# Lesson 12 - Mathematical functions in C++ - The cmath library

In today's lesson of the C++ basics course, we're going to take a look at the
`cmath`

standard library. It provides a variety of functions for
solving common math problems, we're going to mention the most important of them
all.

`fmin()`

, `fmax()`

, `fdim()`

Let's start with the simple functions All 3 functions take two numbers of the `double`

data
type as parameters. `Fmin()`

returns the smallest number,
`fmax()`

returns the largest one. The `fdim()`

function
returns `x-y`

if (`x > y`

) or `0`

otherwise.

`round()`

, `ceil()`

, `floor()`

, and
`trunc()`

All three functions are related to rounding and they all accept a parameter
of the `double`

type. Their return value is also of the
`double`

type. `Round()`

takes a decimal number as a
parameter and returns the number, rounded **as a double data
type**. It rounds in the same way we learned in school (anything over
`0.5`

is rounded upwards, otherwise the number is rounded downwards).
`Ceil()`

rounds upwards and `floor()`

rounds downwards no
matter what. `Trunc()`

cuts the decimal part off and leaves the whole
number part intact (does not round it whatsoever).

We'll certainly be using `round()`

very often. I've used the other
functions for things like determining the number of pages in a table (e.g. of a
table printed to the console). When we have `33`

items and we only
print `10`

items per page, they would take up `3.3`

pages.
Therefore, the result must be rounded up since we would actually need
`4`

pages.

If you think that `floor()`

and `truncate()`

do the
same thing, think again! They behave differently for negative numbers.
`Floor()`

rounds negative numbers down to an even "more negative"
number, `trunc()`

always rounds to zero when the input is
negative.

We round decimal numbers and store them in `int`

variables like
this:

double d = 2.72; int a = (int)round(d);

Casting to `int`

is necessary despite the fact that the
`round()`

method returns a whole number. It is still of the
`double`

type, due to the fact that all mathematical functions have
the same interface. The return types of the following functions won't be
mentioned anymore (since they'll all be `double`

).

`abs()`

and `signbit()`

`Abs()`

returns the absolute value of its parameter and
`signbit()`

returns `1`

if the parameter is negative or
`0`

otherwise. The `signbit()`

function is not supported
by all compilers so it's possible that it won't be available everywhere.

`sin()`

, `cos()`

, `tan()`

Classic trigonometric functions, all take an angle which has to be entered in
radians (not degrees if your country uses them). To convert degrees to radians
we multiply them by `(M_PI / 180)`

.

`acos()`

, `asin()`

, `atan()`

Inverse trigonometric (arcus, sometimes cyclometric) functions, which return
the original angle according to the trigonometric value. They're the inverse
functions for `sin()`

, `cos()`

, and `tan()`

.
The parameter is a function value and the returned value is the original angle
in radians (returned as a `double`

). If we wanted to get an angle in
degrees, we'd have to divide the radians by `(180 / M_PI)`

.

`pow()`

and `sqrt()`

`Pow()`

takes two input parameters. The first is the base of the
power and the second is the exponent. If we wanted to calculate something like
2^{3}, the code would be as follows (don't forget to include the cmath
library for all of the examples):

```
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
cout << pow(2, 3);
return 0;
}
```

`Sqrt()`

is an abbreviation of SQuare RooT, which returns the
square root of the number given as a double.

`exp()`

, `log()`

, `log10()`

`Exp()`

returns Euler's number raised to the given exponent.
`Log()`

returns the natural logarithm of the given number.
`Log10()`

returns the decadic logarithm of the number.

Hopefully, you noticed that the method list lacks any general root function. We can, however, calculate it using the functions the cmath library provides.

We know that roots work like this: 3rd root of `8 = 8^(1/3)`

.
Therefore, we can write:

```
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
cout << pow(8, (1.0/3.0));
return 0;
}
```

It is very important to write at least one number with a decimal point when
we are dividing, otherwise, C++ will assume that we want it to apply
whole-number division, and the result would have been `8 ^ 0 = 1`

in
this case.

## Division

Programming languages often differ in how they perform the division of numbers. You need to be aware of these issues to avoid being, unpleasantly, surprised afterwards. Let's write a simple program:

```
{CPP_CONSOLE}
int a = 5 / 2;
double b = 5 / 2;
double c = 5.0 / 2;
double d = 5 / 2.0;
double e = 5.0 / 2.0;
int f = 5 / 2.0;
cout << "a=" << a << " b=" << b << " c=" << c << " d=" << d << " e=" << e << " f=" << f << endl;
{/CPP_CONSOLE}
```

We divide `5/2`

several times in the code. Mathematically, it's
`2.5`

. Nonetheless, the results will not be the same in all cases.
Can you guess what we'll get in each case? Go ahead, give it a try

The program output will be as follows:

Console application a=2 b=2 c=2.5 d=2.5 e=2.5 f=2

We see the result of this division is sometimes decimal and sometimes whole. The data type of the variable we're assigning the result to is not all that matters. What matters most is the data type of the numbers we divide by. If one of the numbers is decimal, the outcome will always be a decimal number. The division of 2 integers always returns an integer. Keep in mind that if you compute the average and want a decimal result, at least one variable must be cast to double.

int sum = 10; int count = 4; double average = (double)sum / (double)count;

*Note: For example, the PHP language always returns the decimal result for
a division. When you divide in different programming languages make sure you
check how division works internally before you use it.*

### The remainder after division

In our applications, we often need the remainder after dividing integers
(i.e. modulo). In our example `5/2`

, the integer result is
`2`

and the modulo is `1`

(what left over). Modulo is
often used to determine whether a number is even (the remainder of a division by
`2`

is `0`

). You would also use it, for example, to draw a
checkerboard and fill in the fields based on whether they are even or odd,
calculate the deviance of your position in a square grid, etc.

In C++ and C-like languages in general, modulo is a percent sign, i.e.
`%`

:

```
{CPP_CONSOLE}
cout << "The remainder after 5 / 2 is " << 5 % 2 << endl; // prints 1
{/CPP_CONSOLE}
```

We're done for today. In the next lesson, Functions in the C++ language, we'll introduce declaring custom functions, which is very important since doing so allows us to split our program up into multiple logical parts.

**Comments**

No one has commented yet - be the first!