public void TestForComparation() { Variable x = new Variable("x"); var c1 = x + x; var c2 = x + x; Assert.AreEqual(c1.GetHashCode(), c2.GetHashCode()); }
public void TestForSimplification() { Variable x = new Variable("x"); Expression s1 = SMath.Exp(SMath.Ln(x)); Assert.AreEqual(s1.Simplify(), x); Expression s2 = SMath.Ln(SMath.Exp(x)); Assert.AreEqual(s2.Simplify(), x); Expression s3 = SMath.Sqrt((SMath.Exp(SMath.Ln(x)) - x) ^ 10); Assert.AreEqual(s3.Simplify(), Constant.Zero); Expression s4 = (x ^ 6) / (x ^ 4); Assert.AreEqual(s4.Simplify(), x ^ 2); Expression s5 = (x ^ 6) * (x ^ 9); Assert.AreEqual(s5.Simplify(), x ^ 15); Expression s6 = (Constant.One ^ 6) ^ 2; Assert.AreEqual(s6.Simplify(), Constant.One); }
public void TestForDerivation() { Variable x = new Variable("x"); Variable y = new Variable("y"); Expression e = SMath.Exp(x + y); Expression dx = e.Derivate(x).Simplify(); Assert.AreEqual(dx, e); Expression dy = e.Derivate(y).Simplify(); Assert.AreEqual(dy, e); Expression dxy = e.Derivate(x).Derivate(y).Simplify(); Assert.AreEqual(dxy, e); Expression xdy = x.Derivate(y).Simplify(); Assert.AreEqual(xdy, Constant.Zero); Expression ydx = y.Derivate(x).Simplify(); Assert.AreEqual(ydx, Constant.Zero); Expression d1 = (x * y).Derivate(x).Simplify(); Assert.AreEqual(d1, y); Expression d2 = (x * y).Derivate(y).Simplify(); Assert.AreEqual(d2, x); Expression d3 = (x + y).Derivate(x).Simplify(); Assert.AreEqual(d3, Constant.One); Expression d4 = (x + y).Derivate(y).Simplify(); Assert.AreEqual(d4, Constant.One); Expression d5 = (1 / x).Derivate(x).Simplify(); Assert.AreEqual(d5, -(1 / x ^ 2)); }
static Expression LaplaceTransform(Expression expr, Variable t, Variable s) { return 0; }
static double NSolve(Expression f, Variable v, double v0 = 0, double eps = 1e-6) { double vn1 = v0; Expression phi = v - f / f.Derivate(v).Simplify(); v.Value = vn1; do { vn1 = phi.Process(); v.Value = vn1; } while (Math.Abs(f.Process()) > eps); return vn1; }
static double NIntegrate(Expression f, Variable v, double a, double b, double eps = 1e-2) { double res = 0; Expression df = f.Derivate(v).Simplify(); v.Value = a; for (double pv = a, cv = a + eps, step = eps; cv < b + step / 2; v.Value = cv, step = eps / (1 + Math.Abs(df.Process())), pv = cv, cv += step) { v.Value = (pv + cv) / 2; res += step * f.Process(); } return res; }
public override Expression Derivate(Variable dv) { return Constant.Zero; }
static Expression Solve(Expression left, Expression right, Variable v) { left = left.Simplify(); right = right.Simplify(); Console.WriteLine("\t{0} = {1} // {2} == {3}", left, right, left.GetType().Name, right.GetType().Name); if (!left.IsDependOf(v)) throw new Exception("Can't solve equation. No dependencies of variable '" + v.Name + "'."); if (left is Symbolic.Operators.Scalar.Add) { Expression ll = Left(left); Expression lr = Right(left); if (lr.IsDependOf(v)) return Solve(lr, right - ll, v); else return Solve(ll, right - lr, v); } else if (left is Symbolic.Operators.Scalar.Sub) { Expression ll = Left(left); Expression lr = Right(left); if (lr.IsDependOf(v)) return Solve(-lr, right - ll, v); else return Solve(ll, right + lr, v); } else if (left is Symbolic.Operators.Scalar.Div) { Expression ll = Left(left); Expression lr = Right(left); if (lr.IsDependOf(v)) return Solve(lr, ll / right, v); else return Solve(ll, right * lr, v); } else if (left is Symbolic.Operators.Scalar.Mul) { Expression ll = Left(left); Expression lr = Right(left); if (lr.IsDependOf(v)) return Solve(lr, right / ll, v); else return Solve(ll, right / lr, v); } else if (left is Symbolic.Operators.Scalar.Pow) { Expression ll = Left(left); Expression lr = Right(left); if (lr.IsDependOf(v)) return Solve(lr, SMath.Log(right, ll), v); else return Solve(ll, right ^ (1 / lr), v); } else if (left is Symbolic.Functions.Sqrt) { Expression ll = (left as Symbolic.Functions.Sqrt).Args[0]; return Solve(ll, right ^ 2, v); } else if (left is Symbolic.Functions.Sin) { Expression ll = (left as Symbolic.Functions.Sin).Args[0]; return Solve(ll, SMath.ArcSin(right), v); } else if (left is Symbolic.Functions.Cos) { Expression ll = (left as Symbolic.Functions.Cos).Args[0]; return Solve(ll, SMath.ArcCos(right), v); } else if (left is Symbolic.Functions.Tan) { Expression ll = (left as Symbolic.Functions.Tan).Args[0]; return Solve(ll, SMath.ArcTan(right), v); } else if (left is Symbolic.Functions.ArcSin) { Expression ll = (left as Symbolic.Functions.ArcSin).Args[0]; return Solve(ll, SMath.Sin(right), v); } else if (left is Symbolic.Functions.ArcCos) { Expression ll = (left as Symbolic.Functions.ArcCos).Args[0]; return Solve(ll, SMath.Cos(right), v); } else if (left is Symbolic.Functions.ArcTan) { Expression ll = (left as Symbolic.Functions.ArcTan).Args[0]; return Solve(ll, SMath.Tan(right), v); } else if (left is Symbolic.Functions.Exp) { Expression ll = (left as Symbolic.Functions.Exp).Args[0]; return Solve(ll, SMath.Ln(right), v); } else if (left is Symbolic.Functions.Ln) { Expression ll = (left as Symbolic.Functions.Ln).Args[0]; return Solve(ll, SMath.Exp(right), v); } else if (left is Variable && left.IsDependOf(v)) return right; else throw new Exception("Can't solve equation. Unknown equation type."); }
public override Expression Derivate(Variable dv) { throw new NotImplementedException(); }
public override Expression Replace(Variable v, Expression expr) { return this; }
static Expression Laplace(Expression expr, Variable x, Variable y, Variable z) { return expr.Derivate(x, 2).Simplify() + expr.Derivate(y, 2).Simplify() + expr.Derivate(z, 2).Simplify(); }
static Expression TableIntegral(Expression expr, Variable v) { if (expr is Constant) { if (expr == Constant.Zero) return Constant.One; else return expr * v; } //else if (expr is Symbolic.Functions.Sin) ; else throw new NotImplementedException(); }
public override bool IsDependOf(Variable var) { throw new NotImplementedException(); }
public override Expression Replace(Variable v, Expression expr) { if (this == v) return expr; else return this; }
public override bool IsDependOf(Variable var) { return var.Name == this.Name; }
public override Expression Derivate(Variable dv) { if (dv.Name == this.Name) return Constant.One; else return Constant.Zero; }
public new Vector Replace(Variable v, Expression expr) { throw new NotImplementedException(); }
static Expression Integrate(Expression expr, Variable v) { if (IsAddOp(expr)) { var l = Left(expr); var r = Right(expr); if (expr is Symbolic.Operators.Scalar.Add) return Integrate(l, v) + Integrate(r, v); else return Integrate(l, v) - Integrate(r, v); } else if (expr is Symbolic.Operators.Scalar.Mul) { if (!Left(expr).IsDependOf(v)) return Left(expr) * Integrate(Right(expr), v); else if (!Right(expr).IsDependOf(v)) return Right(expr) * Integrate(Left(expr), v); else throw new NotImplementedException(); //Partial integration } else return TableIntegral(expr, v); }
public override bool IsDependOf(Variable var) { return false; }
public static void Main(string[] args) { var x = new Variable("x"); var y = new Variable("y"); var z = new Variable("z"); var u = new Variable("u"); var f = x ^ x; Console.WriteLine(f); Console.WriteLine(f.Derivate(x)); Console.ReadKey(); }
public override Expression Derivate(Variable dv) { return this; }