# Arithmetic

Here are the normal math operators that work on integers and floating point numbers:

`+`

(add)`-`

(subtract; or a negative number, e.g.`int x = -5`

)`*`

(multiply)

Here are somewhat-unique math operators that work with integers:

`/`

(quotient:`13 / 5`

is 2 because 5 goes into 13 two times)`%`

(remainder:`13 % 5`

is 3 because the remainder of 5/13 is 2)

Note that `/`

works as you would expect with floating point numbers
(e.g. `1.2 / 5.6`

is about 0.214).

Precedence works the same as you would expect: `* / %`

happen before `+ -`

so ```
(5 + 6 % 4 - (3 + 4) /
2)
```

equals 4 as you would expect. You can use parentheses to
clarify the math.

## Arithmetic shorthand

You can use the following shorthand for changing the values of variables. The shorthand form is shown, then the equivalent form is described in comments.

```
double a = 0.0;
int x = 0;
x++; // same as: x = x + 1;
++x; // same as: x = x + 1;
x--; // same as: x = x - 1;
--x; // same as: x = x - 1;
x += 2; // same as: x = x + 2;
x -= 2; // same as: x = x - 2;
x *= 2; // same as: x = x * 2;
x /= 2; // same as: x = x / 2;
x %= 2; // same as: x = x % 2;
a += 2.0; // same as: a = a + 2.0;
// etc.
```

What’s the difference between `x++`

and `++x`

(or `x--`

and `--x`

)? An
assignment expression actually has a value. So `x = 5`

turns into the
value 5 (and changes `x`

to equal 5). That makes the following
possible: `y = x = 5`

, which sets `y`

equal to the value `x = 5`

,
which is the value 5.

The difference is that `x++`

gives back the old value of `x`

(but also
increments `x`

), while `++x`

increments `x`

then gives its value. So
if `x`

is 5, and we have `y = x++`

then `y`

is 5 and `x`

is 6. On the
other hand, if we have `y = ++x`

then `y`

is 6 and `x`

is 6.

## Boolean operators

Variables of type `bool`

have the following special operators:

```
bool p = true;
bool q = false;
bool r;
r = !p; // "!" means "not" or "opposite", so r == false
r = p || q; // "||" means "or", so r == true
r = p && q; // "&&" means "and", so r == false
r = q || (!p) // r == false
```

## Mathy example

This example shows use of several mathematical functions and operators.

```
// math example
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
cout << "The reciprocal of 10 is " << 1.0/10.0 << endl;
cout << "The square root of 10 is " << sqrt(10.0) << endl;
cout << "e^(10.0) = " << exp(10.0) << endl;
cout << "The reciprocal of 15 is " << 1.0/15.0 << endl;
cout << "The square root of 15 is " << sqrt(15.0) << endl;
cout << "e^(15.0) = " << exp(15.0) << endl;
return 0; // exit program
}
```

Here is the example again, but this time with a variable `x`

:

```
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double x;
x = 10.0;
cout << "The reciprocal of 10 is " << 1.0/x << endl;
cout << "The square root of 10 is " << sqrt(x) << endl;
cout << "e^(" << x << ") = " << exp(x) << endl;
x = 15.0;
cout << "The reciprocal of 15 is " << 1.0/x << endl;
cout << "The square root of 15 is " << sqrt(x) << endl;
cout << "e^(" << x << ") = " << exp(x) << endl;
return 0; // exit program
}
```

In these examples, various useful math functions were used. Here is a larger list. These all come from `cmath`

(which must be “included”).

`pow(a, b)`

— raise`a`

to the power`b`

;`a`

and`b`

should have type`double`

`exp(a)`

— raise Euler’s number*e*to the power`a`

(a`double`

)`log(a)`

— find the natural logarithm of`a`

(a`double`

)`log10(a)`

— find the “base 10” logarithm of`a`

`sqrt(a)`

— find the square root of`a`

(a`double`

)`sin(a)`

— the result of*sine(a)*(`a`

is a`double`

, in radians)`cos(a)`

,`tan(a)`

— obvious`acos(a)`

,`asin(a)`

— the arc cosine/sine of`a`

; answer is in radians (`a`

is a`double`

, as is the answer)

## Conversion example

This code converts teaspoons to other units of measurement.

```
#include <iostream>
using namespace std;
int main()
{
int teaspoons;
cout << "Please enter the number of teaspoons: ";
cin >> teaspoons;
int gallons = teaspoons/(3*16*2*8);
teaspoons -= gallons*(3*16*2*8);
int pints = teaspoons/(3*16*2);
teaspoons -= pints*(3*16*2);
int cups = teaspoons/(16*3);
teaspoons -= cups*(16*3);
int tablespoons = teaspoons/3;
teaspoons -= tablespoons*3;
cout << "Number of gallons: " << gallons << endl;
cout << "Number of pints: " << pints << endl;
cout << "Number of cups: " << cups << endl;
cout << "Number of tablespoons: " << tablespoons << endl;
cout << "Number of teaspoons: " << teaspoons << endl;
return 0;
}
```