Changeset 16141 for branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis

Timestamp:

09/14/18 11:47:37 (6 years ago)

Author:

abeham

Message:

#2817: updated to trunk r16140

Location:

branches/2817-BinPackingSpeedup

Files:

• . (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4/DoubleArrayExtensions.cs (copied) (copied from trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/DoubleArrayExtensions.cs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineUtil.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs (modified) (1 diff)

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs

@@ -210 +210 @@
     protected override void Run(CancellationToken cancellationToken) {
       // Set up the algorithm
-      if (SetSeedRandomly) Seed = new System.Random().Next();
+      if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
       var rand = new MersenneTwister((uint)Seed);
 
@@ -258 +258 @@
 
           modifiableDataset.RemoveVariable(targetVarName);
-          modifiableDataset.AddVariable(targetVarName, curY.Concat(curYTest));
+          modifiableDataset.AddVariable(targetVarName, curY.Concat(curYTest).ToList());
 
           SampleTrainingData(rand, modifiableDataset, rRows, problemData.Dataset, curY, problemData.TargetVariable, problemData.TrainingIndices); // all training indices from the original problem data are allowed 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs

@@ -186 +186 @@
     protected override void Run(CancellationToken cancellationToken) {
       // Set up the algorithm
-      if (SetSeedRandomly) Seed = new System.Random().Next();
+      if (SetSeedRandomly) Seed = Random.RandomSeedGenerator.GetSeed();
 
       // Set up the results display

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj

@@ -131 +131 @@
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="DoubleArrayExtensions.cs" />
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
     <Compile Include="GaussianProcess\CovarianceFunctions\CovarianceSpectralMixture.cs" />
@@ -320 +321 @@
     <Compile Include="TSNE\Distances\IndexedItemDistance.cs" />
     <Compile Include="TSNE\Distances\ManhattanDistance.cs" />
-  <Compile Include="TSNE\Distances\WeightedEuclideanDistance.cs" />
+    <Compile Include="TSNE\Distances\WeightedEuclideanDistance.cs" />
     <Compile Include="TSNE\Distances\IDistance.cs" />
     <Compile Include="TSNE\PriorityQueue.cs" />

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs

@@ -80 +80 @@
       inputMatrix = factorMatrix.HorzCat(inputMatrix);
 
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Linear discriminant analysis does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs

@@ -80 +80 @@
       var inputMatrix = binaryMatrix.HorzCat(doubleVarMatrix);
 
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset.");
 
@@ -100 +100 @@
       int nVarCoeff = doubleVariables.Count();
       var tree = LinearModelToTreeConverter.CreateTree(factorVariables, coefficients.Take(nFactorCoeff).ToArray(),
-        doubleVariables.ToArray(), coefficients.Skip(nFactorCoeff).Take(nVarCoeff).ToArray(), 
+        doubleVariables.ToArray(), coefficients.Skip(nFactorCoeff).Take(nVarCoeff).ToArray(),
         @const: coefficients[nFeatures]);
-      
+
       SymbolicRegressionSolution solution = new SymbolicRegressionSolution(new SymbolicRegressionModel(problemData.TargetVariable, tree, new SymbolicDataAnalysisExpressionTreeLinearInterpreter()), (IRegressionProblemData)problemData.Clone());
       solution.Model.Name = "Linear Regression Model";

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs

@@ -78 +78 @@
       inputMatrix = factorMatrix.HorzCat(inputMatrix);
 
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Multinomial logit classification does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaModel.cs

@@ -65 +65 @@
 
       var ds = ReduceDataset(dataset, rows);
-      nnModel = new NearestNeighbourModel(ds, Enumerable.Range(0, ds.Rows), k, ds.VariableNames.Last(), ds.VariableNames.Take(transformationMatrix.GetLength(1)), classValues);
+      nnModel = new NearestNeighbourModel(ds, Enumerable.Range(0, ds.Rows), k, ds.VariableNames.Last(), ds.VariableNames.Take(transformationMatrix.GetLength(1)), classValues: classValues);
     }
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs

@@ -130 +130 @@
           // automatic determination of weights (all features should have variance = 1)
           this.weights = this.allowedInputVariables
-            .Select(name => 1.0 / dataset.GetDoubleValues(name, rows).StandardDeviationPop())
+            .Select(name => {
+              var pop = dataset.GetDoubleValues(name, rows).StandardDeviationPop();
+              return  pop.IsAlmost(0) ? 1.0 : 1.0/pop;
+            })
             .Concat(new double[] { 1.0 }) // no scaling for target variable
             .ToArray();
@@ -142 +145 @@
       }
 
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException(
           "Nearest neighbour model does not support NaN or infinity values in the input dataset.");

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs

@@ -115 +115 @@
     public NeuralNetworkClassification()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
@@ -185 +185 @@
       IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = dataset.ToArray(allowedInputVariables.Concat(new string[] { targetVariable }), rows);
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Neural network classification does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs

@@ -171 +171 @@
       IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = dataset.ToArray(allowedInputVariables.Concat(new string[] { targetVariable }), rows);
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Neural network ensemble classification does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs

@@ -102 +102 @@
           x[column] = inputData[row, column];
         }
-        alglib.mlpeprocess(mlpEnsemble, x, ref y);
+        // mlpeprocess writes data in mlpEnsemble and is therefore not thread-safe
+        lock (mlpEnsemble) {
+          alglib.mlpeprocess(mlpEnsemble, x, ref y);
+        }
         yield return y[0];
       }
@@ -119 +122 @@
           x[column] = inputData[row, column];
         }
-        alglib.mlpeprocess(mlpEnsemble, x, ref y);
+        // mlpeprocess writes data in mlpEnsemble and is therefore not thread-safe
+        lock (mlpEnsemble) {
+          alglib.mlpeprocess(mlpEnsemble, x, ref y);
+        }
         // find class for with the largest probability value
         int maxProbClassIndex = 0;

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs

@@ -125 +125 @@
     public NeuralNetworkEnsembleRegression()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
@@ -170 +170 @@
       IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = dataset.ToArray(allowedInputVariables.Concat(new string[] { targetVariable }), rows);
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Neural network ensemble regression does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs

@@ -106 +106 @@
           x[column] = inputData[row, column];
         }
-        alglib.mlpprocess(multiLayerPerceptron, x, ref y);
+        // NOTE: mlpprocess changes data in multiLayerPerceptron and is therefore not thread-save!
+        lock (multiLayerPerceptron) {
+          alglib.mlpprocess(multiLayerPerceptron, x, ref y);
+        }
         yield return y[0];
       }
@@ -112 +115 @@
 
     public override IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
-      double[,] inputData = dataset.ToArray( allowedInputVariables, rows);
+      double[,] inputData = dataset.ToArray(allowedInputVariables, rows);
 
       int n = inputData.GetLength(0);
@@ -123 +126 @@
           x[column] = inputData[row, column];
         }
-        alglib.mlpprocess(multiLayerPerceptron, x, ref y);
+        // NOTE: mlpprocess changes data in multiLayerPerceptron and is therefore not thread-save!
+        lock (multiLayerPerceptron) {
+          alglib.mlpprocess(multiLayerPerceptron, x, ref y);
+        }
         // find class for with the largest probability value
         int maxProbClassIndex = 0;

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs

@@ -115 +115 @@
     public NeuralNetworkRegression()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
@@ -186 +186 @@
       IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = dataset.ToArray(allowedInputVariables.Concat(new string[] { targetVariable }), rows);
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Neural network regression does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs

@@ -186 +186 @@
         qualityTable.Rows.Add(testRMSERow);
         Results.Add(new Result(qualityTable.Name, qualityTable.Name + " for all restarts", qualityTable));
-        if (SetSeedRandomly) Seed = (new System.Random()).Next();
+        if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
         var rand = new MersenneTwister((uint)Seed);
         bestSolution = CreateRegressionSolution(Problem.ProblemData, ModelStructure, Iterations, ApplyLinearScaling, rand);

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs

@@ -135 +135 @@
     protected override void Run(CancellationToken cancellationToken) {
       double rmsError, relClassificationError, outOfBagRmsError, outOfBagRelClassificationError;
-      if (SetSeedRandomly) Seed = new System.Random().Next();
+      if (SetSeedRandomly) Seed = Random.RandomSeedGenerator.GetSeed();
 
       var model = CreateRandomForestClassificationModel(Problem.ProblemData, NumberOfTrees, R, M, Seed, out rmsError, out relClassificationError, out outOfBagRmsError, out outOfBagRelClassificationError);

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs

@@ -310 +310 @@
     public static RandomForestModel CreateClassificationModel(IClassificationProblemData problemData, int nTrees, double r, double m, int seed,
       out double rmsError, out double outOfBagRmsError, out double relClassificationError, out double outOfBagRelClassificationError) {
-      return CreateClassificationModel(problemData, problemData.TrainingIndices, nTrees, r, m, seed, 
+      return CreateClassificationModel(problemData, problemData.TrainingIndices, nTrees, r, m, seed,
         out rmsError, out outOfBagRmsError, out relClassificationError, out outOfBagRelClassificationError);
     }
@@ -370 +370 @@
 
     private static void AssertInputMatrix(double[,] inputMatrix) {
-      if (inputMatrix.Cast<double>().Any(x => Double.IsNaN(x) || Double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Random forest modeling does not support NaN or infinity values in the input dataset.");
     }

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs

@@ -134 +134 @@
     protected override void Run(CancellationToken cancellationToken) {
       double rmsError, avgRelError, outOfBagRmsError, outOfBagAvgRelError;
-      if (SetSeedRandomly) Seed = new System.Random().Next();
+      if (SetSeedRandomly) Seed = Random.RandomSeedGenerator.GetSeed();
       var model = CreateRandomForestRegressionModel(Problem.ProblemData, NumberOfTrees, R, M, Seed,
         out rmsError, out avgRelError, out outOfBagRmsError, out outOfBagAvgRelError);

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs

@@ -155 +155 @@
     private IEnumerable<double> GetEstimatedValuesHelper(IDataset dataset, IEnumerable<int> rows) {
       // calculate predictions for the currently requested rows
-      svm_problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, TargetVariable, allowedInputVariables, rows);
+      svm_problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, allowedInputVariables, rows);
       svm_problem scaledProblem = rangeTransform.Scale(problem);
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineUtil.cs

@@ -35 +35 @@
   public class SupportVectorMachineUtil {
     /// <summary>
-    /// Transforms <paramref name="problemData"/> into a data structure as needed by libSVM.
-    /// </summary>
-    /// <param name="problemData">The problem data to transform</param>
+    /// Transforms <paramref name="dataset"/> into a data structure as needed by libSVM.
+    /// </summary>
+    /// <param name="dataset">The source dataset</param>
+    /// <param name="targetVariable">The target variable</param>
+    /// <param name="inputVariables">The selected input variables to include in the svm_problem.</param>
     /// <param name="rowIndices">The rows of the dataset that should be contained in the resulting SVM-problem</param>
     /// <returns>A problem data type that can be used to train a support vector machine.</returns>
     public static svm_problem CreateSvmProblem(IDataset dataset, string targetVariable, IEnumerable<string> inputVariables, IEnumerable<int> rowIndices) {
-      double[] targetVector = dataset.GetDoubleValues(targetVariable, rowIndices).ToArray();
-      svm_node[][] nodes = new svm_node[targetVector.Length][];
+      double[] targetVector ;
+      var nRows = rowIndices.Count();
+      if (string.IsNullOrEmpty(targetVariable)) {
+        // if the target variable is not set (e.g. for prediction of a trained model) we just use a zero vector
+        targetVector = new double[nRows];
+      } else {
+        targetVector = dataset.GetDoubleValues(targetVariable, rowIndices).ToArray();
+      }
+      svm_node[][] nodes = new svm_node[nRows][];
       int maxNodeIndex = 0;
       int svmProblemRowIndex = 0;
@@ -66 +75 @@
 
     /// <summary>
+    /// Transforms <paramref name="dataset"/> into a data structure as needed by libSVM for prediction.
+    /// </summary>
+    /// <param name="dataset">The problem data to transform</param>
+    /// <param name="inputVariables">The selected input variables to include in the svm_problem.</param>
+    /// <param name="rowIndices">The rows of the dataset that should be contained in the resulting SVM-problem</param>
+    /// <returns>A problem data type that can be used for prediction with a trained support vector machine.</returns>
+    public static svm_problem CreateSvmProblem(IDataset dataset, IEnumerable<string> inputVariables, IEnumerable<int> rowIndices) {
+      // for prediction we don't need a target variable
+      return CreateSvmProblem(dataset, string.Empty, inputVariables, rowIndices);
+    }
+
+    /// <summary>
     /// Instantiate and return a svm_parameter object with default values.
     /// </summary>

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs

@@ -275 +275 @@
       if (wdist != null) wdist.Initialize(problemData);
       if (state == null) {
-        if (SetSeedRandomly) Seed = new System.Random().Next();
+        if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
         var random = new MersenneTwister((uint)Seed);
         var dataset = problemData.Dataset;

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -97 +96 @@
         inputMatrix[i, timeOffset] = targetValues[i + problemData.TrainingPartition.Start];
 
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset.");
 

branches/2817-BinPackingSpeedup/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs

@@ -91 +91 @@
       int[] xyc;
       double[,] inputMatrix = dataset.ToArray(allowedInputVariables, rows);
-      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+      if (inputMatrix.ContainsNanOrInfinity())
         throw new NotSupportedException("k-Means clustering does not support NaN or infinity values in the input dataset.");