Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
10/29/17 21:22:21 (7 years ago)
Author:
gkronber
Message:

#2796 fixed hashing of expressions and unit tests for expression enumeration

Location:
branches/MCTS-SymbReg-2796
Files:
1 added
1 deleted
4 edited

Legend:

Unmodified
Added
Removed

  • branches/MCTS-SymbReg-2796/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis.MCTSSymbReg.csproj

    r15438 r15440  
    104104    <Compile Include="MctsSymbolicRegression\Disassembler.cs" />
    105105    <Compile Include="MctsSymbolicRegression\ExpressionEvaluator.cs" />
     106    <Compile Include="MctsSymbolicRegression\ExprHashSymbolic.cs" />
    106107    <Compile Include="MctsSymbolicRegression\MctsSymbolicRegressionAlgorithm.cs" />
    107108    <Compile Include="MctsSymbolicRegression\MctsSymbolicRegressionStatic.cs" />
    108109    <Compile Include="MctsSymbolicRegression\OpCodes.cs" />
    109     <Compile Include="MctsSymbolicRegression\ExprHash.cs" />
    110110    <Compile Include="MctsSymbolicRegression\SymbolicExpressionGenerator.cs" />
    111111    <Compile Include="MctsSymbolicRegression\Tree.cs" />

  • branches/MCTS-SymbReg-2796/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Automaton.cs

    r15438 r15440  
    424424        v == StateLogTFEnd ||
    425425        v == StateInvTFEnd ||
    426         v == StateExpFEnd
     426        v == StateExpFEnd ||
     427        v == StateLogTEnd ||
     428        v == StateInvTEnd ||
     429        v == StateTermEnd
    427430        ;
    428431    }

  • branches/MCTS-SymbReg-2796/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/MctsSymbolicRegressionStatic.cs

    r15439 r15440  
    587587            // for selected states (EvalStates) we introduce state unification (detection of equivalent states)
    588588            if (automaton.IsEvalState(possibleFollowStates[i])) {
    589               var hc = Hashcode(automaton) * (ulong)tree.state; // TODO fix unit test for structure enumeration
     589              var hc = Hashcode(automaton);
     590              hc = ((hc << 5) + hc) ^ (ulong)tree.state; // TODO fix unit test for structure enumeration
    590591              if (!state.nodes.TryGetValue(hc, out child)) {
     592                // Console.WriteLine("New expression (hash: {0}, state: {1})", Hashcode(automaton), automaton.stateNames[possibleFollowStates[i]]);
    591593                child = new Tree() {
    592594                  state = possibleFollowStates[i],
    … …  
    598600              // only allow forward edges (don't add the child if we would go back in the graph)
    599601              else if (child.level > tree.level) {
     602                // Console.WriteLine("Existing expression (hash: {0}, state: {1})", Hashcode(automaton), automaton.stateNames[possibleFollowStates[i]]);
    600603                // whenever we join paths we need to propagate back the statistics of the existing node through the newly created link
    601604                // to all parents
    602605                BackpropagateStatistics(tree, state, child.visits);
    603606              } else {
     607                // Console.WriteLine("Cycle (hash: {0}, state: {1})", Hashcode(automaton), automaton.stateNames[possibleFollowStates[i]]);
    604608                // prevent cycles
    605609                Debug.Assert(child.level <= tree.level);
    … …  
    688692      int nParams;
    689693      automaton.GetCode(out code, out nParams);
    690       return ExprHash.GetHash(code, nParams);
     694      return (ulong)ExprHashSymbolic.GetHash(code, nParams);
    691695    }
    692696

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

    r15439 r15440  
    374374    [TestCategory("Algorithms.DataAnalysis")]
    375375    [TestProperty("Time", "short")]
    376     public void ExprHashTest() {
     376    public void ExprHashSymbolicTest() {
    377377      int nParams;
    378378      byte[] code;
    … …  
    386386        codeGen.Emit1(OpCodes.Exit);
    387387        codeGen.GetCode(out code, out nParams);
    388         var h1 = ExprHash.GetHash(code, nParams);
     388        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    389389
    390390        codeGen = new CodeGenerator();
    … …  
    394394        codeGen.Emit1(OpCodes.Exit);
    395395        codeGen.GetCode(out code, out nParams);
    396         var h2 = ExprHash.GetHash(code, nParams);
     396        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    397397
    398398        Assert.AreEqual(h1, h2);
    … …  
    407407        codeGen.Emit1(OpCodes.Exit);
    408408        codeGen.GetCode(out code, out nParams);
    409         var h1 = ExprHash.GetHash(code, nParams);
     409        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    410410
    411411        codeGen = new CodeGenerator();
    … …  
    415415        codeGen.Emit1(OpCodes.Exit);
    416416        codeGen.GetCode(out code, out nParams);
    417         var h2 = ExprHash.GetHash(code, nParams);
     417        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    418418
    419419        Assert.AreEqual(h1, h2);
    … …  
    430430        codeGen.Emit1(OpCodes.Exit);
    431431        codeGen.GetCode(out code, out nParams);
    432         var h1 = ExprHash.GetHash(code, nParams);
     432        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    433433
    434434        codeGen = new CodeGenerator();
    … …  
    442442        codeGen.Emit1(OpCodes.Exit);
    443443        codeGen.GetCode(out code, out nParams);
    444         var h2 = ExprHash.GetHash(code, nParams);
     444        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    445445
    446446        Assert.AreEqual(h1, h2);
    … …  
    448448
    449449
    450       {
    451         // div
     450      { // 1/(x1x2) = 1/x1 * 1/x2
    452451        var codeGen = new CodeGenerator();
    453452        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
    … …  
    457456        codeGen.Emit1(OpCodes.Exit);
    458457        codeGen.GetCode(out code, out nParams);
    459         var h1 = ExprHash.GetHash(code, nParams);
     458        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    460459
    461460        codeGen = new CodeGenerator();
    … …  
    467466        codeGen.Emit1(OpCodes.Exit);
    468467        codeGen.GetCode(out code, out nParams);
    469         var h2 = ExprHash.GetHash(code, nParams);
     468        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    470469
    471470        Assert.AreEqual(h1, h2);
    … …  
    480479        codeGen.Emit1(OpCodes.Exit);
    481480        codeGen.GetCode(out code, out nParams);
    482         var h1 = ExprHash.GetHash(code, nParams);
     481        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    483482
    484483        codeGen = new CodeGenerator();
    … …  
    490489        codeGen.GetCode(out code, out nParams);
    491490        codeGen.Emit1(OpCodes.Exit);
    492         var h2 = ExprHash.GetHash(code, nParams);
     491        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    493492
    494493        Assert.AreEqual(h1, h2);
    … …  
    503502        codeGen.Emit1(OpCodes.Exit);
    504503        codeGen.GetCode(out code, out nParams);
    505         var h1 = ExprHash.GetHash(code, nParams);
     504        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    506505
    507506        codeGen = new CodeGenerator();
    … …  
    513512        codeGen.Emit1(OpCodes.Exit);
    514513        codeGen.GetCode(out code, out nParams);
    515         var h2 = ExprHash.GetHash(code, nParams);
     514        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    516515
    517516        Assert.AreEqual(h1, h2);
    … …  
    526525        codeGen.Emit1(OpCodes.Exit);
    527526        codeGen.GetCode(out code, out nParams);
    528         var h1 = ExprHash.GetHash(code, nParams);
     527        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    529528
    530529        codeGen = new CodeGenerator();
    … …  
    532531        codeGen.Emit1(OpCodes.Exit);
    533532        codeGen.GetCode(out code, out nParams);
    534         var h2 = ExprHash.GetHash(code, nParams);
     533        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    535534
    536535        Assert.AreEqual(h1, h2);
    … …  
    550549        codeGen.Emit1(OpCodes.Exit);
    551550        codeGen.GetCode(out code, out nParams);
    552         var h1 = ExprHash.GetHash(code, nParams);
     551        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    553552
    554553        codeGen = new CodeGenerator();
    … …  
    558557        codeGen.Emit1(OpCodes.Exit);
    559558        codeGen.GetCode(out code, out nParams);
    560         var h2 = ExprHash.GetHash(code, nParams);
     559        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    561560
    562561        Assert.AreEqual(h1, h2);
    563562      }
    564563
    565       {
     564      { // c1 x1 + c2 x1 = c3 x1 (extended version)
    566565        var codeGen = new CodeGenerator();
    567566        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
    … …  
    582581        codeGen.Emit1(OpCodes.Exit);
    583582        codeGen.GetCode(out code, out nParams);
    584         var h1 = ExprHash.GetHash(code, nParams);
     583        var h1 = ExprHashSymbolic.GetHash(code, nParams);
    585584
    586585        codeGen = new CodeGenerator();
    … …  
    594593        codeGen.Emit1(OpCodes.Exit);
    595594        codeGen.GetCode(out code, out nParams);
    596         var h2 = ExprHash.GetHash(code, nParams);
     595        var h2 = ExprHashSymbolic.GetHash(code, nParams);
    597596
    598597        Assert.AreEqual(h1, h2);
    599598      }
     599      {
     600        // exp(x1) * exp(x1) = exp(x1)
     601        var codeGen = new CodeGenerator();
     602        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     603        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     604        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     605        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     606        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     607        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     608
     609        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     610        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     611        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     612        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     613
     614        codeGen.Emit1(OpCodes.Mul);
     615
     616        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     617        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     618
     619        codeGen.Emit1(OpCodes.Exit);
     620        codeGen.GetCode(out code, out nParams);
     621        var h1 = ExprHashSymbolic.GetHash(code, nParams);
     622
     623        codeGen = new CodeGenerator();
     624        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     625        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     626        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     627        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     628        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     629        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     630        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     631        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     632        codeGen.Emit1(OpCodes.Exit);
     633        codeGen.GetCode(out code, out nParams);
     634        var h2 = ExprHashSymbolic.GetHash(code, nParams);
     635
     636        Assert.AreEqual(h1, h2);
     637      }
     638      {
     639        // inv(x1) + inv(x1) != inv(x1)
     640        var codeGen = new CodeGenerator();
     641        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     642        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     643        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     644        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     645        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     646        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Inv);
     647
     648        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     649        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     650        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     651        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Inv);
     652
     653        codeGen.Emit1(OpCodes.Add);
     654
     655        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     656        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     657
     658        codeGen.Emit1(OpCodes.Exit);
     659        codeGen.GetCode(out code, out nParams);
     660        var h1 = ExprHashSymbolic.GetHash(code, nParams);
     661
     662        codeGen = new CodeGenerator();
     663        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     664        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     665        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     666        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     667        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     668        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Inv);
     669        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     670        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     671        codeGen.Emit1(OpCodes.Exit);
     672        codeGen.GetCode(out code, out nParams);
     673        var h2 = ExprHashSymbolic.GetHash(code, nParams);
     674
     675        Assert.AreNotEqual(h1, h2);
     676      }
     677
     678      {
     679        // exp(x1) + exp(x1) != exp(x1)
     680        var codeGen = new CodeGenerator();
     681        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     682        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     683        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     684        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     685        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     686        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     687        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     688
     689        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     690        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     691        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     692        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     693        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     694        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     695
     696        codeGen.Emit1(OpCodes.Add);
     697        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     698
     699        codeGen.Emit1(OpCodes.Exit);
     700        codeGen.GetCode(out code, out nParams);
     701        var h1 = ExprHashSymbolic.GetHash(code, nParams);
     702
     703        codeGen = new CodeGenerator();
     704        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     705        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     706        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     707        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     708        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     709        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Exp);
     710        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     711        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     712        codeGen.Emit1(OpCodes.Exit);
     713        codeGen.GetCode(out code, out nParams);
     714        var h2 = ExprHashSymbolic.GetHash(code, nParams);
     715
     716        Assert.AreNotEqual(h1, h2);
     717      }
     718      {
     719        // log(x1) + log(x1) != log(x1)
     720        var codeGen = new CodeGenerator();
     721        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     722        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     723        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     724        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     725        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     726        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Log);
     727
     728        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     729        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     730        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     731        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Log);
     732
     733        codeGen.Emit1(OpCodes.Add);
     734
     735        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     736        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     737
     738        codeGen.Emit1(OpCodes.Exit);
     739        codeGen.GetCode(out code, out nParams);
     740        var h1 = ExprHashSymbolic.GetHash(code, nParams);
     741
     742        codeGen = new CodeGenerator();
     743        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst0);
     744        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadConst1);
     745        codeGen.Emit1(MctsSymbolicRegression.OpCodes.LoadParamN);
     746        codeGen.Emit2(MctsSymbolicRegression.OpCodes.LoadVar, 1);
     747        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     748        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Log);
     749        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Mul);
     750        codeGen.Emit1(MctsSymbolicRegression.OpCodes.Add);
     751        codeGen.Emit1(OpCodes.Exit);
     752        codeGen.GetCode(out code, out nParams);
     753        var h2 = ExprHashSymbolic.GetHash(code, nParams);
     754
     755        Assert.AreNotEqual(h1, h2);
     756      }
     757
    600758    }
    601759    #endregion
    … …  
    662820        // log(x + c) * exp(x)
    663821        // log(x + c) * 1/(x + c)
    664         // log(x + c) + log(x + c)                        // TODO
     822        // log(x + c) + log(x + c)                       
    665823        // log(x + c) + exp(x)
    666824        // log(x + c) + 1/(x+c)
    667825        //              -- 6
    668         // exp(x) * 1/(x+c)
    669         // exp(cx) + exp(cx)                              // TODO
     826        // exp(cx) * 1/(x+c)
     827        // exp(cx) + exp(cx)                             
    670828        // exp(cx) + 1/(x+c)
    671829        //              -- 3
    672         // 1/(x+c) * 1/(x+c)                              // TODO
    673         // 1/(x+c) + 1/(x+c)                              // TODO
     830        // 1/(x+c) * 1/(x+c)                             
     831        // 1/(x+c) + 1/(x+c)                             
    674832        //              -- 2
    675833        // log(x*x)
    … …  
    679837
    680838
    681         TestMctsNumberOfSolutions(regProblem, 2, 27);
     839        TestMctsNumberOfSolutions(regProblem, 2, 25);
    682840      }
    683841      {
    … …  
    688846        //              -- 2
    689847        // x * x
    690         // x + x                                            ?
    691848        // x * exp(x)
    692849        // x + exp(x)
    693         // exp(x) * exp(x)
    694         // exp(x) + exp(x)                                  ?
     850        // exp(x) + exp(x)
    695851        // exp(x*x)
    696         //              -- 7
     852        //              -- 5
    697853        // x * x * x
    698854        // x + x * x                                       
    699         // x + x + x                                        ?
    700855        // x * x * exp(x)
    701856        // x + x * exp(x)                                   
    702         // x + x + exp(x)                                   ?
    703857        // exp(x) + x*x
    704858        // exp(x) + x*exp(x)                               
    705         // x + exp(x) * exp(x)                             
    706         // x + exp(x) + exp(x)                              ?
    707         // x * exp(x) * exp(x)
     859        // x + exp(x) + exp(x)                             
    708860        // x * exp(x*x)
    709861        // x + exp(x*x)
    710         //              -- 13
    711 
    712         // exp(x) * exp(x) * exp(x)
    713         // exp(x) + exp(x) * exp(x)                         
    714         // exp(x) + exp(x) + exp(x)                         ?
    715         //              -- 3
     862        //              -- 9
     863
     864        // exp(x) + exp(x) + exp(x)                         
     865        //              -- 1
    716866
    717867        // exp(x)   * exp(x*x)
    … …  
    720870        // exp(x*x*x)
    721871        //              -- 1
    722         TestMctsNumberOfSolutions(regProblem, 3, 2 + 7 + 13 + 3 + 2 + 1, allowLog: false, allowInv: false);
     872        TestMctsNumberOfSolutions(regProblem, 3, 2+5+9+1+2+1, allowLog: false, allowInv: false);
    723873      }     
    724874    }
    … …  
    762912        // exp(y)
    763913        //                  -- 4
    764         // x (*|+) x
     914        // x (*) x
    765915        // x (*|+) exp(x)
    766916        // x (*|+) y
    767917        // x (*|+) exp(y)
    768         //                  -- 8
    769         // exp(x) (*|+) exp(x)
     918        //                  -- 7
     919        // exp(x) (+) exp(x)
    770920        // exp(x) (*|+) exp(y)
    771         //                  -- 4
    772         // y (*|+) y
     921        //                  -- 3
     922        // y (*) y
    773923        // y (*|+) exp(x)
    774924        // y (*|+) exp(y)
    775         //                  -- 6
    776         // exp(y) (*|+) exp(y)
    777         //                  -- 2
     925        //                  -- 5
     926        // exp(y) (+) exp(y)
     927        //                  -- 1
    778928        //
    779929        // exp(x*x)
    … …  
    782932        //                  -- 3
    783933
    784         TestMctsNumberOfSolutions(regProblem, 2, 4 + 8 + 4 + 6 + 2 + 3, allowLog: false, allowInv: false);
     934        TestMctsNumberOfSolutions(regProblem, 2, 4 + 7 + 3 + 5 + 1 + 3, allowLog: false, allowInv: false);
    785935      }
    786936
    … …  
    830980        // inv(y*y)
    831981        //             -- 6
    832         // log(x+x)
    833982        // log(x+y)
    834         // log(y+y)
    835 
    836         // inv(x+x)
    837983        // inv(x+y)
    838         // inv(y+y)
    839         //             -- 6
    840         TestMctsNumberOfSolutions(regProblem, 2, 6 + 6 + 4 + 2 + 5 + 3 + 1 + 6 + 6, allowExp: false, allowSum: false);
     984        //             -- 2
     985        TestMctsNumberOfSolutions(regProblem, 2, 6 + 6 + 4 + 2 + 5 + 3 + 1 + 6 + 2, allowExp: false, allowSum: false);
    841986      }
    842987    }
Note: See TracChangeset for help on using the changeset viewer.