Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/DeriveTest.cs @ 16737

Last change on this file since 16737 was 16737, checked in by gkronber, 5 years ago

#2948: fixed a bug for products with >2 factors

File size: 7.1 KB
RevLine 
[16206]1#region License Information
2/* HeuristicLab
[16565]3 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[16206]4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22
23using System;
24using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
25using Microsoft.VisualStudio.TestTools.UnitTesting;
26namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Tests {
27
28
29  [TestClass]
30  public class DerivativeTest {
31    [TestMethod]
32    [TestCategory("Problems.DataAnalysis.Symbolic")]
33    [TestProperty("Time", "short")]
34    public void DeriveExpressions() {
35      var formatter = new InfixExpressionFormatter();
36      var parser = new InfixExpressionParser();
[16213]37      Assert.AreEqual("0", Derive("3", "x"));
38      Assert.AreEqual("1", Derive("x", "x"));
39      Assert.AreEqual("10", Derive("10*x", "x"));
40      Assert.AreEqual("10", Derive("x*10", "x"));
41      Assert.AreEqual("(2*'x')", Derive("x*x", "x"));
42      Assert.AreEqual("((('x' * 'x') * 2) + ('x' * 'x'))", Derive("x*x*x", "x")); // simplifier does not merge (x*x)*2 + x*x  to 3*x*x
43      Assert.AreEqual("0", Derive("10*x", "y"));
44      Assert.AreEqual("20", Derive("10*x+20*y", "y"));
45      Assert.AreEqual("6", Derive("2*3*x", "x"));
46      Assert.AreEqual("(10*'y')", Derive("10*x*y+20*y", "x"));
[16294]47      Assert.AreEqual("(1 / (SQR('x') * (-1)))", Derive("1/x", "x"));
[16213]48      Assert.AreEqual("('y' / (SQR('x') * (-1)))", Derive("y/x", "x"));
49      Assert.AreEqual("((((-2*'x') + (-1)) * ('a' + 'b')) / SQR(('x' + ('x' * 'x'))))",
50        Derive("(a+b)/(x+x*x)", "x"));
51      Assert.AreEqual("((((-2*'x') + (-1)) * ('a' + 'b')) / SQR(('x' + SQR('x'))))", Derive("(a+b)/(x+SQR(x))", "x"));
52      Assert.AreEqual("EXP('x')", Derive("exp(x)", "x"));
53      Assert.AreEqual("(EXP((3*'x')) * 3)", Derive("exp(3*x)", "x"));
54      Assert.AreEqual("(1 / 'x')", Derive("log(x)", "x"));
55      Assert.AreEqual("(1 / 'x')", Derive("log(3*x)", "x"));   // 3 * 1/(3*x)
56      Assert.AreEqual("(1 / ('x' + (0.333333333333333*'y')))", Derive("log(3*x+y)", "x"));  // simplifier does not try to keep fractions
57      Assert.AreEqual("(1 / (SQRT(((3*'x') + 'y')) * 0.666666666666667))", Derive("sqrt(3*x+y)", "x"));   // 3 / (2 * sqrt(3*x+y)) = 1 / ((2/3) * sqrt(3*x+y))
58      Assert.AreEqual("(COS((3*'x')) * 3)", Derive("sin(3*x)", "x"));
59      Assert.AreEqual("(SIN((3*'x')) * (-3))", Derive("cos(3*x)", "x"));
[16294]60      Assert.AreEqual("(1 / (SQR(COS((3*'x'))) * 0.333333333333333))", Derive("tan(3*x)", "x")); // diff(tan(f(x)), x) = 1.0 / cos²(f(x)), simplifier puts constant factor into the denominator
[16206]61
[16543]62      Assert.AreEqual("((9*'x') / ABS((3*'x')))", Derive("abs(3*x)", "x"));
63      Assert.AreEqual("(SQR('x') * 3)", Derive("cube(x)", "x"));
64      Assert.AreEqual("(1 / (SQR(CUBEROOT('x')) * 3))", Derive("cuberoot(x)", "x"));
65
[16494]66      Assert.AreEqual("0", Derive("(a+b)/(x+SQR(x))", "y")); // df(a,b,x) / dy = 0
67
[16737]68
69      Assert.AreEqual("('a' * 'b' * 'c')", Derive("a*b*c*d", "d"));
70      Assert.AreEqual("('a' / ('b' * 'c' * SQR('d') * (-1)))", Derive("a/b/c/d", "d"));
71
[16294]72      {
73        // special case: Inv(x) using only one argument to the division symbol
74        // f(x) = 1/x
75        var root = new ProgramRootSymbol().CreateTreeNode();
76        var start = new StartSymbol().CreateTreeNode();
77        var div = new Division().CreateTreeNode();
78        var varNode = (VariableTreeNode)(new Variable().CreateTreeNode());
79        varNode.Weight = 1.0;
80        varNode.VariableName = "x";
81        div.AddSubtree(varNode);
82        start.AddSubtree(div);
83        root.AddSubtree(start);
84        var t = new SymbolicExpressionTree(root);
85        Assert.AreEqual("(1 / (SQR('x') * (-1)))",
86          formatter.Format(DerivativeCalculator.Derive(t, "x")));
87      }
[16213]88
[16294]89      {
90        // special case: multiplication with only one argument
91        var root = new ProgramRootSymbol().CreateTreeNode();
92        var start = new StartSymbol().CreateTreeNode();
93        var mul = new Multiplication().CreateTreeNode();
94        var varNode = (VariableTreeNode)(new Variable().CreateTreeNode());
95        varNode.Weight = 3.0;
96        varNode.VariableName = "x";
97        mul.AddSubtree(varNode);
98        start.AddSubtree(mul);
99        root.AddSubtree(start);
100        var t = new SymbolicExpressionTree(root);
101        Assert.AreEqual("3",
102          formatter.Format(DerivativeCalculator.Derive(t, "x")));
103      }
104
105      {
106        // division with multiple arguments
107        // div(x, y, z) is interpreted as (x / y) / z
108        var root = new ProgramRootSymbol().CreateTreeNode();
109        var start = new StartSymbol().CreateTreeNode();
110        var div = new Division().CreateTreeNode();
111        var varNode1 = (VariableTreeNode)(new Variable().CreateTreeNode());
112        varNode1.Weight = 3.0;
113        varNode1.VariableName = "x";
114        var varNode2 = (VariableTreeNode)(new Variable().CreateTreeNode());
115        varNode2.Weight = 4.0;
116        varNode2.VariableName = "y";
117        var varNode3 = (VariableTreeNode)(new Variable().CreateTreeNode());
118        varNode3.Weight = 5.0;
119        varNode3.VariableName = "z";
120        div.AddSubtree(varNode1); div.AddSubtree(varNode2); div.AddSubtree(varNode3);
121        start.AddSubtree(div);
122        root.AddSubtree(start);
123        var t = new SymbolicExpressionTree(root);
124
[16358]125        Assert.AreEqual("(('y' * 'z' * 60) / (SQR('y') * SQR('z') * 400))", // actually 3 / (4y  5z) but simplifier is not smart enough to cancel numerator and denominator
[16494]126                                                                            // 60 y z / y² z² 20² == 6 / y z 40 == 3 / y z 20
[16294]127          formatter.Format(DerivativeCalculator.Derive(t, "x")));
[16358]128        Assert.AreEqual("(('x' * 'z' * (-60)) / (SQR('y') * SQR('z') * 400))", // actually 3x * -(4 5 z) / (4y 5z)² = -3x / (20 y² z)
[16494]129                                                                               // -3 4 5 x z / 4² y² 5² z² = -60 x z / 20² z² y² ==    -60 x z / y² z² 20²
[16294]130          formatter.Format(DerivativeCalculator.Derive(t, "y")));
[16358]131        Assert.AreEqual("(('x' * 'y' * (-60)) / (SQR('y') * SQR('z') * 400))",
[16294]132          formatter.Format(DerivativeCalculator.Derive(t, "z")));
133      }
[16206]134    }
135
136    private string Derive(string expr, string variable) {
137      var parser = new InfixExpressionParser();
138      var formatter = new InfixExpressionFormatter();
139
140      var t = parser.Parse(expr);
141      var tPrime = DerivativeCalculator.Derive(t, variable);
142
143      return formatter.Format(tPrime);
144    }
145  }
146}
Note: See TracBrowser for help on using the repository browser.