处理数学Math类应用

程序集 mscorlib.dll

#region 程序集 mscorlib.dll, v4.0.0.0
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion

using System.Runtime;
using System.Runtime.ConstrainedExecution;
using System.Security;

namespace System
{
    // 摘要:
    //     为三角函数、对数函数和其他通用数学函数提供常数和静态方法。
    public static class Math
    {
        // 摘要:
        //     表示自然对数的底，它由常数 e 指定。
        public const double E = 2.71828;
        //
        // 摘要:
        //     表示圆的周长与其直径的比值，由常数 π 指定。
        public const double PI = 3.14159;

        // 摘要:
        //     返回 System.Decimal 数字的绝对值。
        //
        // 参数:
        //   value:
        //     但大于或等于 System.Decimal.MinValue，但小于或等于 System.Decimal.MaxValue 的数。
        //
        // 返回结果:
        //     十进制数 x，使其满足 0 ≤ x ≤System.Decimal.MaxValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static decimal Abs(decimal value);
        //
        // 摘要:
        //     返回双精度浮点数字的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于或等于 System.Double.MinValue，但小于或等于的数 System.Double.MaxValue。
        //
        // 返回结果:
        //     一个双精度浮点数 x，满足 0 ≤ x ≤System.Double.MaxValue。
        [SecuritySafeCritical]
        public static double Abs(double value);
        //
        // 摘要:
        //     返回单精度浮点数字的绝对值。
        //
        // 参数:
        //   value:
        //     但大于或等于 System.Single.MinValue，但小于或等于 System.Single.MaxValue 的数。
        //
        // 返回结果:
        //     单精度浮点数 x，满足 0 ≤ x ≤System.Single.MaxValue。
        [SecuritySafeCritical]
        public static float Abs(float value);
        //
        // 摘要:
        //     返回 32 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.Int32.MinValue，但小于或等于 System.Int32.MaxValue 的数。
        //
        // 返回结果:
        //     32 位有符号整数 x，满足 0 ≤ x ≤System.Int32.MaxValue。
        //
        // 异常:
        //   System.OverflowException:
        //     value 等于 System.Int32.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Abs(int value);
        //
        // 摘要:
        //     返回 64 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.Int64.MinValue，但小于或等于 System.Int64.MaxValue 的数。
        //
        // 返回结果:
        //     64 位有符号整数 x，满足 0 ≤ x ≤System.Int64.MaxValue。
        //
        // 异常:
        //   System.OverflowException:
        //     value 等于 System.Int64.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long Abs(long value);
        //
        // 摘要:
        //     返回 8 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.SByte.MinValue，但小于或等于 System.SByte.MaxValue 的数。
        //
        // 返回结果:
        //     8 位有符号整数 x，满足 0 ≤ x ≤System.SByte.MaxValue。
        //
        // 异常:
        //   System.OverflowException:
        //     value 等于 System.SByte.MinValue。
        [CLSCompliant(false)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static sbyte Abs(sbyte value);
        //
        // 摘要:
        //     返回 16 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.Int16.MinValue，但小于或等于 System.Int16.MaxValue 的数。
        //
        // 返回结果:
        //     16 位有符号整数 x，满足 0 ≤ x ≤System.Int16.MaxValue。
        //
        // 异常:
        //   System.OverflowException:
        //     value 等于 System.Int16.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static short Abs(short value);
        //
        // 摘要:
        //     返回余弦值为指定数字的角度。
        //
        // 参数:
        //   d:
        //     代表余弦的数字，其中 d 必须大于或等于 -1，但小于或等于 1。
        //
        // 返回结果:
        //     角度 θ，以弧度为单位，满足 0 ≤θ≤π - 或 - 如果 d < -1 或 d > 1 或 d 等于 System.Double.NaN 则为
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Acos(double d);
        //
        // 摘要:
        //     返回正弦值为指定数字的角度。
        //
        // 参数:
        //   d:
        //     代表正弦的数字，其中 d 必须大于或等于 -1，但小于或等于 1。
        //
        // 返回结果:
        //     角度 θ，以弧度为单位，满足 -π/2 ≤θ≤π/2 - 或 - 如果 d < -1 或 d > 1 或 d 等于 System.Double.NaN
        //     则为 System.Double.NaN。
        [SecuritySafeCritical]
        public static double Asin(double d);
        //
        // 摘要:
        //     返回正切值为指定数字的角度。
        //
        // 参数:
        //   d:
        //     表示正切值的数字。
        //
        // 返回结果:
        //     角度 θ，以弧度为单位，满足 -π/2 ≤θ≤π/2。 - 或 - 如果 d 等于 System.Double.NaN，则为 System.Double.NaN；如果
        //     d 等于 System.Double.NegativeInfinity，则为舍入为双精度值 (-1.5707963267949) 的 -π/2；或者如果
        //     d 等于 System.Double.PositiveInfinity，则为舍入为双精度值 (1.5707963267949) 的 π/2。
        [SecuritySafeCritical]
        public static double Atan(double d);
        //
        // 摘要:
        //     返回正切值为两个指定数字的商的角度。
        //
        // 参数:
        //   y:
        //     点的 y 坐标。
        //
        //   x:
        //     点的 x 坐标。
        //
        // 返回结果:
        //     角度 θ，以弧度为单位，满足 -π≤θ≤π，且 tan(θ) = y / x，其中 (x, y) 是笛卡尔平面中的点。 请看下面： 如果 (x,
        //     y) 在第 1 象限，则 0 < θ < π/2。 如果 (x, y) 在第 2 象限，则 π/2 < θ≤π。 如果 (x, y) 在第 3 象限，则
        //     -π < θ < -π/2。 如果 (x, y) 在第 4 象限，则 -π/2 < θ < 0。 如果点在象限的边界上，则返回值如下： 如果 y
        //     为 0 并且 x 不为负值，则 θ = 0。 如果 y 为 0 并且 x 为负值，则 θ = π。 如果 y 为正值并且 x 为 0，则 θ =
        //     π/2。 如果 y 为负值并且 x 为 0，则 θ = -π/2。 如果 x 或 y 是 System.Double.NaN，或者如果 x 和 y
        //     是 System.Double.PositiveInfinity 或 System.Double.NegativeInfinity，则该方法返回
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Atan2(double y, double x);
        //
        // 摘要:
        //     生成两个 32 位数字的完整乘积。
        //
        // 参数:
        //   a:
        //     要相乘的第一个数字。
        //
        //   b:
        //     要相乘的第二个数字。
        //
        // 返回结果:
        //     包含指定数字乘积的数。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long BigMul(int a, int b);
        //
        // 摘要:
        //     返回大于或等于指定的十进制数的最小整数值。
        //
        // 参数:
        //   d:
        //     一个小数。
        //
        // 返回结果:
        //     大于或等于 d 的最小整数值。 请注意，此方法返回 System.Decimal，而不是整数类型。
        public static decimal Ceiling(decimal d);
        //
        // 摘要:
        //     返回大于或等于指定的双精度浮点数的最小整数值。
        //
        // 参数:
        //   a:
        //     一个双精度浮点数。
        //
        // 返回结果:
        //     大于或等于 a 的最小整数值。 如果 a 等于 System.Double.NaN、System.Double.NegativeInfinity
        //     或 System.Double.PositiveInfinity，则返回该值。 请注意，此方法返回 System.Double，而不是整数类型。
        [SecuritySafeCritical]
        public static double Ceiling(double a);
        //
        // 摘要:
        //     返回指定角度的余弦值。
        //
        // 参数:
        //   d:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     d 的余弦值。 如果 d 等于 System.Double.NaN、System.Double.NegativeInfinity 或 System.Double.PositiveInfinity，此方法将返回
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Cos(double d);
        //
        // 摘要:
        //     返回指定角度的双曲余弦值。
        //
        // 参数:
        //   value:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     value 的双曲余弦值。 如果 value 等于 System.Double.NegativeInfinity 或 System.Double.PositiveInfinity，则返回
        //     System.Double.PositiveInfinity。 如果 value 等于 System.Double.NaN，则返回 System.Double.NaN。
        [SecuritySafeCritical]
        public static double Cosh(double value);
        //
        // 摘要:
        //     计算两个 32 位有符号整数的商，并通过输出参数返回余数。
        //
        // 参数:
        //   a:
        //     被除数。
        //
        //   b:
        //     除数。
        //
        //   result:
        //     余数。
        //
        // 返回结果:
        //     指定数字的商。
        //
        // 异常:
        //   System.DivideByZeroException:
        //     b 是零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int DivRem(int a, int b, out int result);
        //
        // 摘要:
        //     计算两个 64 位有符号整数的商，并通过输出参数返回余数。
        //
        // 参数:
        //   a:
        //     被除数。
        //
        //   b:
        //     除数。
        //
        //   result:
        //     余数。
        //
        // 返回结果:
        //     指定数字的商。
        //
        // 异常:
        //   System.DivideByZeroException:
        //     b 是零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long DivRem(long a, long b, out long result);
        //
        // 摘要:
        //     返回 e 的指定次幂。
        //
        // 参数:
        //   d:
        //     指定幂的数字。
        //
        // 返回结果:
        //     数字 e 的 d 次幂。 如果 d 等于 System.Double.NaN 或 System.Double.PositiveInfinity，则返回该值。
        //     如果 d 等于 System.Double.NegativeInfinity，则返回 0。
        [SecuritySafeCritical]
        public static double Exp(double d);
        //
        // 摘要:
        //     返回小于或等于指定小数的最大整数。
        //
        // 参数:
        //   d:
        //     一个小数。
        //
        // 返回结果:
        //     小于或等于 d 的最大整数。
        public static decimal Floor(decimal d);
        //
        // 摘要:
        //     返回小于或等于指定双精度浮点数的最大整数。
        //
        // 参数:
        //   d:
        //     一个双精度浮点数。
        //
        // 返回结果:
        //     小于或等于 d 的最大整数。 如果 d 等于 System.Double.NaN、System.Double.NegativeInfinity 或
        //     System.Double.PositiveInfinity，则返回该值。
        [SecuritySafeCritical]
        public static double Floor(double d);
        //
        // 摘要:
        //     返回一指定数字被另一指定数字相除的余数。
        //
        // 参数:
        //   x:
        //     被除数。
        //
        //   y:
        //     除数。
        //
        // 返回结果:
        //     该数等于 x - ( y Q)，其中 Q 是 x / y 的商的最接近整数（如果 x / y 在两个整数中间，则返回偶数）。 如果 x - ( y
        //     Q) 为零，则在 x 为正时返回值 +0，而在 x 为负时返回 -0。 如果 y 等于 0，则返回 System.Double.NaN。
        public static double IEEERemainder(double x, double y);
        //
        // 摘要:
        //     返回指定数字的自然对数（底为 e）。
        //
        // 参数:
        //   d:
        //     要查找其对数的数字。
        //
        // 返回结果:
        //     下表中的值之一。 d 参数 返回值 正 d 的自然对数，即 ln d 或 log ed 零 System.Double.NegativeInfinity负数
        //     System.Double.NaN等于 System.Double.NaNSystem.Double.NaN等于 System.Double.PositiveInfinitySystem.Double.PositiveInfinity
        [SecuritySafeCritical]
        public static double Log(double d);
        //
        // 摘要:
        //     返回指定数字在使用指定底时的对数。
        //
        // 参数:
        //   a:
        //     要查找其对数的数字。
        //
        //   newBase:
        //     对数的底。
        //
        // 返回结果:
        //     下表中的值之一。 （+Infinity 表示 System.Double.PositiveInfinity，-Infinity 表示 System.Double.NegativeInfinity，NaN
        //     表示 System.Double.NaN。） anewBase返回值 a> 0 (0 <newBase< 1) 或 (newBase> 1) lognewBase(a)
        //     a< 0 （任意值） NaN （任意值） newBase< 0 NaN a != 1 newBase = 0 NaN a != 1 newBase
        //     = +Infinity NaN a = NaN （任意值） NaN （任意值） newBase = NaN NaN （任意值） newBase =
        //     1 NaN a = 0 0 <newBase< 1 +Infinity a = 0 newBase> 1 -Infinity a = +Infinity
        //     0 <newBase< 1 -Infinity a = +Infinity newBase> 1 +Infinity a = 1 newBase
        //     = 0 0 a = 1 newBase = +Infinity 0
        public static double Log(double a, double newBase);
        //
        // 摘要:
        //     返回指定数字以 10 为底的对数。
        //
        // 参数:
        //   d:
        //     要查找其对数的数字。
        //
        // 返回结果:
        //     下表中的值之一。 d 参数 返回值 正 d 的以 10 为底的对数，即 log 10d。 零 System.Double.NegativeInfinity负数
        //     System.Double.NaN等于 System.Double.NaNSystem.Double.NaN等于 System.Double.PositiveInfinitySystem.Double.PositiveInfinity
        [SecuritySafeCritical]
        public static double Log10(double d);
        //
        // 摘要:
        //     返回两个 8 位无符号整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 8 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 8 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static byte Max(byte val1, byte val2);
        //
        // 摘要:
        //     返回两个十进制数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个十进制数字中的第一个。
        //
        //   val2:
        //     要比较的两个十进制数字中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static decimal Max(decimal val1, decimal val2);
        //
        // 摘要:
        //     返回两个双精度浮点数字中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个双精度浮点数中的第一个。
        //
        //   val2:
        //     要比较的两个双精度浮点数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。 如果 val1 或 val2 或者 val1 和 val2 都等于 System.Double.NaN，则返回
        //     System.Double.NaN。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static double Max(double val1, double val2);
        //
        // 摘要:
        //     返回两个单精度浮点数字中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个单精度浮点数中的第一个。
        //
        //   val2:
        //     要比较的两个单精度浮点数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。 如果 val1、val2 或者 val1 和 val2 都等于 System.Single.NaN，则返回
        //     System.Single.NaN。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static float Max(float val1, float val2);
        //
        // 摘要:
        //     返回两个 32 位有符号的整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 32 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 32 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Max(int val1, int val2);
        //
        // 摘要:
        //     返回两个 64 位有符号的整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 64 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 64 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long Max(long val1, long val2);
        //
        // 摘要:
        //     返回两个 8 位有符号的整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 8 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 8 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static sbyte Max(sbyte val1, sbyte val2);
        //
        // 摘要:
        //     返回两个 16 位有符号的整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 16 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 16 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static short Max(short val1, short val2);
        //
        // 摘要:
        //     返回两个 32 位无符号整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 32 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 32 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static uint Max(uint val1, uint val2);
        //
        // 摘要:
        //     返回两个 64 位无符号整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 64 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 64 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static ulong Max(ulong val1, ulong val2);
        //
        // 摘要:
        //     返回两个 16 位无符号整数中较大的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 16 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 16 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较大的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static ushort Max(ushort val1, ushort val2);
        //
        // 摘要:
        //     返回两个 8 位无符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 8 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 8 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static byte Min(byte val1, byte val2);
        //
        // 摘要:
        //     返回两个十进制数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个十进制数字中的第一个。
        //
        //   val2:
        //     要比较的两个十进制数字中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static decimal Min(decimal val1, decimal val2);
        //
        // 摘要:
        //     返回两个双精度浮点数字中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个双精度浮点数中的第一个。
        //
        //   val2:
        //     要比较的两个双精度浮点数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。 如果 val1 或 val2 或者 val1 和 val2 都等于 System.Double.NaN，则返回
        //     System.Double.NaN。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static double Min(double val1, double val2);
        //
        // 摘要:
        //     返回两个单精度浮点数字中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个单精度浮点数中的第一个。
        //
        //   val2:
        //     要比较的两个单精度浮点数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。 如果 val1 或 val2 或者 val1 和 val2 都等于 System.Single.NaN，则返回
        //     System.Single.NaN。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static float Min(float val1, float val2);
        //
        // 摘要:
        //     返回两个 32 位有符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 32 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 32 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Min(int val1, int val2);
        //
        // 摘要:
        //     返回两个 64 位有符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 64 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 64 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long Min(long val1, long val2);
        //
        // 摘要:
        //     返回两个 8 位有符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 8 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 8 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static sbyte Min(sbyte val1, sbyte val2);
        //
        // 摘要:
        //     返回两个 16 位有符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 16 位有符号的整数中的第一个。
        //
        //   val2:
        //     要比较的两个 16 位有符号的整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static short Min(short val1, short val2);
        //
        // 摘要:
        //     返回两个 32 位无符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 32 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 32 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static uint Min(uint val1, uint val2);
        //
        // 摘要:
        //     返回两个 64 位无符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 64 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 64 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static ulong Min(ulong val1, ulong val2);
        //
        // 摘要:
        //     返回两个 16 位无符号整数中较小的一个。
        //
        // 参数:
        //   val1:
        //     要比较的两个 16 位无符号整数中的第一个。
        //
        //   val2:
        //     要比较的两个 16 位无符号整数中的第二个。
        //
        // 返回结果:
        //     val1 或 val2 参数中较小的一个。
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static ushort Min(ushort val1, ushort val2);
        //
        // 摘要:
        //     返回指定数字的指定次幂。
        //
        // 参数:
        //   x:
        //     要乘幂的双精度浮点数。
        //
        //   y:
        //     指定幂的双精度浮点数。
        //
        // 返回结果:
        //     数字 x 的 y 次幂。
        [SecuritySafeCritical]
        public static double Pow(double x, double y);
        //
        // 摘要:
        //     将小数值舍入到最接近的整数值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        // 返回结果:
        //     最接近参数 d 的整数。 如果 d 的小数部分正好处于两个整数中间，其中一个整数为偶数，另一个整数为奇数，则返回偶数。 请注意，此方法返回 System.Decimal，而不是整数类型。
        //
        // 异常:
        //   System.OverflowException:
        //     结果超出了 System.Decimal 的范围。
        public static decimal Round(decimal d);
        //
        // 摘要:
        //     将双精度浮点值舍入为最接近的整数值。
        //
        // 参数:
        //   a:
        //     要舍入的双精度浮点数。
        //
        // 返回结果:
        //     最接近 a 的整数。 如果 a 的小数部分正好处于两个整数中间，其中一个整数为偶数，另一个整数为奇数，则返回偶数。 请注意，此方法返回 System.Double，而不是整数类型。
        [SecuritySafeCritical]
        public static double Round(double a);
        //
        // 摘要:
        //     将小数值按指定的小数位数舍入。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   decimals:
        //     返回值中的小数位数。
        //
        // 返回结果:
        //     最接近 d 的 decimals 位小数的数字。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     decimals 小于 0 或大于 28。
        //
        //   System.OverflowException:
        //     结果超出了 System.Decimal 的范围。
        public static decimal Round(decimal d, int decimals);
        //
        // 摘要:
        //     将小数值舍入到最接近的整数。 一个参数，指定当一个值正好处于另两个数中间时如何舍入这个值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   mode:
        //     d 在两个数字之间时如何舍入的规范。
        //
        // 返回结果:
        //     最接近 d 的整数。 如果 d 是两个数字的中值，这两个数字一个为偶数，另一个为奇数，则 mode 确定返回两个数字中的哪一个。
        //
        // 异常:
        //   System.ArgumentException:
        //     mode 不是有效的 System.MidpointRounding 值。
        //
        //   System.OverflowException:
        //     结果超出了 System.Decimal 的范围。
        public static decimal Round(decimal d, MidpointRounding mode);
        //
        // 摘要:
        //     将双精度浮点值按指定的小数位数舍入。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   digits:
        //     返回值中的小数数字。
        //
        // 返回结果:
        //     最接近 value 的 digits 位小数的数字。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     digits 小于 0 或大于 15。
        public static double Round(double value, int digits);
        //
        // 摘要:
        //     将双精度浮点值舍入为最接近的整数。 一个参数，指定当一个值正好处于另两个数中间时如何舍入这个值。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   mode:
        //     value 在两个数字之间时如何舍入的规范。
        //
        // 返回结果:
        //     最接近 value 的整数。 如果 value 是两个整数的中值，这两个整数一个为偶数，另一个为奇数，则 mode 确定返回两个整数中的哪一个。
        //
        // 异常:
        //   System.ArgumentException:
        //     mode 不是有效的 System.MidpointRounding 值。
        public static double Round(double value, MidpointRounding mode);
        //
        // 摘要:
        //     将小数值按指定的小数位数舍入。 一个参数，指定当一个值正好处于另两个数中间时如何舍入这个值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   decimals:
        //     返回值中的小数位数。
        //
        //   mode:
        //     d 在两个数字之间时如何舍入的规范。
        //
        // 返回结果:
        //     最接近 d 的 decimals 位小数的数字。 如果 d 比 decimals少部分数字，d 原样返回。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     decimals 小于 0 或大于 28。
        //
        //   System.ArgumentException:
        //     mode 不是有效的 System.MidpointRounding 值。
        //
        //   System.OverflowException:
        //     结果超出了 System.Decimal 的范围。
        public static decimal Round(decimal d, int decimals, MidpointRounding mode);
        //
        // 摘要:
        //     将双精度浮点值按指定的小数位数舍入。 一个参数，指定当一个值正好处于另两个数中间时如何舍入这个值。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   digits:
        //     返回值中的小数数字。
        //
        //   mode:
        //     value 在两个数字之间时如何舍入的规范。
        //
        // 返回结果:
        //     其小数数字等于 digits 的 value 的最接近的数字。 如果 value 比 digits 的小数位少， value 原样返回。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     digits 小于 0 或大于 15。
        //
        //   System.ArgumentException:
        //     mode 不是有效的 System.MidpointRounding 值。
        public static double Round(double value, int digits, MidpointRounding mode);
        //
        // 摘要:
        //     返回表示数字符号的值。
        //
        // 参数:
        //   value:
        //     已签名的十进制数。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(decimal value);
        //
        // 摘要:
        //     返回表示双精度浮点数字的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        //
        // 异常:
        //   System.ArithmeticException:
        //     value 等于 System.Double.NaN。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(double value);
        //
        // 摘要:
        //     返回表示单精度浮点数字的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        //
        // 异常:
        //   System.ArithmeticException:
        //     value 等于 System.Single.NaN。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(float value);
        //
        // 摘要:
        //     返回表示 32 位有符号整数的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(int value);
        //
        // 摘要:
        //     返回表示 64 位有符号整数的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(long value);
        //
        // 摘要:
        //     返回表示 8 位有符号整数的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        [CLSCompliant(false)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(sbyte value);
        //
        // 摘要:
        //     返回表示 16 位有符号整数的符号的值。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(short value);
        //
        // 摘要:
        //     返回指定角度的正弦值。
        //
        // 参数:
        //   a:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     a 的正弦值。 如果 a 等于 System.Double.NaN、System.Double.NegativeInfinity 或 System.Double.PositiveInfinity，此方法将返回
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Sin(double a);
        //
        // 摘要:
        //     返回指定角度的双曲正弦值。
        //
        // 参数:
        //   value:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     value 的双曲正弦值。 如果 value 等于 System.Double.NegativeInfinity、System.Double.PositiveInfinity
        //     或 System.Double.NaN，则此方法返回等于 value 的 System.Double。
        [SecuritySafeCritical]
        public static double Sinh(double value);
        //
        // 摘要:
        //     返回指定数字的平方根。
        //
        // 参数:
        //   d:
        //     将查找其平方根的数字。
        //
        // 返回结果:
        //     下表中的值之一。 d 参数 返回值 零或正数 d 的正平方根。 负数 System.Double.NaN等于 System.Double.NaNSystem.Double.NaN等于
        //     System.Double.PositiveInfinitySystem.Double.PositiveInfinity
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public static double Sqrt(double d);
        //
        // 摘要:
        //     返回指定角度的正切值。
        //
        // 参数:
        //   a:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     a 的正切值。 如果 a 等于 System.Double.NaN、System.Double.NegativeInfinity 或 System.Double.PositiveInfinity，此方法将返回
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Tan(double a);
        //
        // 摘要:
        //     返回指定角度的双曲正切值。
        //
        // 参数:
        //   value:
        //     以弧度计量的角度。
        //
        // 返回结果:
        //     value 的双曲正切值。 如果 value 等于 System.Double.NegativeInfinity，则此方法返回 -1。 如果值等于
        //     System.Double.PositiveInfinity，则此方法返回 1。 如果 value 等于 System.Double.NaN，则此方法返回
        //     System.Double.NaN。
        [SecuritySafeCritical]
        public static double Tanh(double value);
        //
        // 摘要:
        //     计算指定小数的整数部分。
        //
        // 参数:
        //   d:
        //     要截断的数字。
        //
        // 返回结果:
        //     d 的整数部分（即舍弃小数位后剩余的数）。
        public static decimal Truncate(decimal d);
        //
        // 摘要:
        //     计算指定双精度浮点数的整数部分。
        //
        // 参数:
        //   d:
        //     要截断的数字。
        //
        // 返回结果:
        //     d 的整数部分（即舍弃小数位后剩余的数或下表所列出的值之一）。 d返回值 System.Double.NaNSystem.Double.NaNSystem.Double.NegativeInfinitySystem.Double.NegativeInfinitySystem.Double.PositiveInfinitySystem.Double.PositiveInfinity
        public static double Truncate(double d);
    }
}