Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/18/14 12:35:00 (10 years ago)
Author:
ascheibe
Message:

reverted last commit

Location:
branches/HiveStatistics/sources
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/HiveStatistics/sources

  • branches/HiveStatistics/sources/HeuristicLab.Tests

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionCrossoverTest.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2727using HeuristicLab.Core;
    2828using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     29using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2930using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
    3031using HeuristicLab.Random;
    … …  
    3233using ExecutionContext = HeuristicLab.Core.ExecutionContext;
    3334
    34 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
     35namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
    3536  [TestClass()]
    3637  public class SymbolicDataAnalysisExpressionCrossoverTest {
    … …  
    4849
    4950    [TestMethod]
    50     [TestCategory("Problems.DataAnalysis")]
    51     [TestProperty("Time", "long")]
    5251    public void SymbolicDataAnalysisExpressionSemanticSimilarityCrossoverPerformanceTest() {
    5352      var problem = new SymbolicRegressionSingleObjectiveProblem();
    … …  
    5756
    5857    [TestMethod]
    59     [TestCategory("Problems.DataAnalysis")]
    60     [TestProperty("Time", "long")]
    6158    public void SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossoverPerformanceTest() {
    6259      var problem = new SymbolicRegressionSingleObjectiveProblem();
    … …  
    6663
    6764    [TestMethod]
    68     [TestCategory("Problems.DataAnalysis")]
    69     [TestProperty("Time", "long")]
    7065    public void SymbolicDataAnalysisExpressionDeterministicBestCrossoverPerformanceTest() {
    7166      var problem = new SymbolicRegressionSingleObjectiveProblem();
    … …  
    7570
    7671    [TestMethod]
    77     [TestCategory("Problems.DataAnalysis")]
    78     [TestProperty("Time", "long")]
    7972    public void SymbolicDataAnalysisExpressionContextAwareCrossoverPerformanceTest() {
    8073      var problem = new SymbolicRegressionSingleObjectiveProblem();
    … …  
    8477
    8578    [TestMethod]
    86     [TestCategory("Problems.DataAnalysis")]
    87     [TestProperty("Time", "long")]
    8879    public void SymbolicDataAnalysisExpressionDepthConstrainedCrossoverPerformanceTest() {
    8980      var problem = new SymbolicRegressionSingleObjectiveProblem();
    … …  
    146137
    147138      foreach (var tree in trees)
    148         HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Tests.Util.IsValid(tree);
     139        HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_34.Tests.Util.IsValid(tree);
    149140    }
    150141  }

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2525using System.Linq;
    2626using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2728using HeuristicLab.Random;
    2829using Microsoft.VisualStudio.TestTools.UnitTesting;
    29 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
    30 
    31 
    32   [TestClass]
     30namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
     31
     32
     33  [TestClass()]
    3334  public class SymbolicDataAnalysisExpressionTreeInterpreterTest {
    3435    private const int N = 1000;
    3536    private const int Rows = 1000;
    3637    private const int Columns = 50;
    37 
    38     private static Dataset ds = new Dataset(new string[] { "Y", "A", "B" }, new double[,] {
     38    private TestContext testContextInstance;
     39
     40    /// <summary>
     41    ///Gets or sets the test context which provides
     42    ///information about and functionality for the current test run.
     43    ///</summary>
     44    public TestContext TestContext {
     45      get {
     46        return testContextInstance;
     47      }
     48      set {
     49        testContextInstance = value;
     50      }
     51    }
     52
     53    [TestMethod]
     54    public void SymbolicDataAnalysisExpressionTreeInterpreterTypeCoherentGrammarPerformanceTest() {
     55      TypeCoherentGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
     56    }
     57    [TestMethod]
     58    public void SymbolicDataAnalysisExpressionTreeInterpreterFullGrammarPerformanceTest() {
     59      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
     60    }
     61    [TestMethod]
     62    public void SymbolicDataAnalysisExpressionTreeInterpreterArithmeticGrammarPerformanceTest() {
     63      ArithmeticGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
     64    }
     65
     66    [TestMethod]
     67    public void SymbolicDataAnalysisExpressionTreeILEmittingInterpreterTypeCoherentGrammarPerformanceTest() {
     68      TypeCoherentGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
     69    }
     70    [TestMethod]
     71    public void SymbolicDataAnalysisExpressionTreeILEmittingInterpreterFullGrammarPerformanceTest() {
     72      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
     73    }
     74    [TestMethod]
     75    public void SymbolicDataAnalysisExpressionTreeILEmittingInterpreterArithmeticGrammarPerformanceTest() {
     76      ArithmeticGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
     77    }
     78
     79    private void TypeCoherentGrammarPerformanceTest(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
     80      var twister = new MersenneTwister(31415);
     81      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
     82      var grammar = new TypeCoherentExpressionGrammar();
     83      grammar.ConfigureAsDefaultRegressionGrammar();
     84      grammar.MaximumFunctionArguments = 0;
     85      grammar.MaximumFunctionDefinitions = 0;
     86      grammar.MinimumFunctionArguments = 0;
     87      grammar.MinimumFunctionDefinitions = 0;
     88      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
     89      foreach (ISymbolicExpressionTree tree in randomTrees) {
     90        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
     91      }
     92      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
     93      //mkommend: commented due to performance issues on the builder
     94      // Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
     95    }
     96
     97    private void FullGrammarPerformanceTest(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
     98      var twister = new MersenneTwister(31415);
     99      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
     100      var grammar = new FullFunctionalExpressionGrammar();
     101      grammar.MaximumFunctionArguments = 0;
     102      grammar.MaximumFunctionDefinitions = 0;
     103      grammar.MinimumFunctionArguments = 0;
     104      grammar.MinimumFunctionDefinitions = 0;
     105      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
     106      foreach (ISymbolicExpressionTree tree in randomTrees) {
     107        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
     108      }
     109      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
     110      //mkommend: commented due to performance issues on the builder
     111      //Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
     112    }
     113
     114    private void ArithmeticGrammarPerformanceTest(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
     115      var twister = new MersenneTwister(31415);
     116      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
     117      var grammar = new ArithmeticExpressionGrammar();
     118      grammar.MaximumFunctionArguments = 0;
     119      grammar.MaximumFunctionDefinitions = 0;
     120      grammar.MinimumFunctionArguments = 0;
     121      grammar.MinimumFunctionDefinitions = 0;
     122      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
     123      foreach (SymbolicExpressionTree tree in randomTrees) {
     124        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
     125      }
     126
     127      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
     128      //mkommend: commented due to performance issues on the builder
     129      //Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
     130    }
     131
     132
     133    /// <summary>
     134    ///A test for Evaluate
     135    ///</summary>
     136    [TestMethod]
     137    public void SymbolicDataAnalysisExpressionTreeInterpreterEvaluateTest() {
     138      Dataset ds = new Dataset(new string[] { "Y", "A", "B" }, new double[,] {
    39139        { 1.0, 1.0, 1.0 },
    40140        { 2.0, 2.0, 2.0 },
    … …  
    51151      });
    52152
    53     [TestMethod]
    54     [TestCategory("Problems.DataAnalysis.Symbolic")]
    55     [TestProperty("Time", "long")]
    56     public void StandardInterpreterTestTypeCoherentGrammarPerformance() {
    57       TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
    58     }
    59     [TestMethod]
    60     [TestCategory("Problems.DataAnalysis.Symbolic")]
    61     [TestProperty("Time", "long")]
    62     public void StandardInterpreterTestFullGrammarPerformance() {
    63       TestFullGrammarPerformance(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
    64     }
    65     [TestMethod]
    66     [TestCategory("Problems.DataAnalysis.Symbolic")]
    67     [TestProperty("Time", "long")]
    68     public void StandardInterpreterTestArithmeticGrammarPerformance() {
    69       TestArithmeticGrammarPerformance(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
    70     }
    71 
    72 
    73     [TestMethod]
    74     [TestCategory("Problems.DataAnalysis.Symbolic")]
    75     [TestProperty("Time", "long")]
    76     public void ILEmittingInterpreterTestTypeCoherentGrammarPerformance() {
    77       TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
    78     }
    79     [TestMethod]
    80     [TestCategory("Problems.DataAnalysis.Symbolic")]
    81     [TestProperty("Time", "long")]
    82     public void ILEmittingInterpreterTestFullGrammarPerformance() {
    83       TestFullGrammarPerformance(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
    84     }
    85     [TestMethod]
    86     [TestCategory("Problems.DataAnalysis.Symbolic")]
    87     [TestProperty("Time", "long")]
    88     public void ILEmittingInterpreterTestArithmeticGrammarPerformance() {
    89       TestArithmeticGrammarPerformance(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
    90     }
    91 
    92 
    93     [TestMethod]
    94     [TestCategory("Problems.DataAnalysis.Symbolic")]
    95     [TestProperty("Time", "long")]
    96     public void LinearInterpreterTestTypeCoherentGrammarPerformance() {
    97       TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionTreeLinearInterpreter(), 12.5e6);
    98     }
    99     [TestMethod]
    100     [TestCategory("Problems.DataAnalysis.Symbolic")]
    101     [TestProperty("Time", "long")]
    102     public void LinearInterpreterTestFullGrammarPerformance() {
    103       TestFullGrammarPerformance(new SymbolicDataAnalysisExpressionTreeLinearInterpreter(), 12.5e6);
    104     }
    105     [TestMethod]
    106     [TestCategory("Problems.DataAnalysis.Symbolic")]
    107     [TestProperty("Time", "long")]
    108     public void LinearInterpreterTestArithmeticGrammarPerformance() {
    109       TestArithmeticGrammarPerformance(new SymbolicDataAnalysisExpressionTreeLinearInterpreter(), 12.5e6);
    110     }
    111 
    112     private void TestTypeCoherentGrammarPerformance(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
    113       var twister = new MersenneTwister(31415);
    114       var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
    115       var grammar = new TypeCoherentExpressionGrammar();
    116       grammar.ConfigureAsDefaultRegressionGrammar();
    117       grammar.MaximumFunctionArguments = 0;
    118       grammar.MaximumFunctionDefinitions = 0;
    119       grammar.MinimumFunctionArguments = 0;
    120       grammar.MinimumFunctionDefinitions = 0;
    121       var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
    122       foreach (ISymbolicExpressionTree tree in randomTrees) {
    123         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
    124       }
    125       double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
    126       //mkommend: commented due to performance issues on the builder
    127       // Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
    128     }
    129 
    130     private void TestFullGrammarPerformance(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
    131       var twister = new MersenneTwister(31415);
    132       var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
    133       var grammar = new FullFunctionalExpressionGrammar();
    134       grammar.MaximumFunctionArguments = 0;
    135       grammar.MaximumFunctionDefinitions = 0;
    136       grammar.MinimumFunctionArguments = 0;
    137       grammar.MinimumFunctionDefinitions = 0;
    138       var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
    139       foreach (ISymbolicExpressionTree tree in randomTrees) {
    140         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
    141       }
    142       double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
    143       //mkommend: commented due to performance issues on the builder
    144       //Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
    145     }
    146 
    147     private void TestArithmeticGrammarPerformance(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
    148       var twister = new MersenneTwister(31415);
    149       var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
    150       var grammar = new ArithmeticExpressionGrammar();
    151       //grammar.Symbols.OfType<Variable>().First().Enabled = false;
    152       grammar.MaximumFunctionArguments = 0;
    153       grammar.MaximumFunctionDefinitions = 0;
    154       grammar.MinimumFunctionArguments = 0;
    155       grammar.MinimumFunctionDefinitions = 0;
    156       var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
    157       foreach (SymbolicExpressionTree tree in randomTrees) {
    158         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
    159       }
    160 
    161       double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
    162       //mkommend: commented due to performance issues on the builder
    163       //Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
    164     }
    165 
    166 
    167     /// <summary>
    168     ///A test for Evaluate
    169     ///</summary>
    170     [TestMethod]
    171     [TestCategory("Problems.DataAnalysis.Symbolic")]
    172     [TestProperty("Time", "short")]
    173     public void StandardInterpreterTestEvaluation() {
    174153      var interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
    175154      EvaluateTerminals(interpreter, ds);
    … …  
    179158
    180159    [TestMethod]
    181     [TestCategory("Problems.DataAnalysis.Symbolic")]
    182     [TestProperty("Time", "short")]
    183     public void ILEmittingInterpreterTestEvaluation() {
     160    public void SymbolicDataAnalysisExpressionILEmittingTreeInterpreterEvaluateTest() {
     161      Dataset ds = new Dataset(new string[] { "Y", "A", "B" }, new double[,] {
     162        { 1.0, 1.0, 1.0 },
     163        { 2.0, 2.0, 2.0 },
     164        { 3.0, 1.0, 2.0 },
     165        { 4.0, 1.0, 1.0 },
     166        { 5.0, 2.0, 2.0 },
     167        { 6.0, 1.0, 2.0 },
     168        { 7.0, 1.0, 1.0 },
     169        { 8.0, 2.0, 2.0 },
     170        { 9.0, 1.0, 2.0 },
     171        { 10.0, 1.0, 1.0 },
     172        { 11.0, 2.0, 2.0 },
     173        { 12.0, 1.0, 2.0 }
     174      });
     175
    184176      var interpreter = new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter();
    185       EvaluateTerminals(interpreter, ds);
    186       EvaluateOperations(interpreter, ds);
    187     }
    188 
    189     [TestMethod]
    190     [TestCategory("Problems.DataAnalysis.Symbolic")]
    191     [TestProperty("Time", "short")]
    192     public void LinearInterpreterTestEvaluation() {
    193       var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
    194 
    195       //ADFs are not supported by the linear interpreter
    196177      EvaluateTerminals(interpreter, ds);
    197178      EvaluateOperations(interpreter, ds);
    … …  
    317298      Evaluate(interpreter, ds, "(and (log -1.0)  1.0)", 0, -1.0); // (and NaN 1.0)
    318299
     300
    319301      // OR
    320302      Evaluate(interpreter, ds, "(or -1.0 -2.0)", 0, -1.0);
    … …  
    327309      Evaluate(interpreter, ds, "(or (log -1.0))", 0, -1.0); // (or NaN)
    328310      Evaluate(interpreter, ds, "(or (log -1.0)  1.0)", 0, -1.0); // (or NaN 1.0)
    329 
    330       // XOR
    331       Evaluate(interpreter, ds, "(xor -1.0 -2.0)", 0, -1.0);
    332       Evaluate(interpreter, ds, "(xor -1.0 2.0)", 0, 1.0);
    333       Evaluate(interpreter, ds, "(xor 1.0 -2.0)", 0, 1.0);
    334       Evaluate(interpreter, ds, "(xor 1.0 2.0)", 0, -1.0);
    335       Evaluate(interpreter, ds, "(xor 0.0 0.0)", 0, -1.0);
    336       Evaluate(interpreter, ds, "(xor -1.0 -2.0 -3.0)", 0, -1.0);
    337       Evaluate(interpreter, ds, "(xor -1.0 -2.0 3.0)", 0, 1.0);
    338       Evaluate(interpreter, ds, "(xor -1.0 2.0 3.0)", 0, -1.0);
    339       Evaluate(interpreter, ds, "(xor 1.0 2.0 3.0)", 0, 1.0);
    340       Evaluate(interpreter, ds, "(xor (log -1.0))", 0, -1.0);
    341       Evaluate(interpreter, ds, "(xor (log -1.0)  1.0)", 0, 1.0);
    342311
    343312      // sin, cos, tan

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2323using System.Collections.Generic;
    2424using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     25using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2526using Microsoft.VisualStudio.TestTools.UnitTesting;
    2627
    27 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
     28namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
    2829
    2930  [TestClass()]
    3031  public class SymbolicDataAnalysisExpressionTreeSimplifierTest {
    31 
    3232    [TestMethod]
    33     [TestCategory("Problems.DataAnalysis")]
    34     [TestProperty("Time", "short")]
    3533    public void SimplifierAxiomsTest() {
    3634      SymbolicExpressionImporter importer = new SymbolicExpressionImporter();

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionImporter.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2525using System.Linq;
    2626using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    27 
    28 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
     27using HeuristicLab.Problems.DataAnalysis.Symbolic;
     28
     29namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
    2930  internal class SymbolicExpressionImporter {
    3031    private const string VARSTART = "VAR";
    … …  
    7071        {"OR", new Or()},
    7172        {"NOT", new Not()},
    72         {"XOR", new Xor()},
    7373        {"DIFF", new Derivative()},
    7474        {"PROG", new ProgramRootSymbol()},
    … …  
    8585    ProgramRootSymbol programRootSymbol = new ProgramRootSymbol();
    8686    StartSymbol startSymbol = new StartSymbol();
     87
     88    public SymbolicExpressionImporter() {
     89    }
    8790
    8891    internal ISymbolicExpressionTree Import(string str) {

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/Token.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2222using System.Globalization;
    2323
    24 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
     24namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
    2525  internal enum TokenSymbol { LPAR, RPAR, SYMB, NUMBER };
    2626  internal class Token {

  • branches/HiveStatistics/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/Util.cs

    r11202 r11203  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2525using System.Linq;
    2626using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Problems.DataAnalysis.Symbolic;
    2728using HeuristicLab.Random;
    28 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
     29namespace HeuristicLab.Problems.DataAnalysis.Symbolic_34.Tests {
    2930  internal class Util {
    3031
Note: See TracChangeset for help on using the changeset viewer.