/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { var first = (double)left.Calculate(parameters); var second = 1 / (double)right.Calculate(parameters); return MathExtentions.Pow(first, second); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <returns> /// A result of the calculation. /// </returns> public override object Calculate(ExpressionParameters parameters) { if (ResultIsMatrix) { if (left is Vector && right is Vector) throw new NotSupportedException(); IExpression l = null; if (left is Vector || left is Matrix) { l = left; } else { var temp = left.Calculate(parameters); if (temp is IExpression) l = (IExpression)temp; else l = new Number((double)temp); } IExpression r = null; if (right is Vector || right is Matrix) { r = right; } else { var temp = right.Calculate(parameters); if (temp is IExpression) r = (IExpression)temp; else r = new Number((double)temp); } if (l is Vector) { if (r is Matrix) return MatrixExtentions.Mul((Vector)l, (Matrix)r, parameters); return MatrixExtentions.Mul((Vector)l, r, parameters); } if (r is Vector) { if (l is Matrix) return MatrixExtentions.Mul((Matrix)l, (Vector)r, parameters); return MatrixExtentions.Mul((Vector)r, l, parameters); } if (l is Matrix && r is Matrix) return MatrixExtentions.Mul((Matrix)l, (Matrix)r, parameters); if (l is Matrix) return MatrixExtentions.Mul((Matrix)l, r, parameters); if (r is Matrix) return MatrixExtentions.Mul((Matrix)r, l, parameters); } return (double)left.Calculate(parameters) * (double)right.Calculate(parameters); }
public void DefineExpTest() { var exp = new Define(new Variable("x"), new Mul(new Number(4), new Add(new Number(8), new Number(1)))); var parameters = new ExpressionParameters(); var answer = exp.Execute(parameters); Assert.Equal(36.0, parameters.Variables["x"]); Assert.Equal("The value '4 * (8 + 1)' was assigned to the variable 'x'.", answer); }
public void DefineWithFuncTest() { IExpression exp = new Define(new Variable("x"), new Sin(new Number(1))); ParameterCollection parameters = new ParameterCollection(); ExpressionParameters expParams = new ExpressionParameters(AngleMeasurement.Radian, parameters); var answer = exp.Calculate(expParams); Assert.AreEqual(Math.Sin(1), parameters["x"]); Assert.AreEqual(double.NaN, answer); }
public void DefineWithFuncTest() { var exp = new Define(new Variable("x"), new Sin(new Number(1))); var parameters = new ParameterCollection(); var expParams = new ExpressionParameters(AngleMeasurement.Radian, parameters); var answer = exp.Execute(expParams); Assert.Equal(Math.Sin(1), parameters["x"]); Assert.Equal("The value 'sin(1)' was assigned to the variable 'x'.", answer); }
public void DefineFuncWithParamsTest() { var uf = new UserFunction("s", 1); var func = new Sin(new Variable("x")); var exp = new Define(uf, func); var parameters = new ExpressionParameters(); var result = exp.Execute(parameters); Assert.Equal(func, parameters.Functions[uf]); Assert.Equal("The expression 'sin(x)' was assigned to the function 's(x1)'.", result); }
public void DefineFuncTest() { var uf = new UserFunction("s", new IExpression[0], 0); var func = new Sin(new Number(1)); var exp = new Define(uf, func); var parameters = new ExpressionParameters(); var result = exp.Execute(parameters); Assert.Equal(func, parameters.Functions[uf]); Assert.Equal("The expression 'sin(1)' was assigned to the function 's()'.", result); }
public void CalculateForTest() { var parameters = new ExpressionParameters(); var init = new Define(new Variable("i"), new Number(0)); var cond = new LessThan(new Variable("i"), new Number(10)); var iter = new Define(new Variable("i"), new Add(new Variable("i"), new Number(1))); var @for = new For(new Variable("i"), init, cond, iter); @for.Execute(parameters); Assert.Equal(10.0, parameters.Variables["i"]); }
public void CalculateWhileTest() { var parameters = new ExpressionParameters(); parameters.Variables.Add(new Parameter("x", 0)); var body = new Define(new Variable("x"), new Add(new Variable("x"), new Number(2))); var cond = new LessThan(new Variable("x"), new Number(10)); var @while = new While(body, cond); @while.Execute(parameters); Assert.Equal(10.0, parameters.Variables["x"]); }
public void ExecuteRecursiveTest() { var expParams = new ExpressionParameters(); var exp = new If(new Equal(new Variable("x"), new Number(0)), new Number(1), new Mul(new Variable("x"), new UserFunction("f", new[] { new Sub(new Variable("x"), new Number(1)) }, 1))); expParams.Functions.Add(new UserFunction("f", new[] { new Variable("x") }, 1), exp); var func = new UserFunction("f", new[] { new Number(4) }, 1); Assert.Equal(24.0, func.Execute(expParams)); }
public PlottingGraph() { this.parameters = new ExpressionParameters(AngleMeasurement.Radian, new ParameterCollection() { { "x", 0 } }); InitializeComponent(); this.SizeChanged += this_SizeChanged; this.MouseLeftButtonDown += this_MouseLeftButtonDown; this.MouseDoubleClick += this_MouseDoubleClick; this.MouseMove += this_MouseMove; this.MouseWheel += this_MouseWheel; slider.ValueChanged += slider_ValueChanged; renderGrid.Checked += (o, args) => { ReRender(); }; renderGrid.Unchecked += (o, args) => { ReRender(); }; }
/// <summary> /// Calculates this Absolute expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { if (argument is Vector) { return Absolute( (Vector)argument, parameters); } else { var arg = argument.Calculate(parameters); if (arg is Double) return Math.Abs((double)arg); else if (arg is Vector) { return Absolute( (Vector)arg, parameters); } } throw new NotSupportedException(); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var result = m_argument.Execute(parameters); if (result is Complex complex) { return(Complex.Sqrt(complex)); } if (result is double number) { if (number < 0) { return(new Complex(0, Complex.Sqrt(number).Imaginary)); } return(Math.Sqrt(number)); } throw new ResultIsNotSupportedException(this, result); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> /// <exception cref="ArgumentNullException"><paramref name="parameters"/> is null.</exception> public object Execute(ExpressionParameters parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (key is Variable variable) { parameters.Variables.Remove(variable.Name); return(string.Format(Resource.UndefineVariable, key)); } if (key is UserFunction function) { parameters.Functions.Remove(function); } return(string.Format(Resource.UndefineFunction, key)); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// The exception. /// </returns> /// <seealso cref="ExpressionParameters" /> /// <exception cref="System.ArgumentNullException"><paramref name="parameters" /> is null.</exception> public object Execute(ExpressionParameters parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (key is Variable variable) { parameters.Variables[variable.Name] = value.Execute(parameters); return(string.Format(Resource.AssignVariable, key, value)); } if (key is UserFunction function) { parameters.Functions[function] = value; } return(string.Format(Resource.AssignFunction, key, value)); }
/// <summary> /// Executes this Absolute expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var result = m_argument.Execute(parameters); if (result is Complex complex) { return(Complex.Abs(complex)); } if (result is Vector vector) { return(vector.Abs(parameters)); } if (result is double number) { return(Math.Abs(number)); } throw new ResultIsNotSupportedException(this, result); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <exception cref="System.ArgumentNullException">The differentiator is null.</exception> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { if (Differentiator == null) { throw new ArgumentNullException(nameof(Differentiator)); } var variables = Helpers.GetAllVariables(m_argument).ToList(); var vector = new Vector(variables.Count); Differentiator.Parameters = parameters; for (var i = 0; i < variables.Count; i++) { Differentiator.Variable = variables[i]; vector[i] = m_argument.Analyze(Differentiator).Analyze(Simplifier); } return(vector); }
/// <summary> /// Executes the user function. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <exception cref="System.ArgumentNullException"><paramref name="parameters"/> is null.</exception> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } var func = parameters.Functions.GetKeyByKey(this); var newParameters = new ParameterCollection(parameters.Variables.Collection); for (var i = 0; i < m_arguments.Length; i++) { var arg = func.Arguments[i] as Variable; newParameters[arg.Name] = (double)this.m_arguments[i].Execute(parameters); } var expParam = new ExpressionParameters(parameters.AngleMeasurement, newParameters, parameters.Functions); return(parameters.Functions[this].Execute(expParam)); }
/// <summary> /// Calculates this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { if (ResultIsMatrix) { if (left is Vector && right is Vector) return MatrixExtentions.Add((Vector)left, (Vector)right, parameters); if (left is Matrix && right is Matrix) return MatrixExtentions.Add((Matrix)left, (Matrix)right, parameters); if ((left is Vector && right is Matrix) || (right is Vector && left is Matrix)) throw new NotSupportedException(); if (!(left is Vector || left is Matrix)) { var l = left.Calculate(parameters); if (l is Vector) return MatrixExtentions.Add((Vector)l, (Vector)right, parameters); if (l is Matrix) return MatrixExtentions.Add((Matrix)l, (Matrix)right, parameters); throw new NotSupportedException(); } if (!(right is Vector || right is Matrix)) { var r = right.Calculate(parameters); if (r is Vector) return MatrixExtentions.Add((Vector)left, (Vector)r, parameters); if (r is Matrix) return MatrixExtentions.Add((Matrix)left, (Matrix)r, parameters); throw new NotSupportedException(); } throw new NotSupportedException(); } return (double)left.Calculate(parameters) + (double)right.Calculate(parameters); }
/// <summary> /// Returns a specified number raised to the specified power. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A specified number raised to the specified power. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var leftResult = m_left.Execute(parameters); var rightResult = m_right.Execute(parameters); if (leftResult is Complex leftComplex && (rightResult is Complex || rightResult is double)) { var rightComplex = rightResult as Complex? ?? rightResult as double?; if (rightComplex == null) { throw new ResultIsNotSupportedException(this, leftResult, rightResult); } return(Complex.Pow(leftComplex, rightComplex.Value)); } if (leftResult is double leftNumber && rightResult is double rightNumber) { return(MathExtensions.Pow(leftNumber, rightNumber)); } throw new ResultIsNotSupportedException(this, leftResult, rightResult); }
/// <summary> /// Executes this Log expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var leftResult = m_left.Execute(parameters); if (leftResult is double leftNumber) { var rightResult = m_right.Execute(parameters); if (rightResult is Complex complex) { return(Complex.Log(complex, leftNumber)); } if (rightResult is double rightNumber) { return(Math.Log(rightNumber, leftNumber)); } throw new ResultIsNotSupportedException(this, rightResult); } throw new ResultIsNotSupportedException(this, leftResult); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var leftResult = m_left.Execute(parameters); var rightResult = m_right.Execute(parameters); if (leftResult is Complex || rightResult is Complex) { var leftComplex = leftResult as Complex? ?? leftResult as double?; var rightComplex = rightResult as Complex? ?? rightResult as double?; if (leftComplex == null || rightComplex == null) { throw new ResultIsNotSupportedException(this, leftResult, rightResult); } return(Complex.Divide(leftComplex.Value, rightComplex.Value)); } if (leftResult is double leftNumber && rightResult is double rightNumber) { return(leftNumber / rightNumber); } throw new ResultIsNotSupportedException(this, leftResult, rightResult); }
static double Absolute(Vector vec, ExpressionParameters parameters) { return Math.Sqrt( vec.Arguments.Sum ( a => Math.Pow ( ( double ) a.Calculate ( parameters ), 2 ) ) ); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var numbers = m_arguments.Select(item => (double)item.Execute(parameters)).ToArray(); return(MathExtensions.GCD(numbers)); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { return MathExtentions.Fact(Math.Round((double)argument.Calculate(parameters))); }
/// <summary> /// Executes this Ln expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { return(Math.Log((double)m_argument.Execute(parameters), 2)); }
/// <summary> /// Calculates this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { if (ResultType == ExpressionResultType.Matrix) { if (m_left.ResultType.HasFlag(ExpressionResultType.Matrix)) { var l = m_left.Calculate(parameters); var left = l as Vector; if (left != null) return left.Add((Vector)m_right, parameters); return ((Matrix)l).Add((Matrix)m_right, parameters); } if (m_right.ResultType.HasFlag(ExpressionResultType.Matrix)) { var r = m_right.Calculate(parameters); var right = r as Vector; if (right != null) return ((Vector)m_left).Add(right, parameters); return ((Matrix)m_left).Add((Matrix)r, parameters); } if ((m_left is Vector && m_right is Matrix) || (m_right is Vector && m_left is Matrix)) throw new NotSupportedException(); throw new NotSupportedException(); } return (double)m_left.Calculate(parameters) + (double)m_right.Calculate(parameters); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <exception cref="System.NotSupportedException">The multiplication of two vectors is not allowed.</exception> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var leftResult = m_left.Execute(parameters); var rightResult = m_right.Execute(parameters); if (leftResult is double leftNumber && rightResult is double rightNumber) { return(leftNumber * rightNumber); } if (leftResult is Complex || rightResult is Complex) { var leftComplex = leftResult as Complex? ?? leftResult as double?; var rightComplex = rightResult as Complex? ?? rightResult as double?; if (leftComplex == null || rightComplex == null) { throw new ResultIsNotSupportedException(this, leftResult, rightResult); } return(Complex.Multiply(leftComplex.Value, rightComplex.Value)); } if (leftResult is Matrix || rightResult is Matrix || leftResult is Vector || rightResult is Vector) { var leftExpResult = leftResult as IExpression ?? new Number((double)leftResult); var rightExpResult = rightResult as IExpression ?? new Number((double)rightResult); if (leftExpResult is Vector leftVector1 && rightExpResult is Vector rightVector1) { return(leftVector1.Mul(rightVector1, parameters)); } if (leftExpResult is Vector leftVector2) { if (rightExpResult is Matrix rightMaxtir1) { return(leftVector2.Mul(rightMaxtir1, parameters)); } return(leftVector2.Mul(rightExpResult, parameters)); } if (rightExpResult is Vector rightVector2) { if (leftExpResult is Matrix leftMatrix1) { return(rightVector2.Mul(leftMatrix1, parameters)); } return(rightVector2.Mul(leftExpResult, parameters)); } if (leftExpResult is Matrix leftMatrix2 && rightExpResult is Matrix rightMatrix2) { return(leftMatrix2.Mul(rightMatrix2, parameters)); } if (leftExpResult is Matrix leftMatrix3) { return(leftMatrix3.Mul(rightExpResult, parameters)); } if (rightExpResult is Matrix rightMatrix3) { return(rightMatrix3.Mul(leftExpResult, parameters)); } } throw new ResultIsNotSupportedException(this, leftResult, rightResult); }
public PlottingGraph() { this.parameters = new ExpressionParameters(AngleMeasurement.Radian, new ParameterCollection { { "x", 0 } }); InitializeComponent(); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public abstract object Execute(ExpressionParameters parameters);
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { return(MathExtensions.Fact(Math.Round((double)m_argument.Execute(parameters)))); }
/// <summary> /// Always throws an exception. /// </summary> /// <returns> /// A result of the calculation. /// </returns> /// <exception cref="NotSupportedException">Always.</exception> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { if (parameters == null) throw new ArgumentNullException(nameof(parameters)); var func = parameters.Functions.GetKeyByKey(this); var newParameters = new ParameterCollection(parameters.Parameters.Collection); for (int i = 0; i < m_arguments.Length; i++) { var arg = func.Arguments[i] as Variable; newParameters[arg.Name] = (double)this.m_arguments[i].Calculate(parameters); } var expParam = new ExpressionParameters(parameters.AngleMeasurement, newParameters, parameters.Functions); return parameters.Functions[this].Calculate(expParam); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { var body = Body; var from = From != null ? (double)From.Calculate(parameters) : 1; var to = (double)To.Calculate(parameters); var inc = Increment != null ? (double)Increment.Calculate(parameters) : 1; var localParams = new ParameterCollection(parameters.Parameters.Collection); var variable = Variable != null ? Variable.Name : GetVarName(localParams); localParams.Add(variable, from); var param = new ExpressionParameters(parameters.AngleMeasurement, localParams, parameters.Functions); double S = 1; for (; from <= to; from += inc) { localParams[variable] = from; S *= (double)body.Calculate(param); } return S; }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { var arg = (double)Argument.Calculate(parameters); var digits = Digits != null ? (int)(double)Digits.Calculate(parameters) : 0; #if PORTABLE return Math.Round(arg, digits); #else return Math.Round(arg, digits, MidpointRounding.AwayFromZero); #endif }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { var numbers = arguments.Select(item => (double)item.Calculate(parameters)).ToArray(); return MathExtentions.LCM(numbers); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> /// <exception cref="ArgumentNullException"><paramref name="parameters"/> is null.</exception> public object Calculate(ExpressionParameters parameters) { if (parameters == null) throw new ArgumentNullException(nameof(parameters)); var variable = key as Variable; if (variable != null) { parameters.Parameters.Remove(variable.Name); } else { var function = key as UserFunction; if (function != null) parameters.Functions.Remove(function); } return double.NaN; }
/// <summary> /// Returns a number. /// </summary> /// <param name="parameters">A collection of variables.</param> /// <returns>A result of the execution.</returns> /// <seealso cref="ExpressionParameters"/> public object Execute(ExpressionParameters parameters) { return(Value); }
private IExpression Differentiate(IExpression exp, Variable variable, ExpressionParameters parameters) { return exp.Analyze(new Differentiator(parameters, variable)); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public abstract object Calculate(ExpressionParameters parameters);
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { var differentiator = new Differentiator (); var derivat = differentiator.Differentiate ( this.Expression, this.Variable ); return derivat.Calculate ( parameters ); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { return Simpson (parameters); }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <exception cref="System.NotSupportedException">The multiplication of two vectors is not allowed.</exception> /// <seealso cref="ExpressionParameters" /> public override object Execute(ExpressionParameters parameters) { var resultType = this.ResultType; if (resultType == ExpressionResultType.Matrix || resultType == ExpressionResultType.Vector) { var temp = m_left.Execute(parameters); var leftExpResult = temp as IExpression ?? new Number((double)temp); temp = m_right.Execute(parameters); var rightExpResult = temp as IExpression ?? new Number((double)temp); if (leftExpResult is Vector && rightExpResult is Vector) { return(((Vector)leftExpResult).Cross((Vector)rightExpResult, parameters)); } if (leftExpResult is Vector) { if (rightExpResult is Matrix) { return(((Vector)leftExpResult).Mul((Matrix)rightExpResult, parameters)); } return(((Vector)leftExpResult).Mul(rightExpResult, parameters)); } if (rightExpResult is Vector) { if (leftExpResult is Matrix) { return(((Matrix)leftExpResult).Mul((Vector)rightExpResult, parameters)); } return(((Vector)rightExpResult).Mul(leftExpResult, parameters)); } if (leftExpResult is Matrix && rightExpResult is Matrix) { return(((Matrix)leftExpResult).Mul((Matrix)rightExpResult, parameters)); } if (leftExpResult is Matrix) { return(((Matrix)leftExpResult).Mul(rightExpResult, parameters)); } if (rightExpResult is Matrix) { return(((Matrix)rightExpResult).Mul(leftExpResult, parameters)); } } var leftResult = m_left.Execute(parameters); var rightResult = m_right.Execute(parameters); if (resultType == ExpressionResultType.ComplexNumber) { var leftComplex = leftResult as Complex? ?? (double)leftResult; var rightComplex = rightResult as Complex? ?? (double)rightResult; return(Complex.Multiply(leftComplex, rightComplex)); } return((double)leftResult * (double)rightResult); }
double Rectangle(ExpressionParameters parameters) { if (parameters == null) parameters = new ExpressionParameters (); var result = 0.0M; var left = (decimal)(double)this.Left.Calculate (parameters); var right = (decimal)(double)this.Right.Calculate (parameters); if (right <= left) throw new InvalidOperationException ("Invalid Intergral-Bounds"); var n = 1000; // number of rectangles var dx = (right - left) / (decimal)n; var param = default(Parameter); foreach (var p in parameters.Parameters.Collection) { if (p.Key == this.Variable.Name) { param = p; break; } } if (param == null) { param = new Parameter ( this.Variable.Name, 0, ParameterType.Normal); parameters.Parameters.Add (param); } for (var x = left; x <= right; x += dx) { param.Value = (double)x; var z = (double)this.Body.Calculate (parameters); result += (dx * (decimal)z); } return (double)result; }
/// <summary> /// Executes this expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the execution. /// </returns> /// <seealso cref="ExpressionParameters" /> public object Execute(ExpressionParameters parameters) { return(func(parameters)); }
double Simpson(ExpressionParameters parameters) { if (parameters == null) parameters = new ExpressionParameters (); var a = (double)this.Left.Calculate (parameters); var b = (double)this.Right.Calculate (parameters); if (b <= a) throw new InvalidOperationException ("Invalid Intergral-Bounds"); var n = 10000; // number of rectangles var h = (b - a) / (double)n; var param = default(Parameter); foreach (var p in parameters.Parameters.Collection) { if (p.Key == this.Variable.Name) { param = p; break; } } if (param == null) { param = new Parameter ( this.Variable.Name, 0, ParameterType.Normal); parameters.Parameters.Add (param); } var sum = 0.0; for (var i = 1; i <= n - 3; i = i + 2) { param.Value = a + i * h; sum += (double)this.Body.Calculate (parameters); } param.Value = a + (n - 1) * h; sum += (double)this.Body.Calculate (parameters); sum *= 4; var sum2 = 0.0; for (var i = 2; i <= n - 4; i += 2) { param.Value = a + i * h; sum2 += (double)this.Body.Calculate (parameters); } param.Value = a + (n - 2) * h; sum2 += (double)this.Body.Calculate (parameters); sum2 *= 2; sum += sum2; param.Value = a; sum += (double)this.Body.Calculate (parameters); param.Value = b; sum += (double)this.Body.Calculate (parameters); return Math.Round ( h / 3 * sum, 5 ); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { return -(double)argument.Calculate(parameters); }
/// <summary> /// Calculates this mathemarical expression. /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> /// <seealso cref="ExpressionParameters" /> public override object Calculate(ExpressionParameters parameters) { return Math.Round ( (double)Argument.Calculate(parameters)); }