C# 中简单的科学计算

#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETFrameworkv4.6.1mscorlib.dll
#endregion

using System.Runtime.ConstrainedExecution;
using System.Runtime.Versioning;
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。
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。
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。
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)]
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。
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) 是笛卡尔平面中的点。 请看下面： For (x, y)
// in quadrant 1, 0 <>θ <>π/2. For (x, y) in quadrant 2, π/2 <>θ≤π. For (x, y) in
// quadrant 3, -π <>θ <>π/2. For (x, y) in quadrant 4, -π/2 <>θ< 0.></ 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:
// 要相乘的第二个数。
//
// 返回结果:
// 包含指定数字乘积的数。
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 为零。
public static int DivRem(int a, int b, out int result);
//
// 摘要:
// 计算两个 64 位有符号整数的商，并通过输出参数返回余数。
//
// 参数:
// a:
// 被除数。
//
// b:
// 除数。
//
// result:
// 余数。
//
// 返回结果:
// 指定数字的商。
//
// 异常:
// T:System.DivideByZeroException:
// b 为零。
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。） a newBase 返回值 a> 0 (0 <newBase< 1) -or-(newBase> 1) 日志newBase(a)
// a< 0 （任意值） NaN （任意值） newBase< 0 NaN a != 1 newBase = 0 NaN a != 1 newBase= 正无穷
// NaN a = NaN （任意值） NaN （任意值） newBase = NaN NaN （任意值） newBase = 1 NaN a = 0 0 <newBase<
// 1 +Infinity a = 0 newBase> 1 -Infinity a= 正无穷 0 <newBase< 1 -Infinity a= 正无穷
// newBase> 1 +Infinity a = 1 newBase = 0 0 a = 1 newBase= 正无穷 0
public static double Log(double a, double newBase);
//
// 摘要:
// 返回指定数字的自然对数（底为 e）。
//
// 参数:
// d:
// 要查找其对数的数字。
//
// 返回结果:
// 下表中的值之一。 d参数 返回值 正 自然对数d; 即，ln d，或日志ed 零 System.Double.NegativeInfinity 负数 System.Double.NaN
// 等于System.Double.NaN System.Double.NaN 等于System.Double.PositiveInfinity System.Double.PositiveInfinity
[SecuritySafeCritical]
public static double Log(double d);
//
// 摘要:
// 返回指定数字以 10 为底的对数。
//
// 参数:
// d:
// 要查找其对数的数字。
//
// 返回结果:
// 下表中的值之一。 d参数 返回值 正 基 10 日志d; 即，登录10d。 零 System.Double.NegativeInfinity 负数 System.Double.NaN
// 等于System.Double.NaN System.Double.NaN 等于System.Double.PositiveInfinity System.Double.PositiveInfinity
[SecuritySafeCritical]
public static double Log10(double d);
//
// 摘要:
// 返回两个 16 位有符号的整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 16 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 16 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static short Max(short val1, short val2);
//
// 摘要:
// 返回两个 16 位无符号整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 16 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 16 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ushort Max(ushort val1, ushort val2);
//
// 摘要:
// 返回两个 32 位有符号的整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 32 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 32 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int Max(int val1, int val2);
//
// 摘要:
// 返回两个 64 位有符号的整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 64 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 64 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static long Max(long val1, long val2);
//
// 摘要:
// 返回两个 64 位无符号整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 64 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 64 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
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)]
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)]
public static double Max(double val1, double val2);
//
// 摘要:
// 返回两个十进制数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个十进制数字中的第一个。
//
// val2:
// 要比较的两个十进制数字中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static decimal Max(decimal val1, decimal val2);
//
// 摘要:
// 返回两个 32 位无符号整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 32 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 32 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static uint Max(uint val1, uint val2);
//
// 摘要:
// 返回两个 8 位有符号的整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 8 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 8 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static sbyte Max(sbyte val1, sbyte val2);
//
// 摘要:
// 返回两个 8 位无符号整数中较大的一个。
//
// 参数:
// val1:
// 要比较的两个 8 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 8 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较大的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static byte Max(byte val1, byte val2);
//
// 摘要:
// 返回两个 32 位有符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 32 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 32 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int Min(int val1, int val2);
//
// 摘要:
// 返回两个十进制数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个十进制数字中的第一个。
//
// val2:
// 要比较的两个十进制数字中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
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)]
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)]
public static float Min(float val1, float val2);
//
// 摘要:
// 返回两个 64 位无符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 64 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 64 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ulong Min(ulong val1, ulong val2);
//
// 摘要:
// 返回两个 64 位有符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 64 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 64 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static long Min(long val1, long val2);
//
// 摘要:
// 返回两个 32 位无符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 32 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 32 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static uint Min(uint val1, uint val2);
//
// 摘要:
// 返回两个 16 位无符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 16 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 16 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ushort Min(ushort val1, ushort val2);
//
// 摘要:
// 返回两个 16 位有符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 16 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 16 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static short Min(short val1, short val2);
//
// 摘要:
// 返回两个 8 位有符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 8 位有符号整数中的第一个。
//
// val2:
// 要比较的两个 8 位有符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[CLSCompliant(false)]
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static sbyte Min(sbyte val1, sbyte val2);
//
// 摘要:
// 返回两个 8 位无符号整数中较小的一个。
//
// 参数:
// val1:
// 要比较的两个 8 位无符号整数中的第一个。
//
// val2:
// 要比较的两个 8 位无符号整数中的第二个。
//
// 返回结果:
// val1 或 val2 参数中较小的一个。
[NonVersionableAttribute]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
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)]
public static int Sign(sbyte value);
//
// 摘要:
// 返回表示十进制数符号的整数。
//
// 参数:
// value:
// 已签名的十进制数。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value等于零。 1 value大于零。
public static int Sign(decimal value);
//
// 摘要:
// 返回一个整数，该整数表示双精度浮点数字的符号。
//
// 参数:
// value:
// 有符号的数字。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value等于零。 1 value大于零。
//
// 异常:
// T:System.ArithmeticException:
// value 等于 System.Double.NaN。
public static int Sign(double value);
//
// 摘要:
// 返回一个整数，该整数表示单精度浮点数字的符号。
//
// 参数:
// value:
// 有符号的数字。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value等于零。 1 value大于零。
//
// 异常:
// T:System.ArithmeticException:
// value 等于 System.Single.NaN。
public static int Sign(float value);
//
// 摘要:
// 返回一个整数，该整数指示 64 位带符号整数的符号。
//
// 参数:
// value:
// 有符号的数字。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value 等于零。 1 value 大于零。
public static int Sign(long value);
//
// 摘要:
// 返回表示 16 位带符号整数的整数。
//
// 参数:
// value:
// 有符号的数字。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value等于零。 1 value大于零。
public static int Sign(short value);
//
// 摘要:
// 返回表示 32 位带符号整数的整数。
//
// 参数:
// value:
// 有符号的数字。
//
// 返回结果:
// 一个指示 value 的符号的数字，如下表所示。 返回值 含义 -1 value 小于零。 0 value等于零。 1 value大于零。
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.NaN System.Double.NaN
// 等于System.Double.PositiveInfinity System.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.NaN System.Double.NaN System.Double.NegativeInfinity
// System.Double.NegativeInfinity System.Double.PositiveInfinity System.Double.PositiveInfinity
public static double Truncate(double d);
//
// 摘要:
// 计算一个数字的整数部分。
//
// 参数:
// d:
// 要截断的数字。
//
// 返回结果:
// d 的整数部分（即舍弃小数位后剩余的数）。
public static decimal Truncate(decimal d);
}
}