public override E Evaluate(EvalSettings evalSettings = null, bool isRootNode = true) { evalSettings = evalSettings ?? E.DefaultEvalSettings; if (evalSettings.SubstituteVariables) { if (Type == VariableType.Numeric) { object val = null; if (Value != null) { val = Value; } object settingsVal; if (evalSettings.Values.TryGetValue(Name, out settingsVal)) { val = settingsVal; } if (val != null && val.IsNumeric()) { return(SimplifyIfRoot(E.NumConst(Convert.ToDouble(val)), evalSettings, isRootNode)); } } } return(SimplifyIfRoot(this, evalSettings, isRootNode)); }
public override E Evaluate(EvalSettings evalSettings = null, bool isRootNode = true) { evalSettings = evalSettings ?? E.DefaultEvalSettings; E evaluatedObject = Object.Evaluate(evalSettings, false); if (evaluatedObject is Variable) { Variable var = evaluatedObject as Variable; if (var.IsValueNode) { double4 v = ( double4 )var.Value; if (Property == "x") { return(SimplifyIfRoot(E.NumConst(v.x), evalSettings, isRootNode)); } else if (Property == "y") { return(SimplifyIfRoot(E.NumConst(v.y), evalSettings, isRootNode)); } else if (Property == "z") { return(SimplifyIfRoot(E.NumConst(v.z), evalSettings, isRootNode)); } else if (Property == "w") { return(SimplifyIfRoot(E.NumConst(v.w), evalSettings, isRootNode)); } } } return(SimplifyIfRoot(evaluatedObject.Prop(Property), evalSettings, isRootNode)); }
public override E Evaluate(EvalSettings evalSettings = null, bool isRootNode = true) { evalSettings = evalSettings ?? E.DefaultEvalSettings; E evaluatedExpression = Expression.Evaluate(evalSettings, false); if (evaluatedExpression is Literal && OpKind == UnaryOpKind.Negate) { if (evaluatedExpression is NumericConstant) { NumericConstant num = evaluatedExpression as NumericConstant; return(SimplifyIfRoot(E.NumConst(-num.Value), evalSettings, isRootNode)); } else if (evaluatedExpression.IsValueNode) { Variable var = evaluatedExpression as Variable; double4 v = ( double4 )var.Value; return(SimplifyIfRoot(E.Vec(var.Name, -v), evalSettings, isRootNode)); } } if (OpKind == UnaryOpKind.Negate) { return(SimplifyIfRoot(E.Negate(evaluatedExpression), evalSettings, isRootNode)); } else { return(SimplifyIfRoot(evaluatedExpression, evalSettings, isRootNode)); } }
protected static E SimplifyIfRoot(E expr, EvalSettings evalSettings, bool isRootNode) { if (isRootNode) { if (evalSettings.MaximumSimplicity) { int i = 0; E ePrev; do { ePrev = expr; expr = expr.Simplify(evalSettings); i++; } while (ePrev != expr && i <= EvalSettings.INFINITE_LOOP_CYCLE_NUM); if (i == EvalSettings.INFINITE_LOOP_CYCLE_NUM) { Debug.Fail("Simplify Error", "It seems that simplification will never stop. Aborting."); } return(expr); } else { return(expr.Simplify(evalSettings)); } } else { return(expr); } }
public Vec4 Evaluate(EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; Vec4 v = new Vec4(x.Evaluate(evalSettings), y.Evaluate(evalSettings), z.Evaluate(evalSettings), w.Evaluate(evalSettings)); return(v); }
public override E Simplify(EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; if (FuncKind == Analyze.FuncKind.Pow || FuncKind == Analyze.FuncKind.Sqrt) { return(global::Math3.Analyze.MultipleOp.SimplifyNestedPowers(this)); } return(base.Simplify(evalSettings)); }
public E EvaluateStepByStep(out string htmlLog, params object [] varValues) { List <Tuple <string, string> > htmlSteps = new List <Tuple <string, string> > (); EvalFlags [] stepFlags = new [] { EvalFlags.ReduceZeroMultiplier | EvalFlags.ReduceUnitMultiplier | EvalFlags.ReduceUnitDivider, EvalFlags.GroupByCommonFactor | EvalFlags.GroupMultipliersToFractions, EvalFlags.SumFractions, EvalFlags.SimplifyTrigonometricFunctions, EvalFlags.EvalFuncs, EvalFlags.SubstituteVariables }; E e = this; htmlSteps.Add(Tuple.Create("Initial expression", e.AsHtml)); for (int i = 0; i < stepFlags.Length; i++) { E prevE = e; int c = 0; do { for (int j = 0; j <= i; j++) { prevE = e; EvalSettings evalSettings = new EvalSettings(stepFlags [j], varValues); evalSettings.MaximumSimplicity = false; e = e.Evaluate(evalSettings); if (e != prevE) { htmlSteps.Add(Tuple.Create(stepFlags [j].ToString(), e.AsHtml)); } } c++; } while (e != prevE && c <= EvalSettings.INFINITE_LOOP_CYCLE_NUM); if (c == EvalSettings.INFINITE_LOOP_CYCLE_NUM) { Debug.Fail("Simplify Error", "It seems that simplification will never stop. Aborting."); } } htmlLog = string.Join("<br />", htmlSteps.Select(step => string.Format("<h4>{0}:</h4>{1}", step.Item1, step.Item2))); return(e); }
public override E Simplify(EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; E simplifiedExpression = Expression.Simplify(evalSettings); if (OpKind == UnaryOpKind.Negate && simplifiedExpression.IsNegative) { return(simplifiedExpression.SignFree); } else { return(new UnaryOp(OpKind, simplifiedExpression)); } }
public Mat4 Simplify(EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; Mat4 mat = new Mat4(); for (int m = 0; m < 4; m++) { for (int n = 0; n < 4; n++) { mat.M [m, n] = M [m, n].Simplify(evalSettings); } } return(mat); }
public Mat4 Evaluate(EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; Mat4 mat = new Mat4(); for (int m = 0; m < 4; m++) { for (int n = 0; n < 4; n++) { mat.M [m, n] = M [m, n].Evaluate(evalSettings, true); } } return(mat); }
public virtual ExpressionCompareResult Compare(E e, EvalSettings evalSettings = null) { evalSettings = evalSettings ?? E.DefaultEvalSettings; if (this.Equals(e)) { return(ExpressionCompareResult.Equal); } else if ((this.IsNegative && !e.IsNegative && this.SignFree.Equals(e)) || (!this.IsNegative && e.IsNegative && this.Equals(e.SignFree))) { return(ExpressionCompareResult.DiffersBySign); } else { return(ExpressionCompareResult.NotEqual); } }
public virtual E Evaluate(EvalSettings evalSettings = null, bool isRootNode = true) { return(this); }
public virtual E Simplify(EvalSettings evalSettings = null) { return(this); }
public override E Evaluate(EvalSettings evalSettings = null, bool isRootNode = true) { evalSettings = evalSettings ?? E.DefaultEvalSettings; List <E> evaluatedArgs = new List <E> (Args.Count); foreach (E arg in Args) { evaluatedArgs.Add(arg.Evaluate(evalSettings, false)); } if (evalSettings.EvalFuncs) { if (FuncKind == FuncKind.Sin || FuncKind == FuncKind.Cos || FuncKind == FuncKind.Abs || FuncKind == FuncKind.Sqrt) { E firstArg = evaluatedArgs [0]; if (firstArg is NumericConstant) { double inputValue = (firstArg as NumericConstant).Value; double returnValue = 0; if (FuncKind == Analyze.FuncKind.Sin) { returnValue = Math.Sin(inputValue); } else if (FuncKind == Analyze.FuncKind.Cos) { returnValue = Math.Cos(inputValue); } else if (FuncKind == Analyze.FuncKind.Abs) { returnValue = Math.Abs(inputValue); } else if (FuncKind == Analyze.FuncKind.Sqrt) { returnValue = Math.Sqrt(inputValue); } return(SimplifyIfRoot(E.NumConst(returnValue), evalSettings, isRootNode)); } else { if (FuncKind == Analyze.FuncKind.Sin && firstArg.IsNegative) { return(SimplifyIfRoot(E.Negate(E.Sin(firstArg.SignFree)), evalSettings, isRootNode)); } else if (FuncKind == Analyze.FuncKind.Cos && firstArg.IsNegative) { return(SimplifyIfRoot(E.Cos(firstArg.SignFree), evalSettings, isRootNode)); } else if (FuncKind == Analyze.FuncKind.Abs && firstArg.IsNegative) { return(SimplifyIfRoot(E.Abs(firstArg.SignFree), evalSettings, isRootNode)); } } } else if (FuncKind == FuncKind.Pow) { E firstArg = evaluatedArgs [0]; E secondArg = evaluatedArgs [1]; if (firstArg is NumericConstant && secondArg is NumericConstant) { double a = (firstArg as NumericConstant).Value; double b = (secondArg as NumericConstant).Value; return(SimplifyIfRoot(E.NumConst(Math.Pow(a, b)), evalSettings, isRootNode)); } else if (secondArg is NumericConstant) { double b = (secondArg as NumericConstant).Value; if (firstArg.IsNegative) { if (b % 2 == 0) { return(SimplifyIfRoot(E.Pow(firstArg.SignFree, secondArg), evalSettings, isRootNode)); } else { return(SimplifyIfRoot(E.Negate(E.Pow(firstArg.SignFree, secondArg)), evalSettings, isRootNode)); } } } } } return(SimplifyIfRoot(E.Func(FuncKind, evaluatedArgs.ToArray()), evalSettings, isRootNode)); }