/// <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));
}
