Changeset 16294
Legend:
 Unmodified
 Added
 Removed

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs
r16216 r16294 21 21 22 22 using System; 23 using System.Collections.Generic; 23 24 using System.Linq; 24 25 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding; … … 27 28 public static class DerivativeCalculator { 28 29 public static ISymbolicExpressionTree Derive(ISymbolicExpressionTree tree, string variableName) { 30 if (tree.Root.SubtreeCount != 1) 31 throw new NotImplementedException("Derive is not implemented for symbolic expressions with automatically defined functions (ADF)"); 32 if (tree.Root.GetSubtree(0).SubtreeCount != 1) 33 throw new NotImplementedException("Derive is not implemented for multivariate symbolic expressions"); 29 34 var mainBranch = tree.Root.GetSubtree(0).GetSubtree(0); 30 35 var root = new ProgramRootSymbol().CreateTreeNode(); 31 36 root.AddSubtree(new StartSymbol().CreateTreeNode()); 32 37 var dTree = TreeSimplifier.GetSimplifiedTree(Derive(mainBranch, variableName)); 33 // 38 //var dTree = Derive(mainBranch, variableName); 34 39 root.GetSubtree(0).AddSubtree(dTree); 35 40 return new SymbolicExpressionTree(root); 36 41 } 37 42 38 private static Constant constantSy = new Constant(); 39 private static Addition addSy = new Addition(); 40 private static Subtraction subSy = new Subtraction(); 41 private static Multiplication mulSy = new Multiplication(); 42 private static Division divSy = new Division(); 43 private static readonly Constant constantSy = new Constant(); 44 private static readonly Addition addSy = new Addition(); 45 private static readonly Subtraction subSy = new Subtraction(); 46 private static readonly Multiplication mulSy = new Multiplication(); 47 private static readonly Division divSy = new Division(); 48 private static readonly Cosine cosSy = new Cosine(); 49 private static readonly Square sqrSy = new Square(); 43 50 44 51 public static ISymbolicExpressionTreeNode Derive(ISymbolicExpressionTreeNode branch, string variableName) { … … 85 92 } 86 93 return fgPrime; 87 } else throw new ArgumentException(); 94 } else 95 // multiplication with only one argument has no effect > derive the argument 96 return Derive(branch.GetSubtree(0), variableName); 88 97 } 89 98 if (branch.Symbol is Division) { … … 95 104 sqrNode.AddSubtree(g); 96 105 return Div(gPrime, sqrNode); 97 } else if (branch.SubtreeCount == 2) { 106 } else { 107 // for two subtrees: 108 // (f/g)' = (f'g  fg')/g² 109 110 // if there are more than 2 subtrees 111 // div(x,y,z) is interpretered as (x/y)/z 112 // which is the same as x / (y*z) 113 114 // > make a product of all but the first subtree and differentiate as for the 2argument case above 98 115 var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); 99 var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();116 var g = Product(branch.Subtrees.Skip(1).Select(n => (ISymbolicExpressionTreeNode)n.Clone())); 100 117 var fprime = Derive(f, variableName); 101 118 var gprime = Derive(g, variableName); 102 var sqrNode = new Square().CreateTreeNode(); 103 sqrNode.AddSubtree((ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone()); 104 return Div(Subtract(Product(fprime, g), Product(f, gprime)), sqrNode); 105 } else throw new NotSupportedException(); 119 var gSqr = Square(g); 120 return Div(Subtract(Product(fprime, g), Product(f, gprime)), gSqr); 121 } 106 122 } 107 123 if (branch.Symbol is Logarithm) { … … 113 129 return Product(f, Derive(branch.GetSubtree(0), variableName)); 114 130 } 115 if (branch.Symbol is Square) {131 if (branch.Symbol is Square) { 116 132 var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); 117 133 return Product(Product(CreateConstant(2.0), f), Derive(f, variableName)); 118 } 119 if (branch.Symbol is SquareRoot) {134 } 135 if (branch.Symbol is SquareRoot) { 120 136 var f = (ISymbolicExpressionTreeNode)branch.Clone(); 121 137 var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); … … 133 149 sin.AddSubtree(u); 134 150 return Product(CreateConstant(1.0), Product(sin, Derive(u, variableName))); 151 } 152 if (branch.Symbol is Tangent) { 153 // tan(x)' = 1 / cos²(x) 154 var fxp = Derive(branch.GetSubtree(0), variableName); 155 var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); 156 return Div(fxp, Square(Cosine(u))); 135 157 } 136 158 throw new NotSupportedException(string.Format("Symbol {0} is not supported.", branch.Symbol)); … … 144 166 return product; 145 167 } 168 private static ISymbolicExpressionTreeNode Product(IEnumerable<ISymbolicExpressionTreeNode> fs) { 169 var product = mulSy.CreateTreeNode(); 170 foreach (var f in fs) product.AddSubtree(f); 171 return product; 172 } 146 173 private static ISymbolicExpressionTreeNode Div(ISymbolicExpressionTreeNode f, ISymbolicExpressionTreeNode g) { 147 174 var div = divSy.CreateTreeNode(); … … 163 190 return sum; 164 191 } 165 192 private static ISymbolicExpressionTreeNode Cosine(ISymbolicExpressionTreeNode f) { 193 var cos = cosSy.CreateTreeNode(); 194 cos.AddSubtree(f); 195 return cos; 196 } 197 private static ISymbolicExpressionTreeNode Square(ISymbolicExpressionTreeNode f) { 198 var sqr = sqrSy.CreateTreeNode(); 199 sqr.AddSubtree(f); 200 return sqr; 201 } 202 166 203 private static ISymbolicExpressionTreeNode CreateConstant(double v) { 167 204 var constNode = (ConstantTreeNode)constantSy.CreateTreeNode(); … … 186 223 !(n.Symbol is Sine) && 187 224 !(n.Symbol is Cosine) && 225 !(n.Symbol is Tangent) && 188 226 !(n.Symbol is StartSymbol) 189 227 select n).Any(); 
trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic3.4/DeriveTest.cs
r16213 r16294 45 45 Assert.AreEqual("6", Derive("2*3*x", "x")); 46 46 Assert.AreEqual("(10*'y')", Derive("10*x*y+20*y", "x")); 47 Assert.AreEqual("(1 / (SQR('x') * (1)))", 47 Assert.AreEqual("(1 / (SQR('x') * (1)))", Derive("1/x", "x")); 48 48 Assert.AreEqual("('y' / (SQR('x') * (1)))", Derive("y/x", "x")); 49 49 Assert.AreEqual("((((2*'x') + (1)) * ('a' + 'b')) / SQR(('x' + ('x' * 'x'))))", … … 58 58 Assert.AreEqual("(COS((3*'x')) * 3)", Derive("sin(3*x)", "x")); 59 59 Assert.AreEqual("(SIN((3*'x')) * (3))", Derive("cos(3*x)", "x")); 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 60 61 62 { 63 // special case: Inv(x) using only one argument to the division symbol 64 // f(x) = 1/x 65 var root = new ProgramRootSymbol().CreateTreeNode(); 66 var start = new StartSymbol().CreateTreeNode(); 67 var div = new Division().CreateTreeNode(); 68 var varNode = (VariableTreeNode)(new Variable().CreateTreeNode()); 69 varNode.Weight = 1.0; 70 varNode.VariableName = "x"; 71 div.AddSubtree(varNode); 72 start.AddSubtree(div); 73 root.AddSubtree(start); 74 var t = new SymbolicExpressionTree(root); 75 Assert.AreEqual("(1 / (SQR('x') * (1)))", 76 formatter.Format(DerivativeCalculator.Derive(t, "x"))); 77 } 61 78 62 // special case: Inv(x) using only one argument to the division symbol 63 // f(x) = 1/x 64 var root = new ProgramRootSymbol().CreateTreeNode(); 65 var start = new StartSymbol().CreateTreeNode(); 66 var div = new Division().CreateTreeNode(); 67 var varNode = (VariableTreeNode)(new Variable().CreateTreeNode()); 68 varNode.Weight = 1.0; 69 varNode.VariableName = "x"; 70 div.AddSubtree(varNode); 71 start.AddSubtree(div); 72 root.AddSubtree(start); 73 var t = new SymbolicExpressionTree(root); 74 Assert.AreEqual("(1 / (SQR('x') * (1)))", 75 formatter.Format(DerivativeCalculator.Derive(t, "x"))); 79 { 80 // special case: multiplication with only one argument 81 var root = new ProgramRootSymbol().CreateTreeNode(); 82 var start = new StartSymbol().CreateTreeNode(); 83 var mul = new Multiplication().CreateTreeNode(); 84 var varNode = (VariableTreeNode)(new Variable().CreateTreeNode()); 85 varNode.Weight = 3.0; 86 varNode.VariableName = "x"; 87 mul.AddSubtree(varNode); 88 start.AddSubtree(mul); 89 root.AddSubtree(start); 90 var t = new SymbolicExpressionTree(root); 91 Assert.AreEqual("3", 92 formatter.Format(DerivativeCalculator.Derive(t, "x"))); 93 } 94 95 { 96 // division with multiple arguments 97 // div(x, y, z) is interpreted as (x / y) / z 98 var root = new ProgramRootSymbol().CreateTreeNode(); 99 var start = new StartSymbol().CreateTreeNode(); 100 var div = new Division().CreateTreeNode(); 101 var varNode1 = (VariableTreeNode)(new Variable().CreateTreeNode()); 102 varNode1.Weight = 3.0; 103 varNode1.VariableName = "x"; 104 var varNode2 = (VariableTreeNode)(new Variable().CreateTreeNode()); 105 varNode2.Weight = 4.0; 106 varNode2.VariableName = "y"; 107 var varNode3 = (VariableTreeNode)(new Variable().CreateTreeNode()); 108 varNode3.Weight = 5.0; 109 varNode3.VariableName = "z"; 110 div.AddSubtree(varNode1); div.AddSubtree(varNode2); div.AddSubtree(varNode3); 111 start.AddSubtree(div); 112 root.AddSubtree(start); 113 var t = new SymbolicExpressionTree(root); 114 115 Assert.AreEqual("(('y' * 'z' * 60) / SQR(('y' * 'z' * 20)))", // actually 3 / (4y 5z) but simplifier is not smart enough to cancel numerator and denominator 116 // 60 y z / y² z² 20² == 6 / y z 40 == 3 / y z 20 117 formatter.Format(DerivativeCalculator.Derive(t, "x"))); 118 Assert.AreEqual("(('x' * 'z' * (60)) / SQR(('y' * 'z' * 20)))", // actually 3x * (4 5 z) / (4y 5z)² = 3x / (20 y² z) 119 // 3 4 5 x z / 4² y² 5² z² = 60 x z / 20² z² y² == 60 x z / y² z² 20² 120 formatter.Format(DerivativeCalculator.Derive(t, "y"))); 121 Assert.AreEqual("(('x' * 'y' * (60)) / SQR(('y' * 'z' * 20)))", 122 formatter.Format(DerivativeCalculator.Derive(t, "z"))); 123 } 76 124 } 77 125
Note: See TracChangeset
for help on using the changeset viewer.