/// <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)
        {
            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)
        {
            while (right.Calculate(parameters).AsBool())
                left.Calculate(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)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)
        {
            var var = (Variable)argument;
            var newValue = parameters.Parameters[var.Name] + 1;
            parameters.Parameters[var.Name] = newValue;

            return newValue;
        }

 /// <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)
        {
            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>
        /// 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>
        /// 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>
 /// 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 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 (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>
        /// 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>
 /// 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>
 /// 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 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
 }