Changeset 7682


Ignore:
Timestamp:
04/02/12 10:55:26 (10 years ago)
Author:
sforsten
Message:

#1784:

  • added Problem.Instances.Classification project
  • added classification problem instances
  • added a class Transformer to Problem.Instances
Location:
branches/ProblemInstancesRegressionAndClassification
Files:
20 added
58 edited

Legend:

Unmodified
Added
Removed
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab 3.3.sln

    r7666 r7682  
    1919EndProject
    2020Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.Views-3.4", "HeuristicLab.Problems.Instances.Views\3.4\HeuristicLab.Problems.Instances.Views-3.4.csproj", "{B1BA398F-953F-4C3A-B07B-1E5E17A27DD9}"
     21EndProject
     22Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.Classification-3.4", "HeuristicLab.Problems.Instances.Classification\3.4\HeuristicLab.Problems.Instances.Classification-3.4.csproj", "{1BBFCD5B-8A1C-4225-A682-ADEC7800E683}"
    2123EndProject
    2224Global
     
    120122    {B1BA398F-953F-4C3A-B07B-1E5E17A27DD9}.Release|x64.ActiveCfg = Release|Any CPU
    121123    {B1BA398F-953F-4C3A-B07B-1E5E17A27DD9}.Release|x86.ActiveCfg = Release|Any CPU
     124    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     125    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|Any CPU.Build.0 = Debug|Any CPU
     126    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
     127    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
     128    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|x64.ActiveCfg = Debug|Any CPU
     129    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Debug|x86.ActiveCfg = Debug|Any CPU
     130    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|Any CPU.ActiveCfg = Release|Any CPU
     131    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|Any CPU.Build.0 = Release|Any CPU
     132    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
     133    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|Mixed Platforms.Build.0 = Release|Any CPU
     134    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|x64.ActiveCfg = Release|Any CPU
     135    {1BBFCD5B-8A1C-4225-A682-ADEC7800E683}.Release|x86.ActiveCfg = Release|Any CPU
    122136  EndGlobalSection
    123137  GlobalSection(SolutionProperties) = preSolution
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblem.cs

    r7259 r7682  
    2020#endregion
    2121
     22using System;
     23using System.Collections.Generic;
     24using System.Linq;
    2225using HeuristicLab.Common;
    2326using HeuristicLab.Core;
    2427using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     28using HeuristicLab.Problems.Instances;
    2529
    2630namespace HeuristicLab.Problems.DataAnalysis {
     
    2832  [Item("Classification Problem", "A general classification problem.")]
    2933  [Creatable("Problems")]
    30   public class ClassificationProblem : DataAnalysisProblem<IClassificationProblemData>, IClassificationProblem, IStorableContent {
     34  public class ClassificationProblem : DataAnalysisProblem<IClassificationProblemData>, IClassificationProblem, IStorableContent,
     35    IProblemInstanceConsumer<ClassificationData>, IProblemInstanceExporter<ClassificationData>, IProblemInstanceConsumer {
    3136    public string Filename { get; set; }
    3237
     
    4550      ProblemData = problemData;
    4651    }
     52
     53    public void Load(ClassificationData data) {
     54      Name = data.Name;
     55      Description = data.Description;
     56      Dataset dataset = new Dataset(data.InputVariables, data.Values);
     57      ProblemData = new ClassificationProblemData(dataset, data.AllowedInputVariables, data.TargetVariable);
     58      ProblemData.TrainingPartition.Start = data.TrainingPartitionStart;
     59      ProblemData.TrainingPartition.End = data.TrainingPartitionEnd;
     60      ProblemData.TestPartition.Start = data.TestPartitionStart;
     61      ProblemData.TestPartition.End = data.TestPartitionEnd;
     62      OnReset();
     63    }
     64
     65    public ClassificationData Export() {
     66      if (!ProblemData.InputVariables.Count.Equals(ProblemData.Dataset.DoubleVariables.Count()))
     67        throw new ArgumentException("Not all input variables are double variables! (Export only works with double variables)");
     68
     69      ClassificationData claData = new ClassificationData();
     70      claData.Name = Name;
     71      claData.Description = Description;
     72      claData.TargetVariable = ProblemData.TargetVariable;
     73      claData.InputVariables = ProblemData.InputVariables.Select(x => x.Value).ToArray();
     74      claData.AllowedInputVariables = ProblemData.AllowedInputVariables.ToArray();
     75      claData.TrainingPartitionStart = ProblemData.TrainingPartition.Start;
     76      claData.TrainingPartitionEnd = ProblemData.TrainingPartition.End;
     77      claData.TestPartitionStart = ProblemData.TestPartition.Start;
     78      claData.TestPartitionEnd = ProblemData.TestPartition.End;
     79
     80      List<List<double>> data = new List<List<double>>();
     81      foreach (var variable in ProblemData.Dataset.DoubleVariables) {
     82        data.Add(ProblemData.Dataset.GetDoubleValues(variable).ToList());
     83      }
     84      claData.Values = Transformer.Transformation(data);
     85
     86      return claData;
     87    }
    4788  }
    4889}
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblem.cs

    r7664 r7682  
    7171      regData.Description = Description;
    7272      regData.TargetVariable = ProblemData.TargetVariable;
    73       regData.InputVariables = ProblemData.InputVariables.Select(x => x.Value);
    74       regData.AllowedInputVariables = ProblemData.AllowedInputVariables;
     73      regData.InputVariables = ProblemData.InputVariables.Select(x => x.Value).ToArray();
     74      regData.AllowedInputVariables = ProblemData.AllowedInputVariables.ToArray();
    7575      regData.TrainingPartitionStart = ProblemData.TrainingPartition.Start;
    7676      regData.TrainingPartitionEnd = ProblemData.TrainingPartition.End;
     
    8282        data.Add(ProblemData.Dataset.GetDoubleValues(variable).ToList());
    8383      }
    84       regData.Values = Transformation(data);
     84      regData.Values = Transformer.Transformation(data);
    8585
    8686      return regData;
    8787    }
    88 
    89     public static double[,] Transformation(List<List<double>> data) {
    90       if (!data.All(x => x.Count.Equals(data.First().Count)))
    91         throw new ArgumentException("Can't create jagged array.");
    92       double[,] values = new double[data.First().Count, data.Count];
    93       for (int i = 0; i < values.GetLength(0); i++) {
    94         for (int j = 0; j < values.GetLength(1); j++) {
    95           values[i, j] = data[j][i];
    96         }
    97       }
    98       return values;
    99     }
    10088  }
    10189}
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/ArtificialRegressionDataDescriptor.cs

    r7664 r7682  
    2020#endregion
    2121
    22 
    2322using System.Collections.Generic;
    2423namespace HeuristicLab.Problems.Instances.Regression {
     
    2827
    2928    protected abstract string TargetVariable { get; }
    30     protected abstract IEnumerable<string> InputVariables { get; }
    31     protected abstract IEnumerable<string> AllowedInputVariables { get; }
     29    protected abstract string[] InputVariables { get; }
     30    protected abstract string[] AllowedInputVariables { get; }
    3231    protected abstract int TrainingPartitionStart { get; }
    3332    protected abstract int TrainingPartitionEnd { get; }
     
    4241      regData.AllowedInputVariables = this.AllowedInputVariables;
    4342      regData.TargetVariable = this.TargetVariable;
    44       regData.Values = this.GenerateValues();
     43      regData.Values = Transformer.Transformation(this.GenerateValues());
    4544      regData.TrainingPartitionStart = this.TrainingPartitionStart;
    4645      regData.TrainingPartitionEnd = this.TrainingPartitionEnd;
     
    5049    }
    5150
    52     protected abstract double[,] GenerateValues();
     51    protected abstract List<List<double>> GenerateValues();
    5352  }
    5453}
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionEight.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "F"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "F" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4646    protected override int TestPartitionEnd { get { return 1091; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      data.Add(ValueGenerator.GenerateSteps(1, 100, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionFifteen.cs

    r7664 r7682  
    4141    }
    4242    protected override string TargetVariable { get { return "F"; } }
    43     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "F" }; } }
    44     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     43    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
     44    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4545    protected override int TrainingPartitionStart { get { return 0; } }
    4646    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4848    protected override int TestPartitionEnd { get { return 5000; } }
    4949
    50     protected override double[,] GenerateValues() {
     50    protected override List<List<double>> GenerateValues() {
    5151      List<List<double>> data = new List<List<double>>();
    5252      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6363      data.Add(results);
    6464
    65       return ValueGenerator.Transformation(data);
     65      return data;
    6666    }
    6767  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionFour.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "F"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "F" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 21; } }
     
    4545    protected override int TestPartitionEnd { get { return 2022; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateSteps(-1, 1, 0.1));
     
    5858      data.Add(results);
    5959
    60       return ValueGenerator.Transformation(data);
     60      return data;
    6161    }
    6262  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionSeven.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "F"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "F" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 50; } }
     
    4646    protected override int TestPartitionEnd { get { return 170; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      data.Add(ValueGenerator.GenerateSteps(1, 50, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionSix.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "F"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "Z", "F" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y", "Z" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z", "F" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y", "Z" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 1000; } }
     
    4545    protected override int TestPartitionEnd { get { return 11000; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -1, 1));
     
    6161      data.Add(results);
    6262
    63       return ValueGenerator.Transformation(data);
     63      return data;
    6464    }
    6565  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionSixteen.cs

    r7664 r7682  
    4141    }
    4242    protected override string TargetVariable { get { return "F"; } }
    43     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "F" }; } }
    44     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     43    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
     44    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4545    protected override int TrainingPartitionStart { get { return 0; } }
    4646    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4848    protected override int TestPartitionEnd { get { return 5000; } }
    4949
    50     protected override double[,] GenerateValues() {
     50    protected override List<List<double>> GenerateValues() {
    5151      List<List<double>> data = new List<List<double>>();
    5252      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6363      data.Add(results);
    6464
    65       return ValueGenerator.Transformation(data);
     65      return data;
    6666    }
    6767  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionThirteen.cs

    r7664 r7682  
    4141    }
    4242    protected override string TargetVariable { get { return "F"; } }
    43     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "F" }; } }
    44     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     43    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
     44    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4545    protected override int TrainingPartitionStart { get { return 0; } }
    4646    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4848    protected override int TestPartitionEnd { get { return 5000; } }
    4949
    50     protected override double[,] GenerateValues() {
     50    protected override List<List<double>> GenerateValues() {
    5151      List<List<double>> data = new List<List<double>>();
    5252      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6363      data.Add(results);
    6464
    65       return ValueGenerator.Transformation(data);
     65      return data;
    6666    }
    6767  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Keijzer/KeijzerFunctionTwelve.cs

    r7664 r7682  
    4141    }
    4242    protected override string TargetVariable { get { return "F"; } }
    43     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "F" }; } }
    44     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     43    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
     44    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4545    protected override int TrainingPartitionStart { get { return 0; } }
    4646    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4848    protected override int TestPartitionEnd { get { return 5000; } }
    4949
    50     protected override double[,] GenerateValues() {
     50    protected override List<List<double>> GenerateValues() {
    5151      List<List<double>> data = new List<List<double>>();
    5252      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6363      data.Add(results);
    6464
    65       return ValueGenerator.Transformation(data);
     65      return data;
    6666    }
    6767  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionEight.cs

    r7664 r7682  
    4545    }
    4646    protected override string TargetVariable { get { return "Y"; } }
    47     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    48     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     47    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     48    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4949    protected override int TrainingPartitionStart { get { return 0; } }
    5050    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5252    protected override int TestPartitionEnd { get { return 10000; } }
    5353
    54     protected override double[,] GenerateValues() {
     54    protected override List<List<double>> GenerateValues() {
    5555      List<List<double>> data = new List<List<double>>();
    5656      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6868      data.Add(results);
    6969
    70       return ValueGenerator.Transformation(data);
     70      return data;
    7171    }
    7272  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionEleven.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionFive.cs

    r7664 r7682  
    4545    }
    4646    protected override string TargetVariable { get { return "Y"; } }
    47     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    48     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     47    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     48    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4949    protected override int TrainingPartitionStart { get { return 0; } }
    5050    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5252    protected override int TestPartitionEnd { get { return 10000; } }
    5353
    54     protected override double[,] GenerateValues() {
     54    protected override List<List<double>> GenerateValues() {
    5555      List<List<double>> data = new List<List<double>>();
    5656      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6666      data.Add(results);
    6767
    68       return ValueGenerator.Transformation(data);
     68      return data;
    6969    }
    7070  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionFiveteen.cs

    r7664 r7682  
    4545    }
    4646    protected override string TargetVariable { get { return "Y"; } }
    47     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    48     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     47    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     48    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4949    protected override int TrainingPartitionStart { get { return 0; } }
    5050    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5252    protected override int TestPartitionEnd { get { return 10000; } }
    5353
    54     protected override double[,] GenerateValues() {
     54    protected override List<List<double>> GenerateValues() {
    5555      List<List<double>> data = new List<List<double>>();
    5656      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6969      data.Add(results);
    7070
    71       return ValueGenerator.Transformation(data);
     71      return data;
    7272    }
    7373  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionFour.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionFourteen.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6868      data.Add(results);
    6969
    70       return ValueGenerator.Transformation(data);
     70      return data;
    7171    }
    7272  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionNine.cs

    r7664 r7682  
    4545    }
    4646    protected override string TargetVariable { get { return "Y"; } }
    47     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    48     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     47    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     48    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4949    protected override int TrainingPartitionStart { get { return 0; } }
    5050    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5252    protected override int TestPartitionEnd { get { return 10000; } }
    5353
    54     protected override double[,] GenerateValues() {
     54    protected override List<List<double>> GenerateValues() {
    5555      List<List<double>> data = new List<List<double>>();
    5656      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6969      data.Add(results);
    7070
    71       return ValueGenerator.Transformation(data);
     71      return data;
    7272    }
    7373  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionOne.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionSeven.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionSix.cs

    r7664 r7682  
    4545    }
    4646    protected override string TargetVariable { get { return "Y"; } }
    47     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    48     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     47    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     48    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4949    protected override int TrainingPartitionStart { get { return 0; } }
    5050    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5252    protected override int TestPartitionEnd { get { return 10000; } }
    5353
    54     protected override double[,] GenerateValues() {
     54    protected override List<List<double>> GenerateValues() {
    5555      List<List<double>> data = new List<List<double>>();
    5656      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6666      data.Add(results);
    6767
    68       return ValueGenerator.Transformation(data);
     68      return data;
    6969    }
    7070  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionTen.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6868      data.Add(results);
    6969
    70       return ValueGenerator.Transformation(data);
     70      return data;
    7171    }
    7272  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionThirteen.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6868      data.Add(results);
    6969
    70       return ValueGenerator.Transformation(data);
     70      return data;
    7171    }
    7272  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionThree.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6868      data.Add(results);
    6969
    70       return ValueGenerator.Transformation(data);
     70      return data;
    7171    }
    7272  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionTwelve.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6666      data.Add(results);
    6767
    68       return ValueGenerator.Transformation(data);
     68      return data;
    6969    }
    7070  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Korns/KornsFunctionTwo.cs

    r7664 r7682  
    4444    }
    4545    protected override string TargetVariable { get { return "Y"; } }
    46     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
    47     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X0", "X1", "X2", "X3", "X4" }; } }
     46    protected override string[] InputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4", "Y" }; } }
     47    protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
    4848    protected override int TrainingPartitionStart { get { return 0; } }
    4949    protected override int TrainingPartitionEnd { get { return 5000; } }
     
    5151    protected override int TestPartitionEnd { get { return 10000; } }
    5252
    53     protected override double[,] GenerateValues() {
     53    protected override List<List<double>> GenerateValues() {
    5454      List<List<double>> data = new List<List<double>>();
    5555      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6767      data.Add(results);
    6868
    69       return ValueGenerator.Transformation(data);
     69      return data;
    7070    }
    7171  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionEight.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, 0, 4));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionEleven.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Z"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "Z" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4545    protected override int TestPartitionEnd { get { return 1000; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionFive.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionFour.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionNine.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Z"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "Z" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4545    protected override int TestPartitionEnd { get { return 1000; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionOne.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionSeven.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, 0, 2));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionSix.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionTen.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Z"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "Z" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4545    protected override int TestPartitionEnd { get { return 1000; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(1000, 0, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionThree.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionTwelve.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Z"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "Z" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4545    protected override int TestPartitionEnd { get { return 1000; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(1000, 0, 1));
     
    5959      data.Add(results);
    6060
    61       return ValueGenerator.Transformation(data);
     61      return data;
    6262    }
    6363  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Nguyen/NguyenFunctionTwo.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 20; } }
     
    4545    protected override int TestPartitionEnd { get { return 350; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateUniformDistributedValues(500, -1, 1));
     
    5757      data.Add(results);
    5858
    59       return ValueGenerator.Transformation(data);
     59      return data;
    6060    }
    6161  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Properties/AssemblyInfo.cs

    r7667 r7682  
    5555// [assembly: AssemblyVersion("1.0.*")]
    5656[assembly: AssemblyVersion("3.4.0.0")]
    57 [assembly: AssemblyFileVersion("3.4.0.7666")]
     57[assembly: AssemblyFileVersion("3.4.0.7667")]
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/RegressionInstanceProvider.cs

    r7664 r7682  
    4141        regData.Name = path.Substring(pos, path.Length - pos);
    4242      }
    43       regData.InputVariables = new List<string>(csvFileParser.VariableNames);
     43      regData.InputVariables = new List<string>(csvFileParser.VariableNames).ToArray();
    4444      regData.TargetVariable = csvFileParser.VariableNames.Last();
    45       regData.AllowedInputVariables = regData.InputVariables.Where(x => !x.Equals(regData.TargetVariable));
     45      regData.AllowedInputVariables = regData.InputVariables.Where(x => !x.Equals(regData.TargetVariable)).ToArray();
    4646      //convert to multidimensional array
    4747      List<IList> values = csvFileParser.Values;
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/TrentMcConaghy/TrentMcConaghyInstanceProvider.cs

    r7667 r7682  
    4949
    5050      regData.TargetVariable = regData.InputVariables.First();
    51       regData.AllowedInputVariables = regData.InputVariables.Where(x => !x.Equals(regData.TargetVariable));
     51      regData.AllowedInputVariables = regData.InputVariables.Where(x => !x.Equals(regData.TargetVariable)).ToArray();
    5252
    5353      return regData;
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/ValueGenerator.cs

    r7664 r7682  
    2828  public class ValueGenerator {
    2929    protected static FastRandom rand = new FastRandom();
    30 
    31     public static double[,] Transformation(List<List<double>> data) {
    32       if (!data.All(x => x.Count.Equals(data.First().Count)))
    33         throw new ArgumentException("Can't create jagged array.");
    34       double[,] values = new double[data.First().Count, data.Count];
    35       for (int i = 0; i < values.GetLength(0); i++) {
    36         for (int j = 0; j < values.GetLength(1); j++) {
    37           values[i, j] = data[j][i];
    38         }
    39       }
    40       return values;
    41     }
    4230
    4331    public static List<double> GenerateSteps(double start, double end, double stepWidth) {
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Various/BreimanOne.cs

    r7666 r7682  
    3636    }
    3737    protected override string TargetVariable { get { return "Y"; } }
    38     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10", "Y" }; } }
    39     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10" }; } }
     38    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10", "Y" }; } }
     39    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10" }; } }
    4040    protected override int TrainingPartitionStart { get { return 0; } }
    4141    protected override int TrainingPartitionEnd { get { return 5001; } }
     
    4545    protected static FastRandom rand = new FastRandom();
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      List<int> values = new List<int>() { -1, 1 };
     
    7676      data.Add(results);
    7777
    78       return ValueGenerator.Transformation(data);
     78      return data;
    7979    }
    8080
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Various/PolyTen.cs

    r7666 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 250; } }
     
    4646    protected override int TestPartitionEnd { get { return 500; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6969      data.Add(results);
    7070
    71       return ValueGenerator.Transformation(data);
     71      return data;
    7272    }
    7373  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Various/SpatialCoevolution.cs

    r7666 r7682  
    4242    }
    4343    protected override string TargetVariable { get { return "F"; } }
    44     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y", "F" }; } }
    45     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X", "Y" }; } }
     44    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
     45    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
    4646    protected override int TrainingPartitionStart { get { return 0; } }
    4747    protected override int TrainingPartitionEnd { get { return 250; } }
     
    4949    protected override int TestPartitionEnd { get { return 500; } }
    5050
    51     protected override double[,] GenerateValues() {
     51    protected override List<List<double>> GenerateValues() {
    5252      List<List<double>> data = new List<List<double>>();
    5353
     
    7070      data.Add(results);
    7171
    72       return ValueGenerator.Transformation(data);
     72      return data;
    7373    }
    7474  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/KotanchekFunction.cs

    r7666 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4646    protected override int TestPartitionEnd { get { return 3025; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050
     
    6666      data.Add(results);
    6767
    68       return ValueGenerator.Transformation(data);
     68      return data;
    6969    }
    7070  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/RationalPolynomialThreeDimensional.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "X3", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2", "X3" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "X3", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 300; } }
     
    4646    protected override int TestPartitionEnd { get { return 3700; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050
     
    7676      data.Add(results);
    7777
    78       return ValueGenerator.Transformation(data);
     78      return data;
    7979    }
    8080  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/RationalPolynomialTwoDimensional.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 50; } }
     
    4646    protected override int TestPartitionEnd { get { return 2157; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050
     
    6767      data.Add(results);
    6868
    69       return ValueGenerator.Transformation(data);
     69      return data;
    7070    }
    7171  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/RippleFunction.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 300; } }
     
    4646    protected override int TestPartitionEnd { get { return 1300; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/SalutowiczFunctionOneDimensional.cs

    r7664 r7682  
    3838    }
    3939    protected override string TargetVariable { get { return "Y"; } }
    40     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X", "Y" }; } }
    41     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X" }; } }
     40    protected override string[] InputVariables { get { return new string[] { "X", "Y" }; } }
     41    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
    4242    protected override int TrainingPartitionStart { get { return 0; } }
    4343    protected override int TrainingPartitionEnd { get { return 100; } }
     
    4545    protected override int TestPartitionEnd { get { return 321; } }
    4646
    47     protected override double[,] GenerateValues() {
     47    protected override List<List<double>> GenerateValues() {
    4848      List<List<double>> data = new List<List<double>>();
    4949      data.Add(ValueGenerator.GenerateSteps(0.05, 10, 0.1));
     
    5858      data.Add(results);
    5959
    60       return ValueGenerator.Transformation(data);
     60      return data;
    6161    }
    6262  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/SalutowiczFunctionTwoDimensional.cs

    r7664 r7682  
    4040    }
    4141    protected override string TargetVariable { get { return "Y"; } }
    42     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "Y" }; } }
    43     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2" }; } }
     42    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "Y" }; } }
     43    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2" }; } }
    4444    protected override int TrainingPartitionStart { get { return 0; } }
    4545    protected override int TrainingPartitionEnd { get { return 601; } }
     
    4747    protected override int TestPartitionEnd { get { return 3155; } }
    4848
    49     protected override double[,] GenerateValues() {
     49    protected override List<List<double>> GenerateValues() {
    5050      List<List<double>> data = new List<List<double>>();
    5151      List<List<double>> trainingData = new List<List<double>>() {
     
    7676      data.Add(results);
    7777
    78       return ValueGenerator.Transformation(data);
     78      return data;
    7979    }
    8080  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/SineCosineFunction.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 30; } }
     
    4646    protected override int TestPartitionEnd { get { return 1461; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      List<double> oneVariableTestData = ValueGenerator.GenerateSteps(-0.05, 6.05, 0.02);
     
    6666      data.Add(results);
    6767
    68       return ValueGenerator.Transformation(data);
     68      return data;
    6969    }
    7070  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Regression/3.4/Vladislavleva/UnwrappedBallFunctionFiveDimensional.cs

    r7664 r7682  
    3939    }
    4040    protected override string TargetVariable { get { return "Y"; } }
    41     protected override IEnumerable<string> InputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5", "Y" }; } }
    42     protected override IEnumerable<string> AllowedInputVariables { get { return new List<string>() { "X1", "X2", "X3", "X4", "X5" }; } }
     41    protected override string[] InputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "Y" }; } }
     42    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5" }; } }
    4343    protected override int TrainingPartitionStart { get { return 0; } }
    4444    protected override int TrainingPartitionEnd { get { return 1024; } }
     
    4646    protected override int TestPartitionEnd { get { return 6024; } }
    4747
    48     protected override double[,] GenerateValues() {
     48    protected override List<List<double>> GenerateValues() {
    4949      List<List<double>> data = new List<List<double>>();
    5050      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
     
    6565      data.Add(results);
    6666
    67       return ValueGenerator.Transformation(data);
     67      return data;
    6868    }
    6969  }
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Views/3.4/Plugin.cs

    r7667 r7682  
    2323
    2424namespace HeuristicLab.Problems.Instances.Views {
    25   [Plugin("HeuristicLab.Problems.Instances.Views", "3.4.0.7666")]
     25  [Plugin("HeuristicLab.Problems.Instances.Views", "3.4.0.7667")]
    2626  [PluginFile("HeuristicLab.Problems.Instances.Views-3.4.dll", PluginFileType.Assembly)]
    2727  [PluginDependency("HeuristicLab.Common", "3.3")]
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances.Views/3.4/Properties/AssemblyInfo.cs

    r7667 r7682  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.4.0.0")]
    55 [assembly: AssemblyFileVersion("3.4.2.7666")]
     55[assembly: AssemblyFileVersion("3.4.2.7667")]
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj

    r7664 r7682  
    116116    <Compile Include="IExportable.cs" />
    117117    <Compile Include="TableFileParser.cs" />
     118    <Compile Include="Transformer.cs" />
    118119    <Compile Include="Types\ATSPData.cs" />
     120    <Compile Include="Types\ClassificationData.cs" />
    119121    <Compile Include="Types\RegressionData.cs" />
    120122    <Compile Include="Types\CTAPData.cs" />
  • branches/ProblemInstancesRegressionAndClassification/HeuristicLab.Problems.Instances/3.3/Types/RegressionData.cs

    r7603 r7682  
    2020#endregion
    2121
    22 
    23 using System.Collections.Generic;
    2422namespace HeuristicLab.Problems.Instances {
    2523
     
    3634    /// </summary>
    3735    public string Description { get; set; }
    38 
     36    /// <summary>
     37    /// The target variable of a problem.
     38    /// </summary>
    3939    public string TargetVariable { get; set; }
    40 
    41     public IEnumerable<string> InputVariables { get; set; }
    42 
    43     public IEnumerable<string> AllowedInputVariables { get; set; }
    44 
     40    /// <summary>
     41    /// All variables which are in the problem.
     42    /// </summary>
     43    public string[] InputVariables { get; set; }
     44    /// <summary>
     45    /// All variables which shall be used to solve the problem.
     46    /// (Variables wich are not contained by AllowedInputVariables won't be checked initialy, when the problem is created.)
     47    /// </summary>
     48    public string[] AllowedInputVariables { get; set; }
     49    /// <summary>
     50    /// Start of the trainings partition
     51    /// </summary>
    4552    public int TrainingPartitionStart { get; set; }
     53    /// <summary>
     54    /// End of the trainings partition
     55    /// </summary>
    4656    public int TrainingPartitionEnd { get; set; }
    47 
     57    /// <summary>
     58    /// Start of the test partition
     59    /// </summary>
    4860    public int TestPartitionStart { get; set; }
     61    /// <summary>
     62    /// End of the test partition
     63    /// </summary>
    4964    public int TestPartitionEnd { get; set; }
    50 
     65    /// <summary>
     66    /// Contains all the values of the variables
     67    /// </summary>
    5168    public double[,] Values { get; set; }
    5269  }
Note: See TracChangeset for help on using the changeset viewer.