/// <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 leftValue = (double)m_left.Calculate(parameters);
var rightValue = (double)m_right.Calculate(parameters);
return leftValue >= rightValue;
}
/// <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 leftValue = (double)left.Calculate(parameters);
var rightValue = (double)right.Calculate(parameters);
return (leftValue == rightValue).AsNumber();
}
/// <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)
{
while (right.Calculate(parameters).AsBool())
left.Calculate(parameters);
return double.NaN;
}
/// <summary>
/// Calculates this bitwise NOT 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 PORTABLE
return ~(int)Math.Round((double)argument.Calculate(parameters));
#else
return ~(int)Math.Round((double)argument.Calculate(parameters), 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 var = (Variable)argument;
var newValue = parameters.Parameters[var.Name] + 1;
parameters.Parameters[var.Name] = newValue;
return newValue;
}
/// <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 var = (Variable)left;
var newValue = parameters.Parameters[var.Name] - (double)right.Calculate(parameters);
parameters.Parameters[var.Name] = newValue;
return newValue;
}
/// <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)
{
if (parameters == null || parameters.AngleMeasurement == AngleMeasurement.Degree)
return CalculateDergee(parameters);
if (parameters.AngleMeasurement == AngleMeasurement.Radian)
return CalculateRadian(parameters);
if (parameters.AngleMeasurement == AngleMeasurement.Gradian)
return CalculateGradian(parameters);
return double.NaN;
}
/// <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 var = (Variable)m_argument;
var parameter = var.Calculate(parameters);
if (parameter is bool)
throw new NotSupportedException();
var newValue = Convert.ToDouble(parameter) - 1;
parameters.Parameters[var.Name] = newValue;
return newValue;
}
/// <summary>
/// Adds the <paramref name="right"/> vector to the <paramref name="left"/> vector.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The sum of matrices.</returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Vector Add(this Vector left, Vector right, ExpressionParameters parameters)
{
if (left.ParametersCount != right.ParametersCount)
throw new ArgumentException(Resource.MatrixArgException);
var exps = new IExpression[left.ParametersCount];
Parallel.For(0, left.ParametersCount,
i => exps[i] = new Number((double)left.Arguments[i].Execute(parameters) + (double)right.Arguments[i].Execute(parameters))
);
return new Vector(exps);
}
/// <summary>
/// Adds the <paramref name="right"/> vector to the <paramref name="left"/> vector.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The sum of matrices.</returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Vector Add(this Vector left, Vector right, ExpressionParameters parameters)
{
if (left.ParametersCount != right.ParametersCount)
throw new ArgumentException(Resource.MatrixArgException);
var exps = new IExpression[left.ParametersCount];
#if NET40_OR_GREATER
Parallel.For(0, left.ParametersCount,
i => exps[i] = new Number((double)left.Arguments[i].Calculate(parameters) + (double)right.Arguments[i].Calculate(parameters))
);
#else
for (int i = 0; i < left.ParametersCount; i++)
exps[i] = new Number((double)left.Arguments[i].Calculate(parameters) + (double)right.Arguments[i].Calculate(parameters));
#endif
return new Vector(exps);
}
/// <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 value = m_argument.Execute(parameters);
if (value is bool)
{
throw new NotSupportedException();
}
var newValue = Convert.ToDouble(value) - 1;
if (m_argument is Variable variable)
{
parameters.Variables[variable.Name] = newValue;
}
return(newValue);
}
/// <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 data = m_arguments;
if (ParametersCount == 1)
{
var result = m_arguments[0].Execute(parameters);
if (result is Vector vector)
{
data = vector.Arguments;
}
}
var calculatedArray = ExecuteArray(data, parameters);
var avg = calculatedArray.Average();
return(calculatedArray.Sum(x => Math.Pow(x - avg, 2)) / (calculatedArray.Length - 1));
}
/// <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 data = m_arguments;
if (ParametersCount == 1)
{
var result = m_arguments[0].Execute(parameters);
var vector = result as Vector;
if (vector != null)
{
data = vector.Arguments;
}
}
var avg = data.Average(exp => (double)exp.Execute(parameters));
var variance = data.Average(exp => Math.Pow((double)exp.Execute(parameters) - avg, 2));
return(Math.Sqrt(variance));
}
/// <summary>
/// Calculates ths dot product of two vectors.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The dot product of vectors.
/// </returns>
/// <exception cref="System.ArgumentException">The size of vectors is invalid.</exception>
public static double Mul(this Vector left, Vector right, ExpressionParameters parameters)
{
if (left.ParametersCount != right.ParametersCount)
{
throw new ArgumentException(Resource.MatrixArgException);
}
var vector1 = left.ToCalculatedArray(parameters);
var vector2 = right.ToCalculatedArray(parameters);
var product = 0.0;
for (var i = 0; i < vector1.Length; i++)
{
product += vector1[i] * vector2[i];
}
return(product);
}
/// <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 Matrix matrix)
{
if (matrix.Arguments.Any(x => x == null))
{
throw new ArgumentException(Resource.SequenceNullValuesError);
}
if (matrix.Arguments.OfType <Vector>().Any(x => x.Arguments.All(z => z == null)))
{
throw new ArgumentException(Resource.SequenceNullValuesError);
}
return(matrix.Determinant(parameters));
}
throw new ResultIsNotSupportedException(this, result);
}
/// <summary>
/// Decomposes a matrix.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <param name="permutation">An array of permutations.</param>
/// <param name="toggle">Used for calculating a determinant.</param>
/// <returns>Combined Lower and Upper matrices.</returns>
public static Matrix LUPDecomposition(this Matrix matrix, ExpressionParameters parameters, out int[] permutation, out int toggle)
{
if (!matrix.IsSquare)
{
throw new ArgumentException(Resource.MatrixArgException);
}
var result = LUPDecomposition_(matrix.ToCalculatedArray(parameters), out permutation, out toggle);
var m = new Matrix(result.Length, result.Length);
for (int i = 0; i < result.Length; i++)
{
for (int j = 0; j < result.Length; j++)
{
m[i][j] = new Number(result[i][j]);
}
}
return(m);
}
/// <summary>
/// Inverts a matrix.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>An inverse matrix.</returns>
public static Matrix Inverse(this Matrix matrix, ExpressionParameters parameters)
{
if (!matrix.IsSquare)
{
throw new ArgumentException(Resource.MatrixArgException);
}
var size = matrix.ParametersCount;
var result = Inverse_(matrix.ToCalculatedArray(parameters));
var m = new Matrix(size, size);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
m[i][j] = new Number(result[i][j]);
}
}
return(m);
}
/// <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)
{
var angleMeasurement = parameters?.AngleMeasurement ?? AngleMeasurement.Degree;
if (angleMeasurement == AngleMeasurement.Degree)
{
return(complex.Phase * 180 / Math.PI);
}
if (angleMeasurement == AngleMeasurement.Gradian)
{
return(complex.Phase * 200 / Math.PI);
}
return(complex.Phase);
}
throw new ResultIsNotSupportedException(this, result);
}
/// <summary>
/// Subtracts the <paramref name="right"/> matrix from the <paramref name="left"/> matrix.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The difference of matrices.</returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Sub(this Matrix left, Matrix right, ExpressionParameters parameters)
{
if (left.ParametersCount != right.ParametersCount || left.SizeOfVectors != right.SizeOfVectors)
{
throw new ArgumentException(Resource.MatrixArgException);
}
var vectors = new Vector[left.ParametersCount];
Parallel.For(0, left.ParametersCount, i =>
{
var exps = new IExpression[left.SizeOfVectors];
for (var j = 0; j < left.SizeOfVectors; j++)
{
exps[j] = new Number((double)left[i][j].Execute(parameters) - (double)right[i][j].Execute(parameters));
}
vectors[i] = new Vector(exps);
});
return(new Matrix(vectors));
}
/// <summary>
/// Executes 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 Execute(ExpressionParameters parameters)
{
var resultType = this.ResultType;
if (resultType == ExpressionResultType.ComplexNumber)
{
return(ExecuteComplex(parameters));
}
if (parameters == null || parameters.AngleMeasurement == AngleMeasurement.Degree)
{
return(ExecuteDergee(parameters));
}
if (parameters.AngleMeasurement == AngleMeasurement.Radian)
{
return(ExecuteRadian(parameters));
}
if (parameters.AngleMeasurement == AngleMeasurement.Gradian)
{
return(ExecuteGradian(parameters));
}
return(double.NaN);
}
/// <summary>
/// Multiplies the <paramref name="left" /> matrix by the <paramref name="right" /> matrix.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Matrix left, Matrix right, ExpressionParameters parameters)
{
if (left.SizeOfVectors != right.ParametersCount)
{
throw new ArgumentException(Resource.MatrixArgException);
}
var result = new Matrix(left.ParametersCount, right.SizeOfVectors);
Parallel.For(0, right.SizeOfVectors, i =>
{
for (var j = 0; j < left.ParametersCount; j++)
{
double el = 0;
for (var k = 0; k < left.SizeOfVectors; k++)
{
el += (double)left[j][k].Execute(parameters) * (double)right[k][i].Execute(parameters);
}
result[j][i] = new Number(el);
}
});
return(result);
}
/// <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 object Calculate(ExpressionParameters parameters)
{
return value;
}
/// <summary>
/// Multiplies the <paramref name="left" /> matrix by the <paramref name="right" /> vector.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Matrix left, Vector right, ExpressionParameters parameters)
{
var matrix = new Matrix(new[] { right });
return(left.Mul(matrix, parameters));
}
/// <summary>
/// Multiplies the <paramref name="left" /> vector by the <paramref name="right" /> matrix.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Vector left, Matrix right, ExpressionParameters parameters)
{
var matrix = new Matrix(new[] { left });
return matrix.Mul(right, parameters);
}
/// <summary>
/// Multiplies <paramref name="matrix"/> by <paramref name="number"/>.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="number">The number.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The product of matrix and number.</returns>
public static Matrix Mul(this Matrix matrix, IExpression number, ExpressionParameters parameters)
{
var n = (double)number.Calculate(parameters);
#if NET40_OR_GREATER
var result = from v in matrix.Arguments.AsParallel().AsOrdered()
select new Vector(
(from num in ((Vector)v).Arguments
select new Number((double)num.Calculate(parameters) * n))
.ToArray()
);
#else
var result = from v in matrix.Arguments
select new Vector(
(from num in ((Vector)v).Arguments
select new Number((double)num.Calculate(parameters) * n))
.ToArray()
);
#endif
return new Matrix(result.ToArray());
}
/// <summary>
/// Decomposes a matrix.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <param name="permutation">An array of permutations.</param>
/// <param name="toggle">Used for calculating a determinant.</param>
/// <returns>Combined Lower and Upper matrices.</returns>
public static Matrix LUPDecomposition(this Matrix matrix, ExpressionParameters parameters, out int[] permutation, out int toggle)
{
if (!matrix.IsSquare)
throw new ArgumentException(Resource.MatrixArgException);
var result = LUPDecomposition_(matrix.ToCalculatedArray(parameters), out permutation, out toggle);
var m = new Matrix(result.Length, result.Length);
for (int i = 0; i < result.Length; i++)
for (int j = 0; j < result.Length; j++)
m[i][j] = new Number(result[i][j]);
return m;
}
/// <summary>
/// Calculates this mathematical expression (using degree).
/// </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" />
protected override double ExecuteDergee(ExpressionParameters parameters)
{
var radian = (double)m_argument.Execute(parameters) * Math.PI / 180;
return(1 / Math.Cos(radian));
}
/// <summary> /// Calculates this mathematical expression (using degree). /// </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" /> protected abstract double ExecuteDergee(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" />
protected override double ExecuteNumber(ExpressionParameters parameters)
{
return(MathExtensions.Acoth((double)m_argument.Execute(parameters)));
}
/// <summary>
/// Calculates this mathemarical expression (using gradian).
/// </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" />
protected override double CalculateGradian(ExpressionParameters parameters)
{
return MathExtentions.Asec((double)m_argument.Calculate(parameters)) / Math.PI * 200;
}
/// <summary>
/// Calculates the absolute value (norm) of vector.
/// </summary>
/// <param name="vector">The vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>Return the absolute value of vector.</returns>
public static double Abs(this Vector vector, ExpressionParameters parameters)
{
return(Math.Sqrt(vector.Arguments.Sum(arg => Math.Pow((double)arg.Execute(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" /> protected abstract double ExecuteNumber(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)
{
return (bool)m_left.Calculate(parameters) && (bool)m_right.Calculate(parameters);
}
/// <summary>
/// Calculates this mathematical expression (using gradian).
/// </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" />
protected override double ExecuteGradian(ExpressionParameters parameters)
{
var radian = (double)m_argument.Execute(parameters) * Math.PI / 200;
return(Math.Tan(radian));
}
/// <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 MatrixExtentions.Inverse((Matrix)argument.Calculate(parameters), parameters);
}
/// <summary>
/// Calculates this mathematical expression (using radian).
/// </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" />
protected override double ExecuteRadian(ExpressionParameters parameters)
{
return(Math.Acos((double)m_argument.Execute(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 MathExtentions.Acsch((double)m_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>
/// <exception cref="System.ArgumentNullException">If the "else" statement is null.</exception>
/// <seealso cref="ExpressionParameters" />
public override object Calculate(ExpressionParameters parameters)
{
if ((bool)Condition.Calculate(parameters))
return Then.Calculate(parameters);
var @else = Else;
if (@else == null)
throw new ArgumentNullException(nameof(@else));
return @else.Calculate(parameters);
}
/// <summary> /// Calculates the this mathematical expression (complex number). /// </summary> /// <param name="parameters">An object that contains all parameters and functions for expressions.</param> /// <returns> /// A result of the calculation. /// </returns> protected abstract Complex ExecuteComplex(ExpressionParameters parameters);
/// <summary>
/// Executes this NAND 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(!((bool)m_left.Execute(parameters) & (bool)m_right.Execute(parameters)));
}
/// <summary>
/// Inverts a matrix.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>An inverse matrix.</returns>
public static Matrix Inverse(this Matrix matrix, ExpressionParameters parameters)
{
if (!matrix.IsSquare)
throw new ArgumentException(Resource.MatrixArgException);
var size = matrix.ParametersCount;
var result = Inverse_(matrix.ToCalculatedArray(parameters));
var m = new Matrix(size, size);
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
m[i][j] = new Number(result[i][j]);
return m;
}
/// <summary>
/// Calculates this mathemarical expression (using radian).
/// </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" />
protected override double CalculateRadian(ExpressionParameters parameters)
{
return Math.Cos((double)m_argument.Calculate(parameters));
}
/// <summary>
/// Multiplies <paramref name="vector"/> by <paramref name="number"/>.
/// </summary>
/// <param name="vector">The vector.</param>
/// <param name="number">The number.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The product of matrices.</returns>
public static Vector Mul(this Vector vector, IExpression number, ExpressionParameters parameters)
{
var n = (double)number.Calculate(parameters);
#if NET40_OR_GREATER
var numbers = (from num in vector.Arguments.AsParallel().AsOrdered()
select new Number((double)num.Calculate(parameters) * n))
.ToArray();
#else
var numbers = (from num in vector.Arguments
select new Number((double)num.Calculate(parameters) * n))
.ToArray();
#endif
return new Vector(numbers);
}
/// <summary>
/// Calculates this mathemarical expression (using degree).
/// </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" />
protected override double CalculateDergee(ExpressionParameters parameters)
{
var radian = (double)m_argument.Calculate(parameters) * Math.PI / 180;
return Math.Cos(radian);
}
/// <summary>
/// Multiplies the <paramref name="left" /> matrix by the <paramref name="right" /> matrix.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Matrix left, Matrix right, ExpressionParameters parameters)
{
if (left.SizeOfVectors != right.ParametersCount)
throw new ArgumentException(Resource.MatrixArgException);
var result = new Matrix(left.ParametersCount, right.SizeOfVectors);
#if NET40_OR_GREATER
Parallel.For(0, right.SizeOfVectors, i =>
{
for (int j = 0; j < left.ParametersCount; j++)
{
double el = 0;
for (int k = 0; k < left.SizeOfVectors; k++)
el += (double)left[j][k].Calculate(parameters) * (double)right[k][i].Calculate(parameters);
result[j][i] = new Number(el);
}
});
#else
for (int i = 0; i < right.SizeOfVectors; i++)
{
for (int j = 0; j < left.ParametersCount; j++)
{
double el = 0;
for (int k = 0; k < left.SizeOfVectors; k++)
el += (double)left[j][k].Calculate(parameters) * (double)right[k][i].Calculate(parameters);
result[j][i] = new Number(el);
}
}
#endif
return 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="System.NotSupportedException">Always.</exception>
public override object Execute(ExpressionParameters parameters)
{
return(new Matrix(CalculateMatrix(parameters)));
}
/// <summary>
/// Multiplies the <paramref name="left" /> matrix by the <paramref name="right" /> vector.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right vector.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Matrix left, Vector right, ExpressionParameters parameters)
{
var matrix = new Matrix(new[] { right });
return left.Mul(matrix, parameters);
}
internal double[][] ToCalculatedArray(ExpressionParameters parameters)
{
return((from Vector vector in m_arguments.AsParallel().AsOrdered()
select vector.ToCalculatedArray(parameters)).ToArray());
}
/// <summary>
/// Adds the <paramref name="right"/> matrix to the <paramref name="left"/> matrix.
/// </summary>
/// <param name="left">The left matrix.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The sum of matrices.</returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Add(this Matrix left, Matrix right, ExpressionParameters parameters)
{
if (left.ParametersCount != right.ParametersCount || left.SizeOfVectors != right.SizeOfVectors)
throw new ArgumentException(Resource.MatrixArgException);
var vectors = new Vector[left.ParametersCount];
#if NET40_OR_GREATER
Parallel.For(0, left.ParametersCount, i =>
{
var exps = new IExpression[left.SizeOfVectors];
for (int j = 0; j < left.SizeOfVectors; j++)
exps[j] = new Number((double)left[i][j].Calculate(parameters) + (double)right[i][j].Calculate(parameters));
vectors[i] = new Vector(exps);
});
#else
for (int i = 0; i < left.ParametersCount; i++)
{
var exps = new IExpression[left.SizeOfVectors];
for (int j = 0; j < left.SizeOfVectors; j++)
exps[j] = new Number((double)left[i][j].Calculate(parameters) + (double)right[i][j].Calculate(parameters));
vectors[i] = new Vector(exps);
}
#endif
return new Matrix(vectors);
}
/// <summary>
/// Calculates this mathematical expression (using gradian).
/// </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" />
protected override double ExecuteGradian(ExpressionParameters parameters)
{
return(MathExtensions.Asec((double)m_argument.Execute(parameters)) / Math.PI * 200);
}
/// <summary>
/// Calculates the this mathematical expression (complex number).
/// </summary>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// A result of the calculation.
/// </returns>
protected override Complex ExecuteComplex(ExpressionParameters parameters)
{
return(Complex.Acos((Complex)m_argument.Execute(parameters)));
}
/// <summary>
/// Multiplies the <paramref name="left" /> vector by the <paramref name="right" /> matrix.
/// </summary>
/// <param name="left">The left vector.</param>
/// <param name="right">The right matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>
/// The product of matrices.
/// </returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static Matrix Mul(this Vector left, Matrix right, ExpressionParameters parameters)
{
var matrix = new Matrix(new[] { left });
return(matrix.Mul(right, parameters));
}
/// <summary>
/// Calculates this mathematical expression (using gradian).
/// </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" />
protected override double ExecuteGradian(ExpressionParameters parameters)
{
var radian = (double)m_argument.Execute(parameters);
return(Math.Acos(radian) / Math.PI * 200);
}
/// <summary>
/// Calculates this mathemarical expression (using radian).
/// </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" />
protected override double CalculateRadian(ExpressionParameters parameters)
{
return MathExtentions.Asec((double)argument.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>
/// <seealso cref="ExpressionParameters" />
public object Execute(ExpressionParameters parameters)
{
return(Value);
}
/// <summary>
/// Calculates this mathemarical expression (using degree).
/// </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" />
protected override double CalculateDergee(ExpressionParameters parameters)
{
return MathExtentions.Asec((double)argument.Calculate(parameters)) / Math.PI * 180;
}
/// <summary> /// Calculates this mathematical expression (using gradian). /// </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" /> protected abstract double ExecuteGradian(ExpressionParameters parameters);
/// <summary>
/// Calculates a determinant of specified matrix.
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="parameters">An object that contains all parameters and functions for expressions.</param>
/// <returns>The determinant of matrix.</returns>
/// <exception cref="System.ArgumentException">The size of matrices is invalid.</exception>
public static double Determinant(this Matrix matrix, ExpressionParameters parameters)
{
if (!matrix.IsSquare)
throw new ArgumentException(Resource.MatrixArgException);
var array = matrix.ToCalculatedArray(parameters);
return Determinant_(array);
}
/// <summary>
/// Initializes a new instance of the <see cref="Processor" /> class.
/// </summary>
/// <param name="lexer">The lexer.</param>
/// <param name="parser">The parser.</param>
/// <param name="simplifier">The simplifier.</param>
/// <param name="differentiator">The differentiator.</param>
/// <param name="parameters">The collection of parameters.</param>
public Processor(ILexer lexer, IParser parser, ISimplifier simplifier, IDifferentiator differentiator, ExpressionParameters parameters)
{
Lexer = lexer;
Simplifier = simplifier;
Differentiator = differentiator;
Parser = parser;
Parameters = parameters;
NumeralSystem = NumeralSystem.Decimal;
DoSimplify = true;
}
/// <summary>
/// Calculates this AND 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 PORTABLE
if (ResultType == ExpressionResultType.Number)
return (int)Math.Round((double)m_left.Calculate(parameters)) & (int)Math.Round((double)m_right.Calculate(parameters));
else
return (bool)m_left.Calculate(parameters) & (bool)m_right.Calculate(parameters);
#else
if (ResultType == ExpressionResultType.Number)
return (int)Math.Round((double)m_left.Calculate(parameters), MidpointRounding.AwayFromZero) & (int)Math.Round((double)m_right.Calculate(parameters), MidpointRounding.AwayFromZero);
else
return (bool)m_left.Calculate(parameters) & (bool)m_right.Calculate(parameters);
#endif
}
