.NETFramework：Math

最新推荐文章于 2024-03-01 00:00:00 发布
转载最新推荐文章于 2024-03-01 00:00:00 发布 · 310 阅读
0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/storebook/p/9045655.html
文章标签：
#runtime
本文详细介绍了C#中Math类的使用方法，包括各种数学运算如取绝对值、求最大最小值、四舍五入等操作，以及三角函数、指数和对数函数等高级数学功能。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
ylbtech-.NETFramework：Math
1. 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089返回顶部
1、
#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// 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
{
    //
    // 摘要:
    //     为三角函数、对数函数和其他通用数学函数提供常数和静态方法。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。
    public static class Math
    {
        //
        // 摘要:
        //     表示圆的周长与其直径的比值，由常数 π 指定。
        public const double PI = 3.1415926535897931;
        //
        // 摘要:
        //     表示自然对数的底，它由常数 e 指定。
        public const double E = 2.7182818284590451;

        //
        // 摘要:
        //     返回 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。
        //
        // 异常:
        //   T:System.OverflowException:
        //     value 等于 System.Int32.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Abs(int value);
        //
        // 摘要:
        //     返回 16 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.Int16.MinValue 但小于或等于 System.Int16.MaxValue 的数字。
        //
        // 返回结果:
        //     16 位有符号的整数 x，满足 0 ≤ x ≤System.Int16.MaxValue。
        //
        // 异常:
        //   T:System.OverflowException:
        //     value 等于 System.Int16.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static short Abs(short value);
        //
        // 摘要:
        //     返回 8 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.SByte.MinValue 但小于或等于 System.SByte.MaxValue 的数字。
        //
        // 返回结果:
        //     8 位有符号的整数 x，满足 0 ≤ x ≤System.SByte.MaxValue。
        //
        // 异常:
        //   T:System.OverflowException:
        //     value 等于 System.SByte.MinValue。
        [CLSCompliant(false)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static sbyte Abs(sbyte value);
        //
        // 摘要:
        //     返回 64 位有符号整数的绝对值。
        //
        // 参数:
        //   value:
        //     一个大于 System.Int64.MinValue 但小于或等于 System.Int64.MaxValue 的数字。
        //
        // 返回结果:
        //     64 位有符号的整数 x，满足 0 ≤ x ≤System.Int64.MaxValue。
        //
        // 异常:
        //   T:System.OverflowException:
        //     value 等于 System.Int64.MinValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static long Abs(long 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。如果
        //     y 为 0 并且 x 为 0，则 θ = 0。如果 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:
        //     余数。
        //
        // 返回结果:
        //     指定数字的商。
        //
        // 异常:
        //   T: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:
        //     余数。
        //
        // 返回结果:
        //     指定数字的商。
        //
        // 异常:
        //   T: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 的最大整数。 请注意，该方法将返回 System.Math 类型的整数值。
        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);
        //
        // 摘要:
        //     返回指定数字在使用指定底时的对数。
        //
        // 参数:
        //   a:
        //     要查找其对数的数字。
        //
        //   newBase:
        //     对数的底。
        //
        // 返回结果:
        //     下表中的值之一。 （+Infinity 表示 System.Double.PositiveInfinity，-Infinity 表示 System.Double.NegativeInfinity，NaN
        //     表示 System.Double.NaN。）anewBase返回值a> 0(0 <newBase< 1) -or-(newBase> 1)日志newBase(a)a<
        //     0（任意值）NaN（任意值）newBase< 0NaNa != 1newBase = 0NaNa != 1newBase = + InfinityNaNa
        //     = NaN（任意值）NaN（任意值）newBase = NaNNaN（任意值）newBase = 1NaNa = 00 <newBase< 1 +Infinitya
        //     = 0newBase> 1-Infinitya = + Infinity0 <newBase< 1-Infinitya = + InfinitynewBase>
        //     1+Infinitya = 1newBase = 00a = 1newBase = + Infinity0
        public static double Log(double a, double newBase);
        //
        // 摘要:
        //     返回指定数字的自然对数（底为 e）。
        //
        // 参数:
        //   d:
        //     要查找其对数的数字。
        //
        // 返回结果:
        //     下表中的值之一。d 参数返回值 正 自然对数 d; 即 ln d, ，或日志 ed零 System.Double.NegativeInfinity负数 System.Double.NaN等于
        //     System.Double.NaNSystem.Double.NaN等于 System.Double.PositiveInfinitySystem.Double.PositiveInfinity
        [SecuritySafeCritical]
        public static double Log(double d);
        //
        // 摘要:
        //     返回指定数字以 10 为底的对数。
        //
        // 参数:
        //   d:
        //     要查找其对数的数字。
        //
        // 返回结果:
        //     下表中的值之一。d 参数 返回值 正 基 10 日志 d; 也就是说，记录 10d。零 System.Double.NegativeInfinity负数
        //     System.Double.NaN等于 System.Double.NaNSystem.Double.NaN等于 System.Double.PositiveInfinitySystem.Double.PositiveInfinity
        [SecuritySafeCritical]
        public static double Log10(double d);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个单精度浮点数字中较大的一个。
        //
        // 参数:
        //   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);
        //
        // 摘要:
        //     返回两个双精度浮点数字中较大的一个。
        //
        // 参数:
        //   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 参数中较大的一个。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static decimal Max(decimal val1, decimal 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个十进制数中较小的一个。
        //
        // 参数:
        //   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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回两个 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);
        //
        // 摘要:
        //     返回指定数字的指定次幂。
        //
        // 参数:
        //   x:
        //     要乘幂的双精度浮点数。
        //
        //   y:
        //     指定幂的双精度浮点数。
        //
        // 返回结果:
        //     数字 x 的 y 次幂。
        [SecuritySafeCritical]
        public static double Pow(double x, double y);
        //
        // 摘要:
        //     将小数值按指定的小数位数舍入。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   decimals:
        //     返回值中的小数位数。
        //
        // 返回结果:
        //     最接近 d 的 decimals 位小数的数字。
        //
        // 异常:
        //   T:System.ArgumentOutOfRangeException:
        //     decimals 小于 0 或大于 28。
        //
        //   T:System.OverflowException:
        //     结果不在范围之内 System.Decimal。
        public static decimal Round(decimal d, int decimals);
        //
        // 摘要:
        //     将小数值舍入到最接近的整数。 一个参数，指定当一个值正好处于两个数中间时如何舍入这个值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   mode:
        //     在两个数字之间时如何舍入 d 的规范。
        //
        // 返回结果:
        //     最接近 d 的整数。 如果 d 是两个数字的中值，这两个数字一个为偶数，另一个为奇数，则 mode 确定返回两个数字中的哪一个。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     mode 不是有效值的 System.MidpointRounding。
        //
        //   T:System.OverflowException:
        //     结果不在范围之内 System.Decimal。
        public static decimal Round(decimal d, MidpointRounding mode);
        //
        // 摘要:
        //     将小数值舍入到最接近的整数值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        // 返回结果:
        //     最接近参数 d 的整数。 如果 d 的小数部分正好处于两个整数中间，其中一个整数为偶数，另一个整数为奇数，则返回偶数。 请注意，此方法返回 System.Decimal，而不是整数类型。
        //
        // 异常:
        //   T:System.OverflowException:
        //     结果不在范围之内 System.Decimal。
        public static decimal Round(decimal d);
        //
        // 摘要:
        //     将双精度浮点值按指定的小数位数舍入。 一个参数，指定当一个值正好处于两个数中间时如何舍入这个值。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   digits:
        //     返回值中的小数数字。
        //
        //   mode:
        //     在两个数字之间时如何舍入 value 的规范。
        //
        // 返回结果:
        //     最接近 value 的 digits 位小数的数字。 如果 value 比 digits 少部分数字，value 原样返回。
        //
        // 异常:
        //   T:System.ArgumentOutOfRangeException:
        //     digits 为小于 0 或大于 15。
        //
        //   T:System.ArgumentException:
        //     mode 不是有效值的 System.MidpointRounding。
        public static double Round(double value, int digits, MidpointRounding mode);
        //
        // 摘要:
        //     将双精度浮点值舍入为最接近的整数。 一个参数，指定当一个值正好处于两个数中间时如何舍入这个值。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   mode:
        //     在两个数字之间时如何舍入 value 的规范。
        //
        // 返回结果:
        //     最接近 value 的整数。 如果 value 是两个整数的中值，这两个整数一个为偶数，另一个为奇数，则 mode 确定返回两个整数中的哪一个。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     mode 不是有效值的 System.MidpointRounding。
        public static double Round(double value, MidpointRounding mode);
        //
        // 摘要:
        //     将双精度浮点值按指定的小数位数舍入。
        //
        // 参数:
        //   value:
        //     要舍入的双精度浮点数。
        //
        //   digits:
        //     返回值中的小数数字。
        //
        // 返回结果:
        //     最接近 value 的 digits 位小数的数字。
        //
        // 异常:
        //   T:System.ArgumentOutOfRangeException:
        //     digits 为小于 0 或大于 15。
        public static double Round(double value, int digits);
        //
        // 摘要:
        //     将双精度浮点值舍入为最接近的整数值。
        //
        // 参数:
        //   a:
        //     要舍入的双精度浮点数。
        //
        // 返回结果:
        //     最接近 a 的整数。 如果 a 的小数部分正好处于两个整数中间，其中一个整数为偶数，另一个整数为奇数，则返回偶数。 请注意，此方法返回 System.Double，而不是整数类型。
        [SecuritySafeCritical]
        public static double Round(double a);
        //
        // 摘要:
        //     将小数值按指定的小数位数舍入。 一个参数，指定当一个值正好处于两个数中间时如何舍入这个值。
        //
        // 参数:
        //   d:
        //     要舍入的小数。
        //
        //   decimals:
        //     返回值中的小数位数。
        //
        //   mode:
        //     在两个数字之间时如何舍入 d 的规范。
        //
        // 返回结果:
        //     最接近 d 的 decimals 位小数的数字。 如果 d 比 decimals 少部分数字，d 原样返回。
        //
        // 异常:
        //   T:System.ArgumentOutOfRangeException:
        //     decimals 小于 0 或大于 28。
        //
        //   T:System.ArgumentException:
        //     mode 不是有效值的 System.MidpointRounding。
        //
        //   T:System.OverflowException:
        //     结果不在范围之内 System.Decimal。
        public static decimal Round(decimal d, int decimals, MidpointRounding mode);
        //
        // 摘要:
        //     返回一个整数，该整数指示 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);
        //
        // 摘要:
        //     返回表示十进制数符号的整数。
        //
        // 参数:
        //   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 大于零。
        //
        // 异常:
        //   T: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 大于零。
        //
        // 异常:
        //   T:System.ArithmeticException:
        //     value 等于 System.Single.NaN。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(float 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);
        //
        // 摘要:
        //     返回表示 16 位带符号整数的整数。
        //
        // 参数:
        //   value:
        //     有符号的数字。
        //
        // 返回结果:
        //     一个指示 value 的符号的数字，如下表所示。返回值 含义 -1 value 小于零。0 value 等于零。1 value 大于零。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static int Sign(short 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);
        //
        // 摘要:
        //     返回指定角度的正弦值。
        //
        // 参数:
        //   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 的整数部分（即舍弃小数位后剩余的数或下表所列出的值之一）。d返回值System.Double.NaNSystem.Double.NaNSystem.Double.NegativeInfinitySystem.Double.NegativeInfinitySystem.Double.PositiveInfinitySystem.Double.PositiveInfinity
        public static double Truncate(double d);
        //
        // 摘要:
        //     计算一个数字的整数部分。
        //
        // 参数:
        //   d:
        //     要截断的数字。
        //
        // 返回结果:
        //     d 的整数部分（即舍弃小数位后剩余的数）。
        public static decimal Truncate(decimal d);
    }
}