Changeset 15403 for branches/MCTS-SymbReg-2796/Tests

Timestamp:

10/04/17 22:00:52 (7 years ago)

Author:

gkronber

Message:

#2796 worked on MCTS symb reg

Location:

branches/MCTS-SymbReg-2796

Files:

• . (modified) (1 prop)
• Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/MctsSymbolicRegressionTest.cs (modified) (11 diffs)
• Tests/Properties (added)
• Tests/Properties/AssemblyInfo.cs (added)
• Tests/Test.csproj (added)

branches/MCTS-SymbReg-2796/Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/MctsSymbolicRegressionTest.cs

@@ -1 +1 @@
 using System;
-using System.Diagnostics.Contracts;
 using System.Linq;
 using System.Threading;
@@ -8 +7 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Tests;
+using HeuristicLab.Problems.Instances.DataAnalysis;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -21 +20 @@
     public void MctsSymbRegNumberOfSolutionsOneVariable() {
       // this problem has only one variable
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
+      var provider = new NguyenInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F1 ")));
       {
@@ -276 +275 @@
 
 
-    #region Nguyen
+    #region test structure search (no constants)
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbReg_NoConstants_Nguyen1() {
+      // x³ + x² + x
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F1 ")));
+      TestMctsWithoutConstants(regProblem, allowExp: false, allowLog: false, allowInv: false);
+    }
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbReg_NoConstants_Nguyen2() {
+      // x^4 + x³ + x² + x
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F2 ")));
+      TestMctsWithoutConstants(regProblem, allowExp: false, allowLog: false, allowInv: false);
+    }
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbReg_NoConstants_Nguyen3() {
+      // x^5 + x^4 + x³ + x² + x
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F3 ")));
+      TestMctsWithoutConstants(regProblem, allowExp: false, allowLog: false, allowInv: false);
+    }
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbReg_NoConstants_Nguyen4() {
+      // x^6 + x^5 + x^4 + x³ + x² + x
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F4 ")));
+      TestMctsWithoutConstants(regProblem, allowExp: false, allowLog: false, allowInv: false);
+    }
+
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbReg_NoConstants_Poly10() {
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
+      TestMctsWithoutConstants(regProblem, allowExp: false, allowLog: false, allowInv: false);
+    }
+    #endregion
+
+    #region restricted structure but including numeric constants
+
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbRegKeijzer7() {
+      // ln(x)
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 7 f(")));
+      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
+      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
+      TestMcts(regProblem, allowExp: false, allowLog: true, allowInv: false);
+    }
+
+    /*
     // [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen1() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F1 ")));
-      TestMcts(regProblem);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen2() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F2 ")));
-      TestMcts(regProblem);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen3() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F3 ")));
-      TestMcts(regProblem, successThreshold: 0.99);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen4() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F4 ")));
-      TestMcts(regProblem);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen5() {
+      // sin(x²)cos(x) - 1
       var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F5 ")));
@@ -321 +351 @@
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen6() {
+      // sin(x) + sin(x + x²)
       var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F6 ")));
       TestMcts(regProblem);
     }
+    */
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbRegBenchmarkNguyen7() {
+      //  log(x + 1) + log(x² + 1)
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
+      TestMcts(regProblem, maxVariableReferences:5, allowExp: false, allowLog: true, allowInv: false);
+    }
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void MctsSymbRegBenchmarkNguyen8() {
+      // Sqrt(x)
+      // = x ^ 0.5
+      // = exp(0.5 * log(x))
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
+      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F8 ")));
+      TestMcts(regProblem, maxVariableReferences: 5, allowExp: true, allowLog: true, allowInv: false);
+    }
+    /*
     // [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen7() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
-      TestMcts(regProblem);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkNguyen8() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F8 ")));
-      TestMcts(regProblem, successThreshold: 0.99);
-    }
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen9() {
+      //  sin(x) + sin(y²)
       var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F9 ")));
-      TestMcts(regProblem, iterations: 10000);
+      TestMcts(regProblem);
     }
     // [TestMethod]
@@ -353 +391 @@
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen10() {
+      // 2sin(x)cos(y)
       var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F10 ")));
       TestMcts(regProblem);
     }
-    // [TestMethod]
+    */
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen11() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
+      // x ^ y  , x > 0, y > 0   
+      // = exp(y * log(x))
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F11 ")));
-      TestMcts(regProblem, 10000, 0.95); // cannot solve exactly in 10000 iterations
-    }
-    // [TestMethod]
+      TestMcts(regProblem, maxVariableReferences: 5, allowExp: true, allowLog: true, allowInv: false); 
+    }
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkNguyen12() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
+      // x^4 - x³ + y²/2 - y
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F12 ")));
-      TestMcts(regProblem, iterations: 10000, successThreshold: 0.99, allowLog: false, allowExp: false, allowInv: false);
+      TestMcts(regProblem, maxVariableReferences: 20, allowExp: false, allowLog: false, allowInv: false);
     }
 
@@ -377 +420 @@
 
     #region keijzer
-    // [TestMethod]
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "long")]
     public void MctsSymbRegBenchmarkKeijzer5() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // (30 * x * z) / ((x - 10)  * y²)
+      // = 30 x z / (xy² - y²)
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 5 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem, iterations: 10000, allowExp: false, allowLog: false, allowSum: false, successThreshold: 0.99);
-    }
-
-    // [TestMethod]
+      TestMcts(regProblem, maxVariableReferences: 20, allowExp: false, allowLog: false, allowInv: true);
+    }
+
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer6() {
-      // Keijzer 6 f(x) = Sum(1 / i) From 1 to X
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // Keijzer 6 f(x) = Sum(1 / i) From 1 to X  , x \in [0..120]
+      // we can only approximate this
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 6 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem, allowLog: false, allowExp: false, successThreshold: 0.995); // cannot solve
-    }
-
-    // [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkKeijzer7() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 7 f(")));
-      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
-      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem);
-    }
-
-    [TestMethod]
-    // [TestCategory("Algorithms.DataAnalysis")]
+      TestMcts(regProblem, maxVariableReferences: 20, allowExp: false, allowLog: false, allowInv: true);
+    }
+
+
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer8() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // sqrt(x)
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 8 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem);
-    }
-
-    [TestMethod]
-    // [TestCategory("Algorithms.DataAnalysis")]
+      TestMcts(regProblem, maxVariableReferences: 5, allowExp: true, allowLog: true, allowInv: false);
+    }
+
+    [TestMethod]
+    [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer9() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // arcsinh(x)  i.e. ln(x + sqrt(x² + 1))
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 9 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem);
-    }
-
-    /*
-     * cannot solve this yet x^y
-    [TestMethod]
-    [TestCategory("Algorithms.DataAnalysis")]
-    [TestProperty("Time", "short")]
-    public void MctsSymbRegBenchmarkKeijzer10() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
-      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 10 f(")));
-      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
-      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem, iterations: 10000, successThreshold: 0.99);
-    }
-     */
-
-    /* cannot solve this yet
-     * xy + sin( (x-1) (y-1) )
+      TestMcts(regProblem, maxVariableReferences: 5, allowExp: true, allowLog: true, allowInv: false);
+    }
+
+    /* 
     [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer11() {
+      // xy + sin( (x-1) (y-1) )
       var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 11 f(")));
@@ -460 +484 @@
     }
      */
-    // [TestMethod]
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer12() {
-      // sames a Nguyen 12
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // x^4 - x³ + y² / 2 - y,  same as Nguyen 12             
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 12 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem, iterations: 10000, allowLog: false, allowExp: false, allowInv: false, successThreshold: 0.99); // cannot solve exactly in 10000 iterations
-    }
-    // [TestMethod]
+      TestMcts(regProblem, maxVariableReferences: 15, allowExp: false, allowLog: false, allowInv: false);
+    }
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer14() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // 8 / (2 + x² + y²)
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 14 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem);
-    }
-    // [TestMethod]
+      TestMcts(regProblem, maxVariableReferences: 10, allowExp: false, allowLog: false, allowInv: true);
+    }
+    [TestMethod]
     [TestCategory("Algorithms.DataAnalysis")]
     [TestProperty("Time", "short")]
     public void MctsSymbRegBenchmarkKeijzer15() {
-      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
+      // x³ / 5 + y³ / 2 - y - x
+      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(seed: 1234);
       var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 15 f(")));
       // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
       if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
-      TestMcts(regProblem, iterations: 10000, allowLog: false, allowExp: false, allowInv: false);
+      TestMcts(regProblem, maxVariableReferences: 10, allowExp: false, allowLog: false, allowInv: false);
     }
     #endregion
 
-    private void TestMcts(IRegressionProblemData problemData, int iterations = 2000, double successThreshold = 0.999,
+    private void TestMcts(IRegressionProblemData problemData,
+      int iterations = 20000,
+      double successThreshold = 0.99999,
+      int maxVariableReferences = 5,
       bool allowExp = true,
       bool allowLog = true,
@@ -505 +534 @@
       mctsSymbReg.Problem = regProblem;
       mctsSymbReg.Iterations = iterations;
-      mctsSymbReg.MaxVariableReferences = 10;
-      var ucbPolicy = new Ucb();
-      ucbPolicy.C = 2;
-      mctsSymbReg.Policy = ucbPolicy;
+      mctsSymbReg.MaxVariableReferences = maxVariableReferences;
+
       mctsSymbReg.SetSeedRandomly = false;
       mctsSymbReg.Seed = 1234;
@@ -514 +541 @@
       mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("log")), allowLog);
       mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("1 /")), allowInv);
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("sum of multiple")), allowSum);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("t1(x) + t2(x) + ... ")), allowSum);
+
+      mctsSymbReg.ScaleVariables = true;
+      mctsSymbReg.ConstantOptimizationIterations = 0;
+
       #endregion
       RunAlgorithm(mctsSymbReg);
 
       Console.WriteLine(mctsSymbReg.ExecutionTime);
-      // R² >= 0.999
-      // using arequal to get output of the actual value
+      var eps = 1.0 - successThreshold;
+      Assert.AreEqual(1.0, ((DoubleValue)mctsSymbReg.Results["Best solution quality (train)"].Value).Value, eps);
+      Assert.AreEqual(1.0, ((DoubleValue)mctsSymbReg.Results["Best solution quality (test)"].Value).Value, eps);
+    }
+
+
+    private void TestMctsWithoutConstants(IRegressionProblemData problemData, int iterations = 200000, double successThreshold = 0.99999,
+      bool allowExp = true,
+      bool allowLog = true,
+      bool allowInv = true,
+      bool allowSum = true
+      ) {
+      var mctsSymbReg = new MctsSymbolicRegressionAlgorithm();
+      var regProblem = new RegressionProblem();
+      regProblem.ProblemDataParameter.Value = problemData;
+      #region Algorithm Configuration
+      mctsSymbReg.Problem = regProblem;
+      mctsSymbReg.Iterations = iterations;
+      mctsSymbReg.MaxVariableReferences = 25;
+      mctsSymbReg.SetSeedRandomly = false;
+      mctsSymbReg.Seed = 1234;
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("exp")), allowExp);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("log")), allowLog);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("1 /")), allowInv);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("t1(x) + t2(x) + ... ")), allowSum);
+
+      // no constants
+      mctsSymbReg.ScaleVariables = false;
+      mctsSymbReg.ConstantOptimizationIterations = -1;
+
+      #endregion
+      RunAlgorithm(mctsSymbReg);
+
+      Console.WriteLine(mctsSymbReg.ExecutionTime);
       var eps = 1.0 - successThreshold;
       Assert.AreEqual(1.0, ((DoubleValue)mctsSymbReg.Results["Best solution quality (train)"].Value).Value, eps);
@@ -546 +609 @@
       ucbPolicy.C = 1000; // essentially breadth first search
       mctsSymbReg.Policy = ucbPolicy;
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.StartsWith("prod")), allowProd);
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("exp")), allowExp);
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("log")), allowLog);
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("1 /")), allowInv);
-      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("sum of multiple")), allowSum);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.StartsWith("x * y * ...")), allowProd);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("exp(c * x * y ...)")), allowExp);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("log(c + c1 x + c2 x + ...)")), allowLog);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("1 / (1 + c1 x + c2 x + ...)")), allowInv);
+      mctsSymbReg.AllowedFactors.SetItemCheckedState(mctsSymbReg.AllowedFactors.Single(s => s.Value.Contains("t1(x) + t2(x) + ... ")), allowSum);
       #endregion
       RunAlgorithm(mctsSymbReg);