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.

Let’s see what we have at our disposal.

## Basic Math Functions

The first set of functions contains the most commonly used functions like the square root and calculating the maximum or minimum of two numbers.

### Abs

The `Abs` method returns the absolute value of the given argument:
`Math.Abs(-1); // returns 1`

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.

### Max

The `Max` method returns the maximum value of the two arguments:
`Math.Max(3.7, 1.8);// returns  3.7`

It can accept a decimal, double, float, int, long, nint, sbyte, short, byte, uint, ulong, or ushort.

### MaxMagnitude

The `MaxMagnitude` method returns the larger magnitude of two doubles:
`Math.MaxMagnitude(-10.0, 3.0); //returns -10`

### Min

The `Min` method returns the minimum value of the two arguments:
`Math.Min(5, 10); // returns 5`

It can accept a decimal, double, float, int, long, nint, sbyte, short, byte, uint, long, or ushort.

### MinMagnitude

The `MinMagnitude` method returns the smaller magnitude of two doubles:
`Math.MinMagnitude(-10.0, 3.0); //returns 3`

### BigMul

The `BigMul` method produces the full product of two numbers.

As the result of multiplying two int numbers won’t fit into an int, the result is a long:
`long result = Math.BigMul(Int32.MaxValue, Int32.MaxValue); // returns 4611686014132420609`

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:

```long lowerBits = 0, arg1 = long.MaxValue, arg2 = long.MaxValue;
long higherBits = Math.BigMul(arg1, arg2, out lowerBits);```

### BitIncrement, BitDecrement

Returns the next larger (resp. smaller) double value that compares greater (resp. smaller) than the given argument:

```bool lhsIsSmaller = Math.BitDecrement(1.123) < 1.123; // returns true
bool rhsIsSmaller = Math.BitIncrement(1.123) > 1.123; // returns true```

### Cbrt

Returns the cube root of the given double argument:
`Math.Cbrt(8.0); //returns 2`

### CopySign

Returns a value with the magnitude of the first, and the sign of the second double argument:
`Math.CopySign(10.0, -2.0); // returns -10`

### DivRem

This method performs division with remainder, and returns both the quotient and the remainder as a tuple:
`var (quotient, rem) = Math.DivRem(15, 7); // (quotient, rem) is (2, 1)`

The input can be byte, int, long, nint, nuint, sbyte, short, uint, ulong, or ushort.

Returns `(x*y)+z`, 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:

`Math.FusedMultiplyAdd(1.0, 2.0, 3.0); // returns 1*2 + 3 = 5`

Both the input values and the output values are doubles.

### IEEERemainder

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:

`IEEERemainder = dividend - (divisor * Math.Round(dividend / divisor)) `

The result is different from the `%` operator:

```Math.IEEERemainder(3,  2); //returns -1
var val = 3 % 2 // val is 1```

### ReciprocalEstimate, ReciprocalSqrtEstimate

This method returns an estimate of the reciprocal of a specified `double` or the reciprocal square root of a given value:

```Math.ReciprocalEstimate(2.0);// returns 0.5
Math.ReciprocalSqrtEstimate(4.0); // returns 1/(sqrt(4)) = 1/2 = 0.5```

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.

### Sign

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:
`Math.Sign(-5.0); // returns -1`

The input can be a double, int, float, decimal, long, nint, sbyte, or short. The output is always an int.

### Sqrt

Returns the square root of a given double. When it is negative, it returns `double.NaN`:
`Math.Sqrt(4.0); // returns 2`

## Exponential and Logarithmic Functions

The Math class in C# provides lots of methods to work with exponentials and logarithms.

### Exp

Returns the mathematical constant `e` raised to the given power:
`Math.Exp(1); // returns 2.71..`

The input and output are double.

### ILogB

This method returns the base 2 integer logarithm of a specified double number, i.e. (int)log2(val):
`Math.ILogB(9.0); // returns 3`

### Log

Returns the natural logarithm of a given double value. When the given value is 0, it returns `double.NegativeInfinity` and for negative values, it returns `double.NaN`. You can also specify an optional argument to use another base:

```Math.Log(Math.Exp(4.0));//returns 4
Math.Log(100, 10); // returns 2```

### Log10, Log2

Returns the 10 log resp. 2 log of a given double value. When the given value is 0, it returns `double.NegativeInfinity`, and for negative values, it returns `double.NaN`:

```Math.Log10(1000); // returns 3
Math.Log2(16); // returns 4```

### Pow

Returns a specified number raised to another specified number. Both input and output are doubles:
`Math.Pow(3.0, 3.0); // returns 3^3 = 27`

### ScaleB

Returns x*2^n, where x is a double and n is an integer. This can be done efficiently:
`Math.ScaleB(3.0, 2); // returns 3.0*4 = 12`

## Trigonometric Functions

All the common (and less common) trigonometric methods are available in the `Math` class as well:

### Sin, Cos, Tan

These methods return the sine, cosine, or tangent resp. of a given double angle, measures in radians:

```Math.Sin(Math.PI); // returns 0
Math.Cos(Math.PI); // returns -1
Math.Tan(Math.PI); // returns 0```

### Asin, Acos, Atan

These are the inverse sine, cosine, and tangent.

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

The Acos returns a value in the range 0 till PI.

The Atan returns a value in the range -0.5PI till 0.5PI. If the given value is `double.PositiveInfinity`, it returns `0.5*Math.PI` rounded to the nearest double:

```Math.Asin(1); // returns Math.PI*0.5
Math.Acos(0); // returns Math.PI
Math.Atan(double.PositiveInfinity); // returns 1.5707...```

### Sinh, Cosh, Tanh

These methods return the hyperbolic sine, cosine, and tangent of a given double value:

```Math.Sinh(0); // returns 0
Math.Cosh(0.0); // returns 1
Math.Tanh(0.0); //returns 0```

### Asinh, Acosh, Atanh

These methods return the inverse hyperbolic sine, cosine, and tangent of a given double value:

```Math.Asinh(0.0); // returns 0
Math.Acosh(1.0); // returns 0
Math.Atanh(0.0); // returns 0```

## Rounding and Related Functions

There are several different rounding related methods, which we organized under this section:

### Ceiling

Returns the smallest integral value that is greater than or equal to the specified number. The input and output can be double or decimal:

```Math.Ceiling(3.001); // returns 4
Math.Ceiling(1.0); // returns 1```

### Clamp

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:

```Math.Clamp(0.0, -1.0, 2.0); // returns 0
Math.Clamp(-10.0, -1.0, 2.0); // returns -1
Math.Clamp(10.0, -1.0, 2.0); // returns 2```

### Floor

Returns the largest integral value that is smaller than or equal to the specified number. The input and output can be double or decimal:

```Math.Floor(1.0); // returns 1
Math.Floor(1.3); // returns 1
Math.Floor(1.999); // returns 1```

### Round

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:

```Math.Round(1.49); // returns 1
Math.Round(1.49, 1); // returns 1.5```

### Truncate

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:

```Math.Truncate(-2.2); // returns -2
Math.Truncate(2.2); // returns 2```

## Fields

There are several important mathematical constants that are represented as fields in the Math class in C#.

### PI

The mathematical constant Pi (π):
`public const double PI = 3.1415926535897931;`

### E

The mathematical constant e, i.e. the base of the natural logarithm:
`public const double E = 2.7182818284590451;`

### Tau

This constant equals 2π. It has recently been introduced (since .NET 5):
`public const double Tau = 6.2831853071795862;`

## Conclusion

We’ve seen that there are lots of mathematical methods in the Math class in C#, which can help you a lot if you are writing mathematical or scientific software.

This content is available exclusively to members of Code's Patreon at \$0 or more.