niko
898 lines
43 KiB
C#
898 lines
43 KiB
C#
using System;
|
|
using System.Runtime.ConstrainedExecution;
|
|
using Cpp2IlInjected;
|
|
|
|
namespace System
|
|
{
|
|
/// <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary>
|
|
// Token: 0x0200011C RID: 284
|
|
[Token(Token = "0x200011C")]
|
|
public static class Math
|
|
{
|
|
/// <summary>Returns the angle whose cosine is the specified number.</summary>
|
|
/// <param name="d">A number representing a cosine, where <paramref name="d" /> must be greater than or equal to -1, but less than or equal to 1.</param>
|
|
/// <returns>An angle, θ, measured in radians, such that 0 ≤θ≤π
|
|
/// -or-
|
|
/// <see cref="F:System.Double.NaN" /> if <paramref name="d" /> < -1 or <paramref name="d" /> > 1 or <paramref name="d" /> equals <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A4D RID: 2637 RVA: 0x000092A0 File Offset: 0x000074A0
|
|
[Token(Token = "0x6000A4D")]
|
|
[Address(RVA = "0x2D69930", Offset = "0x2D68930", VA = "0x182D69930")]
|
|
public static double Acos(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the angle whose sine is the specified number.</summary>
|
|
/// <param name="d">A number representing a sine, where <paramref name="d" /> must be greater than or equal to -1, but less than or equal to 1.</param>
|
|
/// <returns>An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2
|
|
/// -or-
|
|
/// <see cref="F:System.Double.NaN" /> if <paramref name="d" /> < -1 or <paramref name="d" /> > 1 or <paramref name="d" /> equals <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A4E RID: 2638 RVA: 0x000092B8 File Offset: 0x000074B8
|
|
[Token(Token = "0x6000A4E")]
|
|
[Address(RVA = "0x2D69940", Offset = "0x2D68940", VA = "0x182D69940")]
|
|
public static double Asin(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the angle whose tangent is the specified number.</summary>
|
|
/// <param name="d">A number representing a tangent.</param>
|
|
/// <returns>An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2.
|
|
/// -or-
|
|
/// <see cref="F:System.Double.NaN" /> if <paramref name="d" /> equals <see cref="F:System.Double.NaN" />, -π/2 rounded to double precision (-1.5707963267949) if <paramref name="d" /> equals <see cref="F:System.Double.NegativeInfinity" />, or π/2 rounded to double precision (1.5707963267949) if <paramref name="d" /> equals <see cref="F:System.Double.PositiveInfinity" />.</returns>
|
|
// Token: 0x06000A4F RID: 2639 RVA: 0x000092D0 File Offset: 0x000074D0
|
|
[Token(Token = "0x6000A4F")]
|
|
[Address(RVA = "0x2D69960", Offset = "0x2D68960", VA = "0x182D69960")]
|
|
public static double Atan(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the angle whose tangent is the quotient of two specified numbers.</summary>
|
|
/// <param name="y">The y coordinate of a point.</param>
|
|
/// <param name="x">The x coordinate of a point.</param>
|
|
/// <returns>An angle, θ, measured in radians, such that -π≤θ≤π, and tan(θ) = <paramref name="y" /> / <paramref name="x" />, where (<paramref name="x" />, <paramref name="y" />) is a point in the Cartesian plane. Observe the following:
|
|
///
|
|
/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 1, 0 < θ < π/2.
|
|
///
|
|
/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 2, π/2 < θ≤π.
|
|
///
|
|
/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 3, -π < θ < -π/2.
|
|
///
|
|
/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 4, -π/2 < θ < 0.
|
|
///
|
|
///
|
|
/// For points on the boundaries of the quadrants, the return value is the following:
|
|
///
|
|
/// If y is 0 and x is not negative, θ = 0.
|
|
///
|
|
/// If y is 0 and x is negative, θ = π.
|
|
///
|
|
/// If y is positive and x is 0, θ = π/2.
|
|
///
|
|
/// If y is negative and x is 0, θ = -π/2.
|
|
///
|
|
/// If y is 0 and x is 0, θ = 0.
|
|
///
|
|
///
|
|
/// If <paramref name="x" /> or <paramref name="y" /> is <see cref="F:System.Double.NaN" />, or if <paramref name="x" /> and <paramref name="y" /> are either <see cref="F:System.Double.PositiveInfinity" /> or <see cref="F:System.Double.NegativeInfinity" />, the method returns <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A50 RID: 2640 RVA: 0x000092E8 File Offset: 0x000074E8
|
|
[Token(Token = "0x6000A50")]
|
|
[Address(RVA = "0x2D69950", Offset = "0x2D68950", VA = "0x182D69950")]
|
|
public static double Atan2(double y, double x)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the smallest integral value that is greater than or equal to the specified double-precision floating-point number.</summary>
|
|
/// <param name="a">A double-precision floating-point number.</param>
|
|
/// <returns>The smallest integral value that is greater than or equal to <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, that value is returned. Note that this method returns a <see cref="T:System.Double" /> instead of an integral type.</returns>
|
|
// Token: 0x06000A51 RID: 2641 RVA: 0x00009300 File Offset: 0x00007500
|
|
[Token(Token = "0x6000A51")]
|
|
[Address(RVA = "0x2D69970", Offset = "0x2D68970", VA = "0x182D69970")]
|
|
public static double Ceiling(double a)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the cosine of the specified angle.</summary>
|
|
/// <param name="d">An angle, measured in radians.</param>
|
|
/// <returns>The cosine of <paramref name="d" />. If <paramref name="d" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A52 RID: 2642 RVA: 0x00009318 File Offset: 0x00007518
|
|
[Token(Token = "0x6000A52")]
|
|
[Address(RVA = "0x2D69980", Offset = "0x2D68980", VA = "0x182D69980")]
|
|
public static double Cos(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the largest integral value less than or equal to the specified double-precision floating-point number.</summary>
|
|
/// <param name="d">A double-precision floating-point number.</param>
|
|
/// <returns>The largest integral value less than or equal to <paramref name="d" />. If <paramref name="d" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, that value is returned.</returns>
|
|
// Token: 0x06000A53 RID: 2643 RVA: 0x00009330 File Offset: 0x00007530
|
|
[Token(Token = "0x6000A53")]
|
|
[Address(RVA = "0x2D699A0", Offset = "0x2D689A0", VA = "0x182D699A0")]
|
|
public static double Floor(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
// Token: 0x06000A54 RID: 2644 RVA: 0x00009348 File Offset: 0x00007548
|
|
[Token(Token = "0x6000A54")]
|
|
[Address(RVA = "0x2D69C30", Offset = "0x2D68C30", VA = "0x182D69C30")]
|
|
private static double InternalRound(double value, int digits, MidpointRounding mode)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
// Token: 0x06000A55 RID: 2645 RVA: 0x00009360 File Offset: 0x00007560
|
|
[Token(Token = "0x6000A55")]
|
|
[Address(RVA = "0x2D69E00", Offset = "0x2D68E00", VA = "0x182D69E00")]
|
|
private static double InternalTruncate(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the sine of the specified angle.</summary>
|
|
/// <param name="a">An angle, measured in radians.</param>
|
|
/// <returns>The sine of <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A56 RID: 2646 RVA: 0x00009378 File Offset: 0x00007578
|
|
[Token(Token = "0x6000A56")]
|
|
[Address(RVA = "0x2D6A7D0", Offset = "0x2D697D0", VA = "0x182D6A7D0")]
|
|
public static double Sin(double a)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the tangent of the specified angle.</summary>
|
|
/// <param name="a">An angle, measured in radians.</param>
|
|
/// <returns>The tangent of <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
|
|
// Token: 0x06000A57 RID: 2647 RVA: 0x00009390 File Offset: 0x00007590
|
|
[Token(Token = "0x6000A57")]
|
|
[Address(RVA = "0x2D6A800", Offset = "0x2D69800", VA = "0x182D6A800")]
|
|
public static double Tan(double a)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.</summary>
|
|
/// <param name="a">A double-precision floating-point number to be rounded.</param>
|
|
/// <returns>The integer nearest <paramref name="a" />. If the fractional component of <paramref name="a" /> is halfway between two integers, one of which is even and the other odd, then the even number is returned. Note that this method returns a <see cref="T:System.Double" /> instead of an integral type.</returns>
|
|
// Token: 0x06000A58 RID: 2648 RVA: 0x000093A8 File Offset: 0x000075A8
|
|
[Token(Token = "0x6000A58")]
|
|
[Address(RVA = "0x2D6A4B0", Offset = "0x2D694B0", VA = "0x182D6A4B0")]
|
|
public static double Round(double a)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.</summary>
|
|
/// <param name="value">A double-precision floating-point number to be rounded.</param>
|
|
/// <param name="digits">The number of fractional digits in the return value.</param>
|
|
/// <returns>The number nearest to <paramref name="value" /> that contains a number of fractional digits equal to <paramref name="digits" />.</returns>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="digits" /> is less than 0 or greater than 15.</exception>
|
|
// Token: 0x06000A59 RID: 2649 RVA: 0x000093C0 File Offset: 0x000075C0
|
|
[Token(Token = "0x6000A59")]
|
|
[Address(RVA = "0x2D6A3F0", Offset = "0x2D693F0", VA = "0x182D6A3F0")]
|
|
public static double Round(double value, int digits)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.</summary>
|
|
/// <param name="value">A double-precision floating-point number to be rounded.</param>
|
|
/// <param name="digits">The number of fractional digits in the return value.</param>
|
|
/// <param name="mode">Specification for how to round <paramref name="value" /> if it is midway between two other numbers.</param>
|
|
/// <returns>The number nearest to <paramref name="value" /> that has a number of fractional digits equal to <paramref name="digits" />. If <paramref name="value" /> has fewer fractional digits than <paramref name="digits" />, <paramref name="value" /> is returned unchanged.</returns>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="digits" /> is less than 0 or greater than 15.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="mode" /> is not a valid value of <see cref="T:System.MidpointRounding" />.</exception>
|
|
// Token: 0x06000A5A RID: 2650 RVA: 0x000093D8 File Offset: 0x000075D8
|
|
[Token(Token = "0x6000A5A")]
|
|
[Address(RVA = "0x2D6A4C0", Offset = "0x2D694C0", VA = "0x182D6A4C0")]
|
|
public static double Round(double value, int digits, MidpointRounding mode)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.</summary>
|
|
/// <param name="d">A decimal number to be rounded.</param>
|
|
/// <returns>The integer nearest the <paramref name="d" /> parameter. If the fractional component of <paramref name="d" /> is halfway between two integers, one of which is even and the other odd, the even number is returned. Note that this method returns a <see cref="T:System.Decimal" /> instead of an integral type.</returns>
|
|
/// <exception cref="T:System.OverflowException">The result is outside the range of a <see cref="T:System.Decimal" />.</exception>
|
|
// Token: 0x06000A5B RID: 2651 RVA: 0x000093F0 File Offset: 0x000075F0
|
|
[Token(Token = "0x6000A5B")]
|
|
[Address(RVA = "0x2D6A650", Offset = "0x2D69650", VA = "0x182D6A650")]
|
|
public static decimal Round(decimal d)
|
|
{
|
|
return 0m;
|
|
}
|
|
|
|
// Token: 0x06000A5C RID: 2652 RVA: 0x00009408 File Offset: 0x00007608
|
|
[Token(Token = "0x6000A5C")]
|
|
[Address(RVA = "0x2D6A7E0", Offset = "0x2D697E0", VA = "0x182D6A7E0")]
|
|
private unsafe static double SplitFractionDouble(double* value)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Calculates the integral part of a specified double-precision floating-point number.</summary>
|
|
/// <param name="d">A number to truncate.</param>
|
|
/// <returns>The integral part of <paramref name="d" />; that is, the number that remains after any fractional digits have been discarded, or one of the values listed in the following table.
|
|
/// <paramref name="d" /> Return value
|
|
///
|
|
/// <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /><see cref="F:System.Double.NegativeInfinity" /><see cref="F:System.Double.NegativeInfinity" /><see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
|
|
// Token: 0x06000A5D RID: 2653 RVA: 0x00009420 File Offset: 0x00007620
|
|
[Token(Token = "0x6000A5D")]
|
|
[Address(RVA = "0x2D6A810", Offset = "0x2D69810", VA = "0x182D6A810")]
|
|
public static double Truncate(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the square root of a specified number.</summary>
|
|
/// <param name="d">The number whose square root is to be found.</param>
|
|
/// <returns>One of the values in the following table.
|
|
/// <paramref name="d" /> parameter
|
|
///
|
|
/// Return value
|
|
///
|
|
/// Zero or positive
|
|
///
|
|
/// The positive square root of <paramref name="d" />.
|
|
///
|
|
/// Negative
|
|
///
|
|
/// <see cref="F:System.Double.NaN" /> Equals <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equals <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
|
|
// Token: 0x06000A5E RID: 2654 RVA: 0x00009438 File Offset: 0x00007638
|
|
[Token(Token = "0x6000A5E")]
|
|
[Address(RVA = "0x2D6A7F0", Offset = "0x2D697F0", VA = "0x182D6A7F0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static double Sqrt(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the natural (base <see langword="e" />) logarithm of a specified number.</summary>
|
|
/// <param name="d">The number whose logarithm is to be found.</param>
|
|
/// <returns>One of the values in the following table.
|
|
/// <paramref name="d" /> parameter
|
|
///
|
|
/// Return value
|
|
///
|
|
/// Positive
|
|
///
|
|
/// The natural logarithm of <paramref name="d" />; that is, ln <paramref name="d" />, or log e <paramref name="d" /> Zero
|
|
///
|
|
/// <see cref="F:System.Double.NegativeInfinity" /> Negative
|
|
///
|
|
/// <see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
|
|
// Token: 0x06000A5F RID: 2655 RVA: 0x00009450 File Offset: 0x00007650
|
|
[Token(Token = "0x6000A5F")]
|
|
[Address(RVA = "0x2D69FD0", Offset = "0x2D68FD0", VA = "0x182D69FD0")]
|
|
public static double Log(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the base 10 logarithm of a specified number.</summary>
|
|
/// <param name="d">A number whose logarithm is to be found.</param>
|
|
/// <returns>One of the values in the following table.
|
|
/// <paramref name="d" /> parameter
|
|
///
|
|
/// Return value
|
|
///
|
|
/// Positive
|
|
///
|
|
/// The base 10 log of <paramref name="d" />; that is, log 10<paramref name="d" />.
|
|
///
|
|
/// Zero
|
|
///
|
|
/// <see cref="F:System.Double.NegativeInfinity" /> Negative
|
|
///
|
|
/// <see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
|
|
// Token: 0x06000A60 RID: 2656 RVA: 0x00009468 File Offset: 0x00007668
|
|
[Token(Token = "0x6000A60")]
|
|
[Address(RVA = "0x2D69E60", Offset = "0x2D68E60", VA = "0x182D69E60")]
|
|
public static double Log10(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns <see langword="e" /> raised to the specified power.</summary>
|
|
/// <param name="d">A number specifying a power.</param>
|
|
/// <returns>The number <see langword="e" /> raised to the power <paramref name="d" />. If <paramref name="d" /> equals <see cref="F:System.Double.NaN" /> or <see cref="F:System.Double.PositiveInfinity" />, that value is returned. If <paramref name="d" /> equals <see cref="F:System.Double.NegativeInfinity" />, 0 is returned.</returns>
|
|
// Token: 0x06000A61 RID: 2657 RVA: 0x00009480 File Offset: 0x00007680
|
|
[Token(Token = "0x6000A61")]
|
|
[Address(RVA = "0x2D69990", Offset = "0x2D68990", VA = "0x182D69990")]
|
|
public static double Exp(double d)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns a specified number raised to the specified power.</summary>
|
|
/// <param name="x">A double-precision floating-point number to be raised to a power.</param>
|
|
/// <param name="y">A double-precision floating-point number that specifies a power.</param>
|
|
/// <returns>The number <paramref name="x" /> raised to the power <paramref name="y" />.</returns>
|
|
// Token: 0x06000A62 RID: 2658 RVA: 0x00009498 File Offset: 0x00007698
|
|
[Token(Token = "0x6000A62")]
|
|
[Address(RVA = "0x2D6A3E0", Offset = "0x2D693E0", VA = "0x182D6A3E0")]
|
|
public static double Pow(double x, double y)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the remainder resulting from the division of a specified number by another specified number.</summary>
|
|
/// <param name="x">A dividend.</param>
|
|
/// <param name="y">A divisor.</param>
|
|
/// <returns>A number equal to <paramref name="x" /> - (<paramref name="y" /> Q), where Q is the quotient of <paramref name="x" /> / <paramref name="y" /> rounded to the nearest integer (if <paramref name="x" /> / <paramref name="y" /> falls halfway between two integers, the even integer is returned).
|
|
/// If <paramref name="x" /> - (<paramref name="y" /> Q) is zero, the value +0 is returned if <paramref name="x" /> is positive, or -0 if <paramref name="x" /> is negative.
|
|
/// If <paramref name="y" /> = 0, <see cref="F:System.Double.NaN" /> is returned.</returns>
|
|
// Token: 0x06000A63 RID: 2659 RVA: 0x000094B0 File Offset: 0x000076B0
|
|
[Token(Token = "0x6000A63")]
|
|
[Address(RVA = "0x2D699B0", Offset = "0x2D689B0", VA = "0x182D699B0")]
|
|
public static double IEEERemainder(double x, double y)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the absolute value of a 32-bit signed integer.</summary>
|
|
/// <param name="value">A number that is greater than <see cref="F:System.Int32.MinValue" />, but less than or equal to <see cref="F:System.Int32.MaxValue" />.</param>
|
|
/// <returns>A 32-bit signed integer, x, such that 0 ≤ x ≤<see cref="F:System.Int32.MaxValue" />.</returns>
|
|
/// <exception cref="T:System.OverflowException">
|
|
/// <paramref name="value" /> equals <see cref="F:System.Int32.MinValue" />.</exception>
|
|
// Token: 0x06000A64 RID: 2660 RVA: 0x000094C8 File Offset: 0x000076C8
|
|
[Token(Token = "0x6000A64")]
|
|
[Address(RVA = "0x2D69850", Offset = "0x2D68850", VA = "0x182D69850")]
|
|
public static int Abs(int value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06000A65 RID: 2661 RVA: 0x000094E0 File Offset: 0x000076E0
|
|
[Token(Token = "0x6000A65")]
|
|
[Address(RVA = "0x2D696F0", Offset = "0x2D686F0", VA = "0x182D696F0")]
|
|
private static int AbsHelper(int value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the absolute value of a 64-bit signed integer.</summary>
|
|
/// <param name="value">A number that is greater than <see cref="F:System.Int64.MinValue" />, but less than or equal to <see cref="F:System.Int64.MaxValue" />.</param>
|
|
/// <returns>A 64-bit signed integer, x, such that 0 ≤ x ≤<see cref="F:System.Int64.MaxValue" />.</returns>
|
|
/// <exception cref="T:System.OverflowException">
|
|
/// <paramref name="value" /> equals <see cref="F:System.Int64.MinValue" />.</exception>
|
|
// Token: 0x06000A66 RID: 2662 RVA: 0x000094F8 File Offset: 0x000076F8
|
|
[Token(Token = "0x6000A66")]
|
|
[Address(RVA = "0x2D69770", Offset = "0x2D68770", VA = "0x182D69770")]
|
|
public static long Abs(long value)
|
|
{
|
|
return 0L;
|
|
}
|
|
|
|
// Token: 0x06000A67 RID: 2663 RVA: 0x00009510 File Offset: 0x00007710
|
|
[Token(Token = "0x6000A67")]
|
|
[Address(RVA = "0x2D69660", Offset = "0x2D68660", VA = "0x182D69660")]
|
|
private static long AbsHelper(long value)
|
|
{
|
|
return 0L;
|
|
}
|
|
|
|
/// <summary>Returns the absolute value of a single-precision floating-point number.</summary>
|
|
/// <param name="value">A number that is greater than or equal to <see cref="F:System.Single.MinValue" />, but less than or equal to <see cref="F:System.Single.MaxValue" />.</param>
|
|
/// <returns>A single-precision floating-point number, x, such that 0 ≤ x ≤<see cref="F:System.Single.MaxValue" />.</returns>
|
|
// Token: 0x06000A68 RID: 2664 RVA: 0x00009528 File Offset: 0x00007728
|
|
[Token(Token = "0x6000A68")]
|
|
[Address(RVA = "0x2D69910", Offset = "0x2D68910", VA = "0x182D69910")]
|
|
public static float Abs(float value)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
/// <summary>Returns the absolute value of a double-precision floating-point number.</summary>
|
|
/// <param name="value">A number that is greater than or equal to <see cref="F:System.Double.MinValue" />, but less than or equal to <see cref="F:System.Double.MaxValue" />.</param>
|
|
/// <returns>A double-precision floating-point number, x, such that 0 ≤ x ≤<see cref="F:System.Double.MaxValue" />.</returns>
|
|
// Token: 0x06000A69 RID: 2665 RVA: 0x00009540 File Offset: 0x00007740
|
|
[Token(Token = "0x6000A69")]
|
|
[Address(RVA = "0x2D69840", Offset = "0x2D68840", VA = "0x182D69840")]
|
|
public static double Abs(double value)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 8-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 8-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 8-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6A RID: 2666 RVA: 0x00009558 File Offset: 0x00007758
|
|
[Token(Token = "0x6000A6A")]
|
|
[Address(RVA = "0x2D6A080", Offset = "0x2D69080", VA = "0x182D6A080")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static sbyte Max(sbyte val1, sbyte val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 8-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 8-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 8-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6B RID: 2667 RVA: 0x00009570 File Offset: 0x00007770
|
|
[Token(Token = "0x6000A6B")]
|
|
[Address(RVA = "0x2D69FF0", Offset = "0x2D68FF0", VA = "0x182D69FF0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static byte Max(byte val1, byte val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 16-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 16-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 16-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6C RID: 2668 RVA: 0x00009588 File Offset: 0x00007788
|
|
[Token(Token = "0x6000A6C")]
|
|
[Address(RVA = "0x2D6A1D0", Offset = "0x2D691D0", VA = "0x182D6A1D0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static short Max(short val1, short val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 16-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 16-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 16-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6D RID: 2669 RVA: 0x000095A0 File Offset: 0x000077A0
|
|
[Token(Token = "0x6000A6D")]
|
|
[Address(RVA = "0x2D6A010", Offset = "0x2D69010", VA = "0x182D6A010")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static ushort Max(ushort val1, ushort val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 32-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 32-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 32-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6E RID: 2670 RVA: 0x000095B8 File Offset: 0x000077B8
|
|
[Token(Token = "0x6000A6E")]
|
|
[Address(RVA = "0x2D6A130", Offset = "0x2D69130", VA = "0x182D6A130")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static int Max(int val1, int val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 32-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 32-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 32-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A6F RID: 2671 RVA: 0x000095D0 File Offset: 0x000077D0
|
|
[Token(Token = "0x6000A6F")]
|
|
[Address(RVA = "0x2D6A000", Offset = "0x2D69000", VA = "0x182D6A000")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static uint Max(uint val1, uint val2)
|
|
{
|
|
return 0U;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 64-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 64-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 64-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A70 RID: 2672 RVA: 0x000095E8 File Offset: 0x000077E8
|
|
[Token(Token = "0x6000A70")]
|
|
[Address(RVA = "0x2D69FE0", Offset = "0x2D68FE0", VA = "0x182D69FE0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static long Max(long val1, long val2)
|
|
{
|
|
return 0L;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two 64-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 64-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 64-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A71 RID: 2673 RVA: 0x00009600 File Offset: 0x00007800
|
|
[Token(Token = "0x6000A71")]
|
|
[Address(RVA = "0x2D6A070", Offset = "0x2D69070", VA = "0x182D6A070")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static ulong Max(ulong val1, ulong val2)
|
|
{
|
|
return 0UL;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two single-precision floating-point numbers.</summary>
|
|
/// <param name="val1">The first of two single-precision floating-point numbers to compare.</param>
|
|
/// <param name="val2">The second of two single-precision floating-point numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger. If <paramref name="val1" />, or <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.NaN" /> is returned.</returns>
|
|
// Token: 0x06000A72 RID: 2674 RVA: 0x00009618 File Offset: 0x00007818
|
|
[Token(Token = "0x6000A72")]
|
|
[Address(RVA = "0x2D6A020", Offset = "0x2D69020", VA = "0x182D6A020")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static float Max(float val1, float val2)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two double-precision floating-point numbers.</summary>
|
|
/// <param name="val1">The first of two double-precision floating-point numbers to compare.</param>
|
|
/// <param name="val2">The second of two double-precision floating-point numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NaN" /> is returned.</returns>
|
|
// Token: 0x06000A73 RID: 2675 RVA: 0x00009630 File Offset: 0x00007830
|
|
[Token(Token = "0x6000A73")]
|
|
[Address(RVA = "0x2D6A140", Offset = "0x2D69140", VA = "0x182D6A140")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static double Max(double val1, double val2)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the larger of two decimal numbers.</summary>
|
|
/// <param name="val1">The first of two decimal numbers to compare.</param>
|
|
/// <param name="val2">The second of two decimal numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
|
|
// Token: 0x06000A74 RID: 2676 RVA: 0x00009648 File Offset: 0x00007848
|
|
[Token(Token = "0x6000A74")]
|
|
[Address(RVA = "0x2D6A090", Offset = "0x2D69090", VA = "0x182D6A090")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static decimal Max(decimal val1, decimal val2)
|
|
{
|
|
return 0m;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 8-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 8-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 8-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A75 RID: 2677 RVA: 0x00009660 File Offset: 0x00007860
|
|
[Token(Token = "0x6000A75")]
|
|
[Address(RVA = "0x2D6A3D0", Offset = "0x2D693D0", VA = "0x182D6A3D0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
[CLSCompliant(false)]
|
|
public static sbyte Min(sbyte val1, sbyte val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 8-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 8-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 8-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A76 RID: 2678 RVA: 0x00009678 File Offset: 0x00007878
|
|
[Token(Token = "0x6000A76")]
|
|
[Address(RVA = "0x2D6A290", Offset = "0x2D69290", VA = "0x182D6A290")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static byte Min(byte val1, byte val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 16-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 16-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 16-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A77 RID: 2679 RVA: 0x00009690 File Offset: 0x00007890
|
|
[Token(Token = "0x6000A77")]
|
|
[Address(RVA = "0x2D6A2A0", Offset = "0x2D692A0", VA = "0x182D6A2A0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static short Min(short val1, short val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 16-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 16-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 16-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A78 RID: 2680 RVA: 0x000096A8 File Offset: 0x000078A8
|
|
[Token(Token = "0x6000A78")]
|
|
[Address(RVA = "0x2D6A270", Offset = "0x2D69270", VA = "0x182D6A270")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static ushort Min(ushort val1, ushort val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 32-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 32-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 32-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A79 RID: 2681 RVA: 0x000096C0 File Offset: 0x000078C0
|
|
[Token(Token = "0x6000A79")]
|
|
[Address(RVA = "0x2D6A3A0", Offset = "0x2D693A0", VA = "0x182D6A3A0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static int Min(int val1, int val2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 32-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 32-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 32-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A7A RID: 2682 RVA: 0x000096D8 File Offset: 0x000078D8
|
|
[Token(Token = "0x6000A7A")]
|
|
[Address(RVA = "0x2D6A3C0", Offset = "0x2D693C0", VA = "0x182D6A3C0")]
|
|
[CLSCompliant(false)]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static uint Min(uint val1, uint val2)
|
|
{
|
|
return 0U;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 64-bit signed integers.</summary>
|
|
/// <param name="val1">The first of two 64-bit signed integers to compare.</param>
|
|
/// <param name="val2">The second of two 64-bit signed integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A7B RID: 2683 RVA: 0x000096F0 File Offset: 0x000078F0
|
|
[Token(Token = "0x6000A7B")]
|
|
[Address(RVA = "0x2D6A280", Offset = "0x2D69280", VA = "0x182D6A280")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static long Min(long val1, long val2)
|
|
{
|
|
return 0L;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two 64-bit unsigned integers.</summary>
|
|
/// <param name="val1">The first of two 64-bit unsigned integers to compare.</param>
|
|
/// <param name="val2">The second of two 64-bit unsigned integers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A7C RID: 2684 RVA: 0x00009708 File Offset: 0x00007908
|
|
[Token(Token = "0x6000A7C")]
|
|
[Address(RVA = "0x2D6A3B0", Offset = "0x2D693B0", VA = "0x182D6A3B0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
[CLSCompliant(false)]
|
|
public static ulong Min(ulong val1, ulong val2)
|
|
{
|
|
return 0UL;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two single-precision floating-point numbers.</summary>
|
|
/// <param name="val1">The first of two single-precision floating-point numbers to compare.</param>
|
|
/// <param name="val2">The second of two single-precision floating-point numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.NaN" /> is returned.</returns>
|
|
// Token: 0x06000A7D RID: 2685 RVA: 0x00009720 File Offset: 0x00007920
|
|
[Token(Token = "0x6000A7D")]
|
|
[Address(RVA = "0x2D6A2B0", Offset = "0x2D692B0", VA = "0x182D6A2B0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static float Min(float val1, float val2)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two double-precision floating-point numbers.</summary>
|
|
/// <param name="val1">The first of two double-precision floating-point numbers to compare.</param>
|
|
/// <param name="val2">The second of two double-precision floating-point numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NaN" /> is returned.</returns>
|
|
// Token: 0x06000A7E RID: 2686 RVA: 0x00009738 File Offset: 0x00007938
|
|
[Token(Token = "0x6000A7E")]
|
|
[Address(RVA = "0x2D6A1E0", Offset = "0x2D691E0", VA = "0x182D6A1E0")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static double Min(double val1, double val2)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns the smaller of two decimal numbers.</summary>
|
|
/// <param name="val1">The first of two decimal numbers to compare.</param>
|
|
/// <param name="val2">The second of two decimal numbers to compare.</param>
|
|
/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
|
|
// Token: 0x06000A7F RID: 2687 RVA: 0x00009750 File Offset: 0x00007950
|
|
[Token(Token = "0x6000A7F")]
|
|
[Address(RVA = "0x2D6A300", Offset = "0x2D69300", VA = "0x182D6A300")]
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
|
|
public static decimal Min(decimal val1, decimal val2)
|
|
{
|
|
return 0m;
|
|
}
|
|
|
|
/// <summary>Returns the logarithm of a specified number in a specified base.</summary>
|
|
/// <param name="a">The number whose logarithm is to be found.</param>
|
|
/// <param name="newBase">The base of the logarithm.</param>
|
|
/// <returns>One of the values in the following table. (+Infinity denotes <see cref="F:System.Double.PositiveInfinity" />, -Infinity denotes <see cref="F:System.Double.NegativeInfinity" />, and NaN denotes <see cref="F:System.Double.NaN" />.)
|
|
/// <paramref name="a" /><paramref name="newBase" /> Return value
|
|
///
|
|
/// <paramref name="a" />> 0
|
|
///
|
|
/// (0 <<paramref name="newBase" />< 1) -or-(<paramref name="newBase" />> 1)
|
|
///
|
|
/// lognewBase(a)
|
|
///
|
|
/// <paramref name="a" />< 0
|
|
///
|
|
/// (any value)
|
|
///
|
|
/// NaN
|
|
///
|
|
/// (any value)
|
|
///
|
|
/// <paramref name="newBase" />< 0
|
|
///
|
|
/// NaN
|
|
///
|
|
/// <paramref name="a" /> != 1
|
|
///
|
|
/// <paramref name="newBase" /> = 0
|
|
///
|
|
/// NaN
|
|
///
|
|
/// <paramref name="a" /> != 1
|
|
///
|
|
/// <paramref name="newBase" /> = +Infinity
|
|
///
|
|
/// NaN
|
|
///
|
|
/// <paramref name="a" /> = NaN
|
|
///
|
|
/// (any value)
|
|
///
|
|
/// NaN
|
|
///
|
|
/// (any value)
|
|
///
|
|
/// <paramref name="newBase" /> = NaN
|
|
///
|
|
/// NaN
|
|
///
|
|
/// (any value)
|
|
///
|
|
/// <paramref name="newBase" /> = 1
|
|
///
|
|
/// NaN
|
|
///
|
|
/// <paramref name="a" /> = 0
|
|
///
|
|
/// 0 <<paramref name="newBase" />< 1
|
|
///
|
|
/// +Infinity
|
|
///
|
|
/// <paramref name="a" /> = 0
|
|
///
|
|
/// <paramref name="newBase" />> 1
|
|
///
|
|
/// -Infinity
|
|
///
|
|
/// <paramref name="a" /> = +Infinity
|
|
///
|
|
/// 0 <<paramref name="newBase" />< 1
|
|
///
|
|
/// -Infinity
|
|
///
|
|
/// <paramref name="a" /> = +Infinity
|
|
///
|
|
/// <paramref name="newBase" />> 1
|
|
///
|
|
/// +Infinity
|
|
///
|
|
/// <paramref name="a" /> = 1
|
|
///
|
|
/// <paramref name="newBase" /> = 0
|
|
///
|
|
/// 0
|
|
///
|
|
/// <paramref name="a" /> = 1
|
|
///
|
|
/// <paramref name="newBase" /> = +Infinity
|
|
///
|
|
/// 0</returns>
|
|
// Token: 0x06000A80 RID: 2688 RVA: 0x00009768 File Offset: 0x00007968
|
|
[Token(Token = "0x6000A80")]
|
|
[Address(RVA = "0x2D69E70", Offset = "0x2D68E70", VA = "0x182D69E70")]
|
|
public static double Log(double a, double newBase)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
/// <summary>Returns an integer that indicates the sign of a 32-bit signed integer.</summary>
|
|
/// <param name="value">A signed number.</param>
|
|
/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.
|
|
/// Return value
|
|
///
|
|
/// Meaning
|
|
///
|
|
/// -1
|
|
///
|
|
/// <paramref name="value" /> is less than zero.
|
|
///
|
|
/// 0
|
|
///
|
|
/// <paramref name="value" /> is equal to zero.
|
|
///
|
|
/// 1
|
|
///
|
|
/// <paramref name="value" /> is greater than zero.</returns>
|
|
// Token: 0x06000A81 RID: 2689 RVA: 0x00009780 File Offset: 0x00007980
|
|
[Token(Token = "0x6000A81")]
|
|
[Address(RVA = "0x2D6A790", Offset = "0x2D69790", VA = "0x182D6A790")]
|
|
public static int Sign(int value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns an integer that indicates the sign of a 64-bit signed integer.</summary>
|
|
/// <param name="value">A signed number.</param>
|
|
/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.
|
|
/// Return value
|
|
///
|
|
/// Meaning
|
|
///
|
|
/// -1
|
|
///
|
|
/// <paramref name="value" /> is less than zero.
|
|
///
|
|
/// 0
|
|
///
|
|
/// <paramref name="value" /> is equal to zero.
|
|
///
|
|
/// 1
|
|
///
|
|
/// <paramref name="value" /> is greater than zero.</returns>
|
|
// Token: 0x06000A82 RID: 2690 RVA: 0x00009798 File Offset: 0x00007998
|
|
[Token(Token = "0x6000A82")]
|
|
[Address(RVA = "0x2D6A7B0", Offset = "0x2D697B0", VA = "0x182D6A7B0")]
|
|
public static int Sign(long value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>Returns an integer that indicates the sign of a double-precision floating-point number.</summary>
|
|
/// <param name="value">A signed number.</param>
|
|
/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.
|
|
/// Return value
|
|
///
|
|
/// Meaning
|
|
///
|
|
/// -1
|
|
///
|
|
/// <paramref name="value" /> is less than zero.
|
|
///
|
|
/// 0
|
|
///
|
|
/// <paramref name="value" /> is equal to zero.
|
|
///
|
|
/// 1
|
|
///
|
|
/// <paramref name="value" /> is greater than zero.</returns>
|
|
/// <exception cref="T:System.ArithmeticException">
|
|
/// <paramref name="value" /> is equal to <see cref="F:System.Double.NaN" />.</exception>
|
|
// Token: 0x06000A83 RID: 2691 RVA: 0x000097B0 File Offset: 0x000079B0
|
|
[Token(Token = "0x6000A83")]
|
|
[Address(RVA = "0x2D6A6D0", Offset = "0x2D696D0", VA = "0x182D6A6D0")]
|
|
public static int Sign(double value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x04000462 RID: 1122
|
|
[Token(Token = "0x4000462")]
|
|
private static double doubleRoundLimit;
|
|
|
|
// Token: 0x04000463 RID: 1123
|
|
[Token(Token = "0x4000463")]
|
|
private const int maxRoundingDigits = 15;
|
|
|
|
// Token: 0x04000464 RID: 1124
|
|
[Token(Token = "0x4000464")]
|
|
private static double[] roundPower10Double;
|
|
|
|
/// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
|
|
// Token: 0x04000465 RID: 1125
|
|
[Token(Token = "0x4000465")]
|
|
public const double PI = 3.141592653589793;
|
|
|
|
/// <summary>Represents the natural logarithmic base, specified by the constant, <see langword="e" />.</summary>
|
|
// Token: 0x04000466 RID: 1126
|
|
[Token(Token = "0x4000466")]
|
|
public const double E = 2.718281828459045;
|
|
}
|
|
}
|