In this article, we are going to describe the Math class in C#. The Math class in C# contains lots of useful static methods for performing all sorts of calculations. We’ll briefly describe all the methods in the library with some examples, so it will be quite a long article, but you can use it as a reference as well.<\/p>\n
Let’s see what we have at our disposal.<\/p>\n
The first set of functions contains the most commonly used functions like the square root and calculating the maximum or minimum of two numbers.<\/p>\n
The Similar to many other methods we will see, there are several overloads of this method: It can accept a decimal, double, float, int, long, nint, sbyte or short, and returns the respective type.<\/p>\n The It can accept a decimal, double, float, int, long, nint, sbyte, short, byte, uint, ulong, or ushort.<\/p>\n The The It can accept a decimal, double, float, int, long, nint, sbyte, short, byte, uint, long, or ushort.<\/p>\n The The As the result of multiplying two int numbers won’t fit into an int, the result is a long: There are also overloads to multiply long values and ulong values. In this case, the result will not fit into a long, so the result is spread of the return argument and an out argument, here we show it for the long case:<\/p>\n Returns the next larger (resp. smaller) double value that compares greater (resp. smaller) than the given argument:<\/p>\n Returns the cube root of the given double argument: Returns a value with the magnitude of the first, and the sign of the second double argument: This method performs division with remainder, and returns both the quotient and the remainder as a tuple: The input can be byte, int, long, nint, nuint, sbyte, short, uint, ulong, or ushort.\u00a0<\/p>\n Returns Both the input values and the output values are doubles.<\/p>\n This method returns the remainder resulting from the division of a specified number by another specified number, using the following formula. Both input and output are doubles:<\/p>\n The result is different from the This method returns an estimate of the reciprocal of a specified Unless it is an ARM64 architecture, this simply returns 1.0\/value resp. 1.0\/sqrt(value). In the case of an ARM64 architecture, it performs a Newton-Raphson iteration to calculate it, which might be more efficient.<\/p>\n This method returns the sign of a given number, i.e. returns -1 if the value is less than zero, 0 if it is zero, and +1 if it is greater than zero: The input can be a double, int, float, decimal, long, nint, sbyte, or short. The output is always an int.<\/p>\n Returns the square root of a given double. When it is negative, it returns The Math class in C# provides lots of methods to work with exponentials and logarithms.<\/p>\n Returns the mathematical constant The input and output are double.<\/p>\n This method returns the base 2 integer logarithm of a specified double number, i.e. (int)log2(val): Returns the natural logarithm of a given double value. When the given value is 0, it returns Returns the 10 log resp. 2 log of a given double value. When the given value is 0, it returns Returns a specified number raised to another specified number. Both input and output are doubles: Returns x*2^n, where x is a double and n is an integer. This can be done efficiently: All the common (and less common) trigonometric methods are available in the These methods return the sine, cosine, or tangent resp. of a given double angle, measures in radians:<\/p>\n These are the inverse sine, cosine, and tangent.<\/p>\n The Asin returns a value in the range-0.5PI till 0.5PI, double.NaN if the input is greater than 1, less than -1<\/p>\n The Acos returns a value in the range 0 till PI.<\/p>\n The Atan returns a value in the range -0.5PI till 0.5PI. If the given value is These methods return the hyperbolic sine, cosine, and tangent of a given double value:<\/p>\n These methods return the inverse hyperbolic sine, cosine, and tangent of a given double value:<\/p>\n There are several different rounding related methods, which we organized under this section:<\/p>\n Returns the smallest integral value that is greater than or equal to the specified number. The input and output can be double or decimal:<\/p>\n Returns the value clamped to a specified min and max value. If the value lies between the min and max, it simply returns the value. Otherwise, it returns either min or max. The input types can be decimal, double, float, int, long, nint, sbyte, short, byte, uint, ulong, or short:<\/p>\n Returns the largest integral value that is smaller than or equal to the specified number. The input and output can be double or decimal:<\/p>\n Returns the closest integral value. The input type can be either double or decimal. One can also specify to how many decimal digits the specified value needs to be rounded to:<\/p>\n Returns an integral part of a given value. This is different than the other methods mentioned in this section, as it might round up or down depending on the sign of the value. The value itself can be double or decimal:<\/p>\n There are several important mathematical constants that are represented as fields in the Math class in C#.<\/p>\nAbs<\/code> method returns the absolute value of the given argument:
\nMath.Abs(-1); \/\/ returns 1<\/code><\/p>\nMax<\/h3>\n
Max<\/code> method returns the maximum value of the two arguments:
\nMath.Max(3.7, 1.8);\/\/ returns\u00a0 3.7<\/code><\/p>\nMaxMagnitude<\/h3>\n
MaxMagnitude<\/code> method returns the larger magnitude of two doubles:
\nMath.MaxMagnitude(-10.0, 3.0); \/\/returns -10<\/code><\/p>\nMin<\/h3>\n
Min<\/code> method returns the minimum value of the two arguments:
\nMath.Min(5, 10); \/\/ returns 5<\/code><\/p>\nMinMagnitude<\/h3>\n
MinMagnitude<\/code> method returns the smaller magnitude of two doubles:
\nMath.MinMagnitude(-10.0, 3.0); \/\/returns 3<\/code><\/p>\nBigMul<\/h3>\n
BigMul<\/code> method produces the full product of two numbers.\u00a0<\/p>\n
\nlong result = Math.BigMul(Int32.MaxValue, Int32.MaxValue); \/\/ returns 4611686014132420609<\/code><\/p>\nlong lowerBits = 0, arg1 = long.MaxValue, arg2 = long.MaxValue;\r\nlong higherBits = Math.BigMul(arg1, arg2, out lowerBits);<\/pre>\n
BitIncrement, BitDecrement<\/h3>\n
bool lhsIsSmaller = Math.BitDecrement(1.123) < 1.123; \/\/ returns true\r\nbool rhsIsSmaller = Math.BitIncrement(1.123) > 1.123; \/\/ returns true<\/pre>\n
Cbrt<\/h3>\n
\nMath.Cbrt(8.0); \/\/returns 2<\/code><\/p>\nCopySign<\/h3>\n
\nMath.CopySign(10.0, -2.0); \/\/ returns -10<\/code><\/p>\nDivRem<\/h3>\n
\nvar (quotient, rem) = Math.DivRem(15, 7); \/\/ (quotient, rem) is (2, 1)<\/code><\/p>\nFusedMultiplyAdd<\/h3>\n
(x*y)+z<\/code>, rounded as one operation. Contrary to doing these operations separately, the intermediate result is not rounded so this will give more accurate results. This can be beneficial in applications where the loss of precision due to many intermediate steps can be an issue:<\/p>\nMath.FusedMultiplyAdd(1.0, 2.0, 3.0); \/\/ returns 1*2 + 3 = 5<\/code><\/p>\nIEEERemainder<\/h3>\n
IEEERemainder = dividend - (divisor * Math.Round(dividend \/ divisor)) <\/code><\/p>\n%<\/code> operator:<\/p>\nMath.IEEERemainder(3,\u00a0 2); \/\/returns -1\r\nvar val = 3 % 2 \/\/ val is 1<\/pre>\n
ReciprocalEstimate, ReciprocalSqrtEstimate<\/h3>\n
double<\/code> or the reciprocal square root of a given value:<\/p>\nMath.ReciprocalEstimate(2.0);\/\/ returns 0.5\r\nMath.ReciprocalSqrtEstimate(4.0); \/\/ returns 1\/(sqrt(4)) = 1\/2 = 0.5<\/pre>\n
Sign<\/h3>\n
\nMath.Sign(-5.0); \/\/ returns -1<\/code><\/p>\nSqrt<\/h3>\n
double.NaN<\/code>:
\nMath.Sqrt(4.0); \/\/ returns 2<\/code><\/p>\n<\/a>Exponential and Logarithmic Functions<\/h2>\n
Exp<\/h3>\n
e<\/code> raised to the given power:
\nMath.Exp(1); \/\/ returns 2.71..<\/code><\/p>\nILogB<\/h3>\n
\nMath.ILogB(9.0); \/\/ returns 3<\/code><\/p>\nLog<\/h3>\n
double.NegativeInfinity<\/code> and for negative values, it returns double.NaN<\/code>. You can also specify an optional argument to use another base:<\/p>\nMath.Log(Math.Exp(4.0));\/\/returns 4\r\nMath.Log(100, 10); \/\/ returns 2<\/pre>\n
Log10, Log2<\/h3>\n
double.NegativeInfinity<\/code>, and for negative values, it returns double.NaN<\/code>:<\/p>\nMath.Log10(1000); \/\/ returns 3\r\nMath.Log2(16); \/\/ returns 4<\/pre>\n
Pow<\/h3>\n
\nMath.Pow(3.0, 3.0); \/\/ returns 3^3 = 27<\/code><\/p>\nScaleB<\/h3>\n
\nMath.ScaleB(3.0, 2); \/\/ returns 3.0*4 = 12<\/code><\/p>\n<\/a>Trigonometric Functions<\/h2>\n
Math<\/code> class as well:<\/p>\nSin, Cos, Tan<\/h3>\n
Math.Sin(Math.PI); \/\/ returns 0\r\nMath.Cos(Math.PI); \/\/ returns -1\r\nMath.Tan(Math.PI); \/\/ returns 0<\/pre>\n
Asin, Acos, Atan<\/h3>\n
double.PositiveInfinity<\/code>, it returns 0.5*Math.PI<\/code> rounded to the nearest double:<\/p>\nMath.Asin(1); \/\/ returns Math.PI*0.5\r\nMath.Acos(0); \/\/ returns Math.PI\r\nMath.Atan(double.PositiveInfinity); \/\/ returns 1.5707...<\/pre>\n
Sinh, Cosh, Tanh<\/h3>\n
Math.Sinh(0); \/\/ returns 0\r\nMath.Cosh(0.0); \/\/ returns 1\r\nMath.Tanh(0.0); \/\/returns 0<\/pre>\n
Asinh, Acosh, Atanh<\/h3>\n
Math.Asinh(0.0); \/\/ returns 0\r\nMath.Acosh(1.0); \/\/ returns 0\r\nMath.Atanh(0.0); \/\/ returns 0<\/pre>\n
<\/a>Rounding and Related Functions<\/h2>\n
Ceiling<\/h3>\n
Math.Ceiling(3.001); \/\/ returns 4\r\nMath.Ceiling(1.0); \/\/ returns 1<\/pre>\n
Clamp<\/h3>\n
Math.Clamp(0.0, -1.0, 2.0); \/\/ returns 0\r\nMath.Clamp(-10.0, -1.0, 2.0); \/\/ returns -1\r\nMath.Clamp(10.0, -1.0, 2.0); \/\/ returns 2<\/pre>\n
Floor<\/h3>\n
Math.Floor(1.0); \/\/ returns 1\r\nMath.Floor(1.3); \/\/ returns 1\r\nMath.Floor(1.999); \/\/ returns 1<\/pre>\n
Round<\/h3>\n
Math.Round(1.49); \/\/ returns 1\r\nMath.Round(1.49, 1); \/\/ returns 1.5<\/pre>\n
Truncate<\/h3>\n
Math.Truncate(-2.2); \/\/ returns -2\r\nMath.Truncate(2.2); \/\/ returns 2<\/pre>\n
<\/a>Fields<\/h2>\n
PI<\/h3>\n