private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) { // remove old ADFs while (tempTree.Root.SubtreeCount > 1) { tempTree.Root.RemoveSubtree(1); } // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } var start = tempTree.Root.GetSubtree(0); while (start.SubtreeCount > 0) { start.RemoveSubtree(0); } start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var interpreter = Content.Model.Interpreter; var rows = Content.ProblemData.TrainingIndices; var allPrognosedValues = interpreter.GetSymbolicExpressionTreeValues(tempTree, Content.ProblemData.Dataset, rows); return(allPrognosedValues.Median()); }
protected static double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataset dataset, IEnumerable <int> rows) { //optimization: constant nodes return always the same value ConstantTreeNode constantNode = node as ConstantTreeNode; if (constantNode != null) { return(constantNode.Value); } var rootSymbol = new ProgramRootSymbol().CreateTreeNode(); var startSymbol = new StartSymbol().CreateTreeNode(); rootSymbol.AddSubtree(startSymbol); startSymbol.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var tempTree = new SymbolicExpressionTree(rootSymbol); // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } return(interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median()); }
protected IEnumerable <double> CalculateReplacementValues(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataset dataset, IEnumerable <int> rows) { //optimization: constant nodes return always the same value ConstantTreeNode constantNode = node as ConstantTreeNode; BinaryFactorVariableTreeNode binaryFactorNode = node as BinaryFactorVariableTreeNode; FactorVariableTreeNode factorNode = node as FactorVariableTreeNode; if (constantNode != null) { yield return(constantNode.Value); } else if (binaryFactorNode != null) { // valid replacements are either all off or all on yield return(0); yield return(1); } else if (factorNode != null) { foreach (var w in factorNode.Weights) { yield return(w); } yield return(0.0); } else { var rootSymbol = new ProgramRootSymbol().CreateTreeNode(); var startSymbol = new StartSymbol().CreateTreeNode(); rootSymbol.AddSubtree(startSymbol); startSymbol.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var tempTree = new SymbolicExpressionTree(rootSymbol); // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } yield return(interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median()); yield return(interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Average()); // TODO perf } }
protected static double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataset dataset, IEnumerable<int> rows) { //optimization: constant nodes return always the same value ConstantTreeNode constantNode = node as ConstantTreeNode; if (constantNode != null) return constantNode.Value; var rootSymbol = new ProgramRootSymbol().CreateTreeNode(); var startSymbol = new StartSymbol().CreateTreeNode(); rootSymbol.AddSubtree(startSymbol); startSymbol.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var tempTree = new SymbolicExpressionTree(rootSymbol); // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } return interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median(); }
private void pasteToolStripMenuItem_Clicked(object sender, EventArgs e) { if (!(lastOp == EditOp.CopySubtree || lastOp == EditOp.CutSubtree)) { return; } // check if the copied/cut node (stored in the tempNode) can be inserted as a child of the current selected node var node = currSelected.Content; if (node is ConstantTreeNode || node is VariableTreeNode) { return; } // check if the currently selected node can accept the copied node as a child // no need to check the grammar, an arity check will do just fine here if (node.Symbol.MaximumArity <= node.SubtreeCount) { return; } switch (lastOp) { case EditOp.CutSubtree: { if (tempNode.IterateNodesBreadth().Contains(node)) { throw new ArgumentException(); // cannot cut/paste a node into itself } ModifyTree(Tree, tempNode.Parent, tempNode, null); //remove node from its original parent ModifyTree(Tree, node, null, tempNode); //insert it as a child to the new parent break; } case EditOp.CopySubtree: { var clone = (SymbolicExpressionTreeNode)tempNode.Clone(); ModifyTree(Tree, node, null, clone); break; } } currSelected = null; // because the tree will have changed tempNode = null; // clear the clipboard after one paste }
public static ISymbolicExpressionTreeNode Derive(ISymbolicExpressionTreeNode branch, string variableName) { if (branch.Symbol is Constant) { return(CreateConstant(0.0)); } if (branch.Symbol is Variable) { var varNode = branch as VariableTreeNode; if (varNode.VariableName == variableName) { return(CreateConstant(varNode.Weight)); } else { return(CreateConstant(0.0)); } } if (branch.Symbol is Addition) { var sum = addSy.CreateTreeNode(); foreach (var subTree in branch.Subtrees) { sum.AddSubtree(Derive(subTree, variableName)); } return(sum); } if (branch.Symbol is Subtraction) { var sum = subSy.CreateTreeNode(); foreach (var subTree in branch.Subtrees) { sum.AddSubtree(Derive(subTree, variableName)); } return(sum); } if (branch.Symbol is Multiplication) { // (f * g)' = f'*g + f*g' // for multiple factors: (f * g * h)' = ((f*g) * h)' = (f*g)' * h + (f*g) * h' if (branch.SubtreeCount >= 2) { var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var fprime = Derive(f, variableName); for (int i = 1; i < branch.SubtreeCount; i++) { var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(i).Clone(); var fg = Product((ISymbolicExpressionTreeNode)f.Clone(), (ISymbolicExpressionTreeNode)g.Clone()); var gPrime = Derive(g, variableName); var fgPrime = Sum(Product(fprime, g), Product(gPrime, f)); // prepare for next iteration f = fg; fprime = fgPrime; } return(fprime); } else { // multiplication with only one argument has no effect -> derive the argument return(Derive(branch.GetSubtree(0), variableName)); } } if (branch.Symbol is Division) { // (f/g)' = (f'g - g'f) / g² if (branch.SubtreeCount == 1) { var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var gPrime = Product(CreateConstant(-1.0), Derive(g, variableName)); var sqrNode = new Square().CreateTreeNode(); sqrNode.AddSubtree(g); return(Div(gPrime, sqrNode)); } else { // for two subtrees: // (f/g)' = (f'g - fg')/g² // if there are more than 2 subtrees // div(x,y,z) is interpretered as (x/y)/z // which is the same as x / (y*z) // --> make a product of all but the first subtree and differentiate as for the 2-argument case above var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var g = Product(branch.Subtrees.Skip(1).Select(n => (ISymbolicExpressionTreeNode)n.Clone())); var fprime = Derive(f, variableName); var gprime = Derive(g, variableName); var gSqr = Square(g); return(Div(Subtract(Product(fprime, g), Product(f, gprime)), gSqr)); } } if (branch.Symbol is Logarithm) { var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Product(Div(CreateConstant(1.0), f), Derive(f, variableName))); } if (branch.Symbol is Exponential) { var f = (ISymbolicExpressionTreeNode)branch.Clone(); return(Product(f, Derive(branch.GetSubtree(0), variableName))); } if (branch.Symbol is Square) { var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Product(Product(CreateConstant(2.0), f), Derive(f, variableName))); } if (branch.Symbol is SquareRoot) { var f = (ISymbolicExpressionTreeNode)branch.Clone(); var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Product(Div(CreateConstant(1.0), Product(CreateConstant(2.0), f)), Derive(u, variableName))); } if (branch.Symbol is CubeRoot) { var f = (ISymbolicExpressionTreeNode)branch.Clone(); var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName))); // 1/3 1/cbrt(f(x))^2 d/dx f(x) } if (branch.Symbol is Cube) { var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName))); } if (branch.Symbol is Absolute) { var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var absf = Abs((ISymbolicExpressionTreeNode)f.Clone()); return(Product(Div(f, absf), Derive(f, variableName))); } if (branch.Symbol is AnalyticQuotient) { // aq(a(x), b(x)) = a(x) / sqrt(b(x)²+1) var a = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var b = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone(); var definition = Div(a, SquareRoot(Sum(Square(b), CreateConstant(1.0)))); return(Derive(definition, variableName)); } if (branch.Symbol is Sine) { var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var cos = (new Cosine()).CreateTreeNode(); cos.AddSubtree(u); return(Product(cos, Derive(u, variableName))); } if (branch.Symbol is Cosine) { var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); var sin = (new Sine()).CreateTreeNode(); sin.AddSubtree(u); return(Product(CreateConstant(-1.0), Product(sin, Derive(u, variableName)))); } if (branch.Symbol is Tangent) { // tan(x)' = 1 / cos²(x) var fxp = Derive(branch.GetSubtree(0), variableName); var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone(); return(Div(fxp, Square(Cosine(u)))); } if (branch.Symbol is HyperbolicTangent) { // tanh(f(x))' = f(x)'sech²(f(x)) = f(x)'(1 - tanh²(f(x))) var fxp = Derive(branch.GetSubtree(0), variableName); var tanh = (ISymbolicExpressionTreeNode)branch.Clone(); return(Product(fxp, Subtract(CreateConstant(1.0), Square(tanh)))); } throw new NotSupportedException(string.Format("Symbol {0} is not supported.", branch.Symbol)); }
private ISymbolicExpressionTreeNode MakeIntegral(ISymbolicExpressionTreeNode subtree, int lag) { if (lag == 0) return subtree; else if (lag == -1 || lag == 1) { return MakeSum(subtree, AddLagToDynamicNodes((ISymbolicExpressionTreeNode)subtree.Clone(), lag)); } else { var node = (LaggedTreeNode)integralSymbol.CreateTreeNode(); node.Lag = lag; node.AddSubtree(subtree); return node; } }
private ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) { // can't simplify this function but simplify all subtrees List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees); while (original.Subtrees.Count() > 0) original.RemoveSubtree(0); var clone = (SymbolicExpressionTreeNode)original.Clone(); List<ISymbolicExpressionTreeNode> simplifiedSubtrees = new List<ISymbolicExpressionTreeNode>(); foreach (var subtree in subtrees) { simplifiedSubtrees.Add(GetSimplifiedTree(subtree)); original.AddSubtree(subtree); } foreach (var simplifiedSubtree in simplifiedSubtrees) { clone.AddSubtree(simplifiedSubtree); } if (simplifiedSubtrees.TrueForAll(t => IsConstant(t))) { SimplifyConstantExpression(clone); } return clone; }
/// <summary> /// Creates a new simplified tree /// </summary> /// <param name="original"></param> /// <returns></returns> public ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) { if (IsConstant(original) || IsVariable(original)) { return (ISymbolicExpressionTreeNode)original.Clone(); } else if (IsAddition(original)) { return SimplifyAddition(original); } else if (IsSubtraction(original)) { return SimplifySubtraction(original); } else if (IsMultiplication(original)) { return SimplifyMultiplication(original); } else if (IsDivision(original)) { return SimplifyDivision(original); } else if (IsAverage(original)) { return SimplifyAverage(original); } else if (IsLog(original)) { return SimplifyLog(original); } else if (IsExp(original)) { return SimplifyExp(original); } else if (IsSquare(original)) { return SimplifySquare(original); } else if (IsSquareRoot(original)) { return SimplifySquareRoot(original); } else if (IsPower(original)) { return SimplifyPower(original); } else if (IsRoot(original)) { return SimplifyRoot(original); } else if (IsSine(original)) { return SimplifySine(original); } else if (IsCosine(original)) { return SimplifyCosine(original); } else if (IsTangent(original)) { return SimplifyTangent(original); } else if (IsIfThenElse(original)) { return SimplifyIfThenElse(original); } else if (IsGreaterThan(original)) { return SimplifyGreaterThan(original); } else if (IsLessThan(original)) { return SimplifyLessThan(original); } else if (IsAnd(original)) { return SimplifyAnd(original); } else if (IsOr(original)) { return SimplifyOr(original); } else if (IsNot(original)) { return SimplifyNot(original); } else if (IsTimeLag(original)) { return SimplifyTimeLag(original); } else if (IsIntegral(original)) { return SimplifyIntegral(original); } else { return SimplifyAny(original); } }
private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) { // remove old ADFs while (tempTree.Root.SubtreeCount > 1) tempTree.Root.RemoveSubtree(1); // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } var start = tempTree.Root.GetSubtree(0); while (start.SubtreeCount > 0) start.RemoveSubtree(0); start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var interpreter = Content.Model.Interpreter; var rows = Content.ProblemData.TrainingIndices; var allPrognosedValues = interpreter.GetSymbolicExpressionTreeValues(tempTree, Content.ProblemData.Dataset, rows); return allPrognosedValues.Median(); }