Double
DoubleExtension.cs
``````﻿namespace System
{
public static clast DoubleExtension
{
public static long ToLong(this double @this)
{
return Convert.ToInt64(@this);
}

///
/// A T extension method that check if the value is between inclusively the minValue and maxValue.
///
/// The @this to act on.
/// The minimum value.
/// The maximum value.
/// true if the value is between inclusively the minValue and maxValue, otherwise false.
public static bool InRange(this double @this, double minValue, double maxValue)
{
return @this.CompareTo(minValue) >= 0 && @this.CompareTo(maxValue)  Convert.ToInt32(Math.Ceiling(a));

///
///     Returns the cosine of the specified angle.
///
/// An angle, measured in radians.
/// The cosine of . If  is equal to , , or , this method returns .
public static double Cos(this double d)
{
return Math.Cos(d);
}

///
///     Returns the hyperbolic cosine of the specified angle.
///
/// An angle, measured in radians.
/// The hyperbolic cosine of . If  is equal to  or ,  is returned. If  is equal to ,  is returned.
public static double Cosh(this double value)
{
return Math.Cosh(value);
}

///
///     Returns e raised to the specified power.
///
/// A number specifying a power.
///
///     The number e raised to the power . If  equals  or , that value is returned. If  equals , 0 is returned.
///
public static double Exp(this double d)
{
return Math.Exp(d);
}

///
///     Returns the largest integer less than or equal to the specified double-precision floating-point number.
///
/// A double-precision floating-point number.
/// The largest integer less than or equal to . If  is equal to , , or , that value is returned.
public static int Floor(this double d)
{
return Convert.ToInt32(Math.Floor(d));
}

///
///     Returns the remainder resulting from the division of a specified number by another specified number.
///
/// A dividend.
/// A divisor.
///
///     A number equal to  - ( Q), where Q is the quotient of  /  rounded to the nearest integer (if  /  falls
///     halfway between two integers, the even integer is returned).If  - ( Q) is zero, the value +0 is returned if
///     is positive, or -0 if  is negative.If  = 0,  is returned.
///
public static double IEEERemainder(this double x, double y)
{
return Math.IEEERemainder(x, y);
}

///
///     Returns the natural (base e) logarithm of a specified number.
///
/// The number whose logarithm is to be found.
///
///     One of the values in the following table.  parameterReturn value Positive The natural logarithm of ; that is,
///     ln , or log eZero Negative Equal to Equal to.
///
public static double Log(this double d)
{
return Math.Log(d);
}

///
///     Returns the logarithm of a specified number in a specified base.
///
/// The number whose logarithm is to be found.
/// The base of the logarithm.
///
///     One of the values in the following table. (+Infinity denotes , -Infinity denotes , and NaN denotes .)Return
///     value> 0(0 << 1) -or-(> 1)lognewBase(a)< 0(any value)NaN(any value)< 0NaN != 1 = 0NaN != 1
///     = +InfinityNaN = NaN(any value)NaN(any value) = NaNNaN(any value) = 1NaN = 00 << 1 +Infinity = 0> 1-
///     Infinity =  +Infinity0 << 1-Infinity =  +Infinity> 1+Infinity = 1 = 00 = 1 = +Infinity0.
///
public static double Log(this double d, double newBase)
{
return Math.Log(d, newBase);
}

///
///     Returns the base 10 logarithm of a specified number.
///
/// A number whose logarithm is to be found.
///
///     One of the values in the following table.  parameter Return value Positive The base 10 log of ; that is, log
///     10. Zero Negative Equal to Equal to.
///
public static double Log10(this double d)
{
return Math.Log10(d);
}

///
///     Returns the larger of two double-precision floating-point numbers.
///
/// The first of two double-precision floating-point numbers to compare.
/// The second of two double-precision floating-point numbers to compare.
/// Parameter  or , whichever is larger. If , , or both  and  are equal to ,  is returned.
public static double Max(this double val1, double val2)
{
return Math.Max(val1, val2);
}

///
///     Returns the smaller of two double-precision floating-point numbers.
///
/// The first of two double-precision floating-point numbers to compare.
/// The second of two double-precision floating-point numbers to compare.
/// Parameter  or , whichever is smaller. If , , or both  and  are equal to ,  is returned.
public static double Min(this double val1, double val2) => Math.Min(val1, val2);

///
///     Returns a specified number raised to the specified power.
///
/// A double-precision floating-point number to be raised to a power.
/// A double-precision floating-point number that specifies a power.
/// The number  raised to the power .
public static double Pow(this double x, double y) => Math.Pow(x, y);

///
///     Rounds a double-precision floating-point value to the nearest integral value.
///
/// A double-precision floating-point number to be rounded.
///
///     The integer nearest . If the fractional component of  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  instead of an integral
///     type.
///
public static double Round(this double a) => Math.Round(a);

///
///     Rounds a double-precision floating-point value to a specified number of fractional digits.
///
/// A double-precision floating-point number to be rounded.
/// The number of fractional digits in the return value.
/// The number nearest to  that contains a number of fractional digits equal to .
public static double Round(this double a, int digits) => Math.Round(a, digits);

///
///     Rounds a double-precision floating-point value to the nearest integer. A parameter specifies how to round the
///     value if it is midway between two numbers.
///
/// A double-precision floating-point number to be rounded.
/// Specification for how to round  if it is midway between two other numbers.
///
///     The integer nearest . If  is halfway between two integers, one of which is even and the other odd, then
///     determines which of the two is returned.
///
public static double Round(this double a, MidpointRounding mode) => Math.Round(a, mode);

///
///     Rounds a double-precision floating-point value to a specified number of fractional digits. A parameter
///     specifies how to round the value if it is midway between two numbers.
///
/// A double-precision floating-point number to be rounded.
/// The number of fractional digits in the return value.
/// Specification for how to round  if it is midway between two other numbers.
///
///     The number nearest to  that has a number of fractional digits equal to . If  has fewer fractional digits than
///     ,  is returned unchanged.
///
public static double Round(this double value, int digits, MidpointRounding mode) => Math.Round(value, digits, mode);

///
///     Returns a value indicating the sign of a double-precision floating-point number.
///
/// A signed number.
///
///     A number that indicates the sign of , as shown in the following table.Return value Meaning -1  is less than
///     zero. 0  is equal to zero. 1  is greater than zero.
///
public static int Sign(this double value) => Math.Sign(value);

///
///     Returns the sine of the specified angle.
///
/// An angle, measured in radians.
/// The sine of . If  is equal to , , or , this method returns .
public static double Sin(this double a)
{
return Math.Sin(a);
}

///
///     Returns the hyperbolic sine of the specified angle.
///
/// An angle, measured in radians.
/// The hyperbolic sine of . If  is equal to , , or , this method returns a  equal to .
public static double Sinh(this double value)
{
return Math.Sinh(value);
}

///
///     Returns the square root of a specified number.
///
/// The number whose square root is to be found.
///
///     One of the values in the following table.  parameter Return value Zero or positive The positive square root
///     of . Negative Equals Equals.
///
public static double Sqrt(this double d)
{
return Math.Sqrt(d);
}

///
///     Returns the tangent of the specified angle.
///
/// An angle, measured in radians.
/// The tangent of . If  is equal to , , or , this method returns .
public static double Tan(this double a)
{
return Math.Tan(a);
}

///
///     Returns the hyperbolic tangent of the specified angle.
///
/// An angle, measured in radians.
///
///     The hyperbolic tangent of . If  is equal to , this method returns -1. If value is equal to , this method
///     returns 1. If  is equal to , this method returns .
///
public static double Tanh(this double value)
{
return Math.Tanh(value);
}

///
///     Calculates the integral part of a specified double-precision floating-point number.
///
/// A number to truncate.
///
///     The integral part of ; that is, the number that remains after any fractional digits have been discarded, or
///     one of the values listed in the following table. Return value.
///
public static double Truncate(this double d) => Math.Truncate(d);

///
///     A Double extension method that converts the @this to a moneyFormat.
///
/// The @this to act on.
/// @this as a Double.
public static double ToMoney(this double @this) => Math.Round(@this, 2);
}
}``````