// for each factor variable value we need a parameter which represents a binary indicator for that variable & value combination // each binary indicator is only necessary once. So we only create a parameter if this combination is not yet available private static Term FindOrCreateParameter(Dictionary <DataForVariable, AutoDiff.Variable> parameters, string varName, string varValue = "", int lag = 0) { var data = new DataForVariable(varName, varValue, lag); AutoDiff.Variable par = null; if (!parameters.TryGetValue(data, out par)) { // not found -> create new parameter and entries in names and values lists par = new AutoDiff.Variable(); parameters.Add(data, par); } return(par); }
public void Visit(AutoDiff.Variable variable) { AddToQueue(variable); //return true; }
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List <AutoDiff.Variable> variables, List <AutoDiff.Variable> parameters, List <string> variableNames, bool updateVariableWeights, out AutoDiff.Term term) { if (node.Symbol is Constant) { var var = new AutoDiff.Variable(); variables.Add(var); term = var; return(true); } if (node.Symbol is Variable) { var varNode = node as VariableTreeNode; var par = new AutoDiff.Variable(); parameters.Add(par); variableNames.Add(varNode.VariableName); if (updateVariableWeights) { var w = new AutoDiff.Variable(); variables.Add(w); term = AutoDiff.TermBuilder.Product(w, par); } else { term = par; } return(true); } if (node.Symbol is Addition) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return(true); } if (node.Symbol is Subtraction) { List <AutoDiff.Term> terms = new List <Term>(); for (int i = 0; i < node.SubtreeCount; i++) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } if (i > 0) { t = -t; } terms.Add(t); } if (terms.Count == 1) { term = -terms[0]; } else { term = AutoDiff.TermBuilder.Sum(terms); } return(true); } if (node.Symbol is Multiplication) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } terms.Add(t); } if (terms.Count == 1) { term = terms[0]; } else { term = terms.Aggregate((a, b) => new AutoDiff.Product(a, b)); } return(true); } if (node.Symbol is Division) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } terms.Add(t); } if (terms.Count == 1) { term = 1.0 / terms[0]; } else { term = terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b)); } return(true); } if (node.Symbol is Logarithm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Log(t); return(true); } } if (node.Symbol is Exponential) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Exp(t); return(true); } } if (node.Symbol is Square) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Power(t, 2.0); return(true); } } if (node.Symbol is SquareRoot) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Power(t, 0.5); return(true); } } if (node.Symbol is Sine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = sin(t); return(true); } } if (node.Symbol is Cosine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = cos(t); return(true); } } if (node.Symbol is Tangent) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = tan(t); return(true); } } if (node.Symbol is Erf) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = erf(t); return(true); } } if (node.Symbol is Norm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return(false); } else { term = norm(t); return(true); } } if (node.Symbol is StartSymbol) { var alpha = new AutoDiff.Variable(); var beta = new AutoDiff.Variable(); variables.Add(beta); variables.Add(alpha); AutoDiff.Term branchTerm; if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out branchTerm)) { term = branchTerm * alpha + beta; return(true); } else { term = null; return(false); } } term = null; return(false); }
public bool Visit(AutoDiff.Variable variable) { return(true); }
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List<AutoDiff.Variable> variables, List<AutoDiff.Variable> parameters, List<string> variableNames, bool updateVariableWeights, out AutoDiff.Term term) { if (node.Symbol is Constant) { var var = new AutoDiff.Variable(); variables.Add(var); term = var; return true; } if (node.Symbol is Variable) { var varNode = node as VariableTreeNode; var par = new AutoDiff.Variable(); parameters.Add(par); variableNames.Add(varNode.VariableName); if (updateVariableWeights) { var w = new AutoDiff.Variable(); variables.Add(w); term = AutoDiff.TermBuilder.Product(w, par); } else { term = par; } return true; } if (node.Symbol is Addition) { List<AutoDiff.Term> terms = new List<Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return true; } if (node.Symbol is Subtraction) { List<AutoDiff.Term> terms = new List<Term>(); for (int i = 0; i < node.SubtreeCount; i++) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } if (i > 0) t = -t; terms.Add(t); } if (terms.Count == 1) term = -terms[0]; else term = AutoDiff.TermBuilder.Sum(terms); return true; } if (node.Symbol is Multiplication) { List<AutoDiff.Term> terms = new List<Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } terms.Add(t); } if (terms.Count == 1) term = terms[0]; else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, b)); return true; } if (node.Symbol is Division) { List<AutoDiff.Term> terms = new List<Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } terms.Add(t); } if (terms.Count == 1) term = 1.0 / terms[0]; else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b)); return true; } if (node.Symbol is Logarithm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Log(t); return true; } } if (node.Symbol is Exponential) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Exp(t); return true; } } if (node.Symbol is Square) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Power(t, 2.0); return true; } } if (node.Symbol is SquareRoot) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Power(t, 0.5); return true; } } if (node.Symbol is Sine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = sin(t); return true; } } if (node.Symbol is Cosine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = cos(t); return true; } } if (node.Symbol is Tangent) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = tan(t); return true; } } if (node.Symbol is Erf) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = erf(t); return true; } } if (node.Symbol is Norm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) { term = null; return false; } else { term = norm(t); return true; } } if (node.Symbol is StartSymbol) { var alpha = new AutoDiff.Variable(); var beta = new AutoDiff.Variable(); variables.Add(beta); variables.Add(alpha); AutoDiff.Term branchTerm; if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out branchTerm)) { term = branchTerm * alpha + beta; return true; } else { term = null; return false; } } term = null; return false; }
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List<AutoDiff.Variable> variables, List<AutoDiff.Variable> parameters, List<string> variableNames, out AutoDiff.Term term) { if (node.Symbol is Constant) { var var = new AutoDiff.Variable(); variables.Add(var); term = var; return true; } if (node.Symbol is Variable) { var varNode = node as VariableTreeNode; var par = new AutoDiff.Variable(); parameters.Add(par); variableNames.Add(varNode.VariableName); var w = new AutoDiff.Variable(); variables.Add(w); term = AutoDiff.TermBuilder.Product(w, par); return true; } if (node.Symbol is Addition) { List<AutoDiff.Term> terms = new List<Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out t)) { term = null; return false; } terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return true; } if (node.Symbol is Subtraction) { List<AutoDiff.Term> terms = new List<Term>(); for (int i = 0; i < node.SubtreeCount; i++) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, out t)) { term = null; return false; } if (i > 0) t = -t; terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return true; } if (node.Symbol is Multiplication) { AutoDiff.Term a, b; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) || !TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) { term = null; return false; } else { List<AutoDiff.Term> factors = new List<Term>(); foreach (var subTree in node.Subtrees.Skip(2)) { AutoDiff.Term f; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) { term = null; return false; } factors.Add(f); } term = AutoDiff.TermBuilder.Product(a, b, factors.ToArray()); return true; } } if (node.Symbol is Division) { // only works for at least two subtrees AutoDiff.Term a, b; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) || !TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) { term = null; return false; } else { List<AutoDiff.Term> factors = new List<Term>(); foreach (var subTree in node.Subtrees.Skip(2)) { AutoDiff.Term f; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) { term = null; return false; } factors.Add(1.0 / f); } term = AutoDiff.TermBuilder.Product(a, 1.0 / b, factors.ToArray()); return true; } } if (node.Symbol is Logarithm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Log(t); return true; } } if (node.Symbol is Exponential) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Exp(t); return true; } } if (node.Symbol is Square) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Power(t, 2.0); return true; } } if (node.Symbol is SquareRoot) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = AutoDiff.TermBuilder.Power(t, 0.5); return true; } } if (node.Symbol is Sine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = sin(t); return true; } } if (node.Symbol is Cosine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = cos(t); return true; } } if (node.Symbol is Tangent) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = tan(t); return true; } } if (node.Symbol is Erf) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = erf(t); return true; } } if (node.Symbol is Norm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return false; } else { term = norm(t); return true; } } if (node.Symbol is StartSymbol) { var alpha = new AutoDiff.Variable(); var beta = new AutoDiff.Variable(); variables.Add(beta); variables.Add(alpha); AutoDiff.Term branchTerm; if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out branchTerm)) { term = branchTerm * alpha + beta; return true; } else { term = null; return false; } } term = null; return false; }
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List <AutoDiff.Variable> variables, List <AutoDiff.Variable> parameters, List <string> variableNames, out AutoDiff.Term term) { if (node.Symbol is Constant) { var var = new AutoDiff.Variable(); variables.Add(var); term = var; return(true); } if (node.Symbol is Variable) { var varNode = node as VariableTreeNode; var par = new AutoDiff.Variable(); parameters.Add(par); variableNames.Add(varNode.VariableName); var w = new AutoDiff.Variable(); variables.Add(w); term = AutoDiff.TermBuilder.Product(w, par); return(true); } if (node.Symbol is Addition) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { AutoDiff.Term t; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out t)) { term = null; return(false); } terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return(true); } if (node.Symbol is Subtraction) { List <AutoDiff.Term> terms = new List <Term>(); for (int i = 0; i < node.SubtreeCount; i++) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, out t)) { term = null; return(false); } if (i > 0) { t = -t; } terms.Add(t); } term = AutoDiff.TermBuilder.Sum(terms); return(true); } if (node.Symbol is Multiplication) { AutoDiff.Term a, b; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) || !TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) { term = null; return(false); } else { List <AutoDiff.Term> factors = new List <Term>(); foreach (var subTree in node.Subtrees.Skip(2)) { AutoDiff.Term f; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) { term = null; return(false); } factors.Add(f); } term = AutoDiff.TermBuilder.Product(a, b, factors.ToArray()); return(true); } } if (node.Symbol is Division) { // only works for at least two subtrees AutoDiff.Term a, b; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) || !TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) { term = null; return(false); } else { List <AutoDiff.Term> factors = new List <Term>(); foreach (var subTree in node.Subtrees.Skip(2)) { AutoDiff.Term f; if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) { term = null; return(false); } factors.Add(1.0 / f); } term = AutoDiff.TermBuilder.Product(a, 1.0 / b, factors.ToArray()); return(true); } } if (node.Symbol is Logarithm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Log(t); return(true); } } if (node.Symbol is Exponential) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Exp(t); return(true); } } if (node.Symbol is Square) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Power(t, 2.0); return(true); } } if (node.Symbol is SquareRoot) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = AutoDiff.TermBuilder.Power(t, 0.5); return(true); } } if (node.Symbol is Sine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = sin(t); return(true); } } if (node.Symbol is Cosine) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = cos(t); return(true); } } if (node.Symbol is Tangent) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = tan(t); return(true); } } if (node.Symbol is Erf) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = erf(t); return(true); } } if (node.Symbol is Norm) { AutoDiff.Term t; if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) { term = null; return(false); } else { term = norm(t); return(true); } } if (node.Symbol is StartSymbol) { var alpha = new AutoDiff.Variable(); var beta = new AutoDiff.Variable(); variables.Add(beta); variables.Add(alpha); AutoDiff.Term branchTerm; if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out branchTerm)) { term = branchTerm * alpha + beta; return(true); } else { term = null; return(false); } } term = null; return(false); }
public void Visit(AutoDiff.Variable variable) { VariableCount++; }
private AutoDiff.Term ConvertToAutoDiff(ISymbolicExpressionTreeNode node) { if (node.Symbol is Constant) { initialConstants.Add(((ConstantTreeNode)node).Value); var var = new AutoDiff.Variable(); variables.Add(var); return(var); } if (node.Symbol is Variable || node.Symbol is BinaryFactorVariable) { var varNode = node as VariableTreeNodeBase; var factorVarNode = node as BinaryFactorVariableTreeNode; // factor variable values are only 0 or 1 and set in x accordingly var varValue = factorVarNode != null ? factorVarNode.VariableValue : string.Empty; var par = FindOrCreateParameter(parameters, varNode.VariableName, varValue); if (makeVariableWeightsVariable) { initialConstants.Add(varNode.Weight); var w = new AutoDiff.Variable(); variables.Add(w); return(AutoDiff.TermBuilder.Product(w, par)); } else { return(varNode.Weight * par); } } if (node.Symbol is FactorVariable) { var factorVarNode = node as FactorVariableTreeNode; var products = new List <Term>(); foreach (var variableValue in factorVarNode.Symbol.GetVariableValues(factorVarNode.VariableName)) { var par = FindOrCreateParameter(parameters, factorVarNode.VariableName, variableValue); initialConstants.Add(factorVarNode.GetValue(variableValue)); var wVar = new AutoDiff.Variable(); variables.Add(wVar); products.Add(AutoDiff.TermBuilder.Product(wVar, par)); } return(AutoDiff.TermBuilder.Sum(products)); } if (node.Symbol is LaggedVariable) { var varNode = node as LaggedVariableTreeNode; var par = FindOrCreateParameter(parameters, varNode.VariableName, string.Empty, varNode.Lag); if (makeVariableWeightsVariable) { initialConstants.Add(varNode.Weight); var w = new AutoDiff.Variable(); variables.Add(w); return(AutoDiff.TermBuilder.Product(w, par)); } else { return(varNode.Weight * par); } } if (node.Symbol is Addition) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { terms.Add(ConvertToAutoDiff(subTree)); } return(AutoDiff.TermBuilder.Sum(terms)); } if (node.Symbol is Subtraction) { List <AutoDiff.Term> terms = new List <Term>(); for (int i = 0; i < node.SubtreeCount; i++) { AutoDiff.Term t = ConvertToAutoDiff(node.GetSubtree(i)); if (i > 0) { t = -t; } terms.Add(t); } if (terms.Count == 1) { return(-terms[0]); } else { return(AutoDiff.TermBuilder.Sum(terms)); } } if (node.Symbol is Multiplication) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { terms.Add(ConvertToAutoDiff(subTree)); } if (terms.Count == 1) { return(terms[0]); } else { return(terms.Aggregate((a, b) => new AutoDiff.Product(a, b))); } } if (node.Symbol is Division) { List <AutoDiff.Term> terms = new List <Term>(); foreach (var subTree in node.Subtrees) { terms.Add(ConvertToAutoDiff(subTree)); } if (terms.Count == 1) { return(1.0 / terms[0]); } else { return(terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b))); } } if (node.Symbol is Absolute) { var x1 = ConvertToAutoDiff(node.GetSubtree(0)); return(abs(x1)); } if (node.Symbol is AnalyticQuotient) { var x1 = ConvertToAutoDiff(node.GetSubtree(0)); var x2 = ConvertToAutoDiff(node.GetSubtree(1)); return(x1 / (TermBuilder.Power(1 + x2 * x2, 0.5))); } if (node.Symbol is Logarithm) { return(AutoDiff.TermBuilder.Log( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Exponential) { return(AutoDiff.TermBuilder.Exp( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Square) { return(AutoDiff.TermBuilder.Power( ConvertToAutoDiff(node.GetSubtree(0)), 2.0)); } if (node.Symbol is SquareRoot) { return(AutoDiff.TermBuilder.Power( ConvertToAutoDiff(node.GetSubtree(0)), 0.5)); } if (node.Symbol is Cube) { return(AutoDiff.TermBuilder.Power( ConvertToAutoDiff(node.GetSubtree(0)), 3.0)); } if (node.Symbol is CubeRoot) { return(cbrt(ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Sine) { return(sin( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Cosine) { return(cos( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Tangent) { return(tan( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is HyperbolicTangent) { return(tanh( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Erf) { return(erf( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is Norm) { return(norm( ConvertToAutoDiff(node.GetSubtree(0)))); } if (node.Symbol is StartSymbol) { if (addLinearScalingTerms) { // scaling variables α, β are given at the beginning of the parameter vector var alpha = new AutoDiff.Variable(); var beta = new AutoDiff.Variable(); variables.Add(beta); variables.Add(alpha); var t = ConvertToAutoDiff(node.GetSubtree(0)); return(t * alpha + beta); } else { return(ConvertToAutoDiff(node.GetSubtree(0))); } } throw new ConversionException(); }
public bool Visit(AutoDiff.Variable variable) { variable.Parents.Clear(); UpdateInterval(variable, variable.GlobalMin, variable.GlobalMax); return(true); }
public override Term Derivative(Variable v) { return(0); }