zoukankan      html  css  js  c++  java
  • System.Math.cs

    ylbtech-System.Math.cs
    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 AssembliesMicrosoftFramework.NETFrameworkv4.5mscorlib.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);
        }
    }
    2、
    2.返回顶部
     
    3.返回顶部
     
    4.返回顶部
     
    5.返回顶部
     
     
    6.返回顶部
     
    warn 作者:ylbtech
    出处:http://ylbtech.cnblogs.com/
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
  • 相关阅读:
    CodeForces 219D Choosing Capital for Treeland (树形DP)
    POJ 3162 Walking Race (树的直径,单调队列)
    POJ 2152 Fire (树形DP,经典)
    POJ 1741 Tree (树的分治,树的重心)
    POJ 1655 Balancing Act (树的重心,常规)
    HDU 2196 Computer (树形DP)
    HDU 1520 Anniversary party (树形DP,入门)
    寒门子弟
    JQuery选择器(转)
    (四)Web应用开发---系统架构图
  • 原文地址:https://www.cnblogs.com/storebook/p/9045655.html
Copyright © 2011-2022 走看看