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