# Common operators¶

After having explained how mp++’s type coercion works, we can now move on to describe how mp++’s classes can be used to perform mathematical computations.

All of mp++’s multiprecision classes support the four basic arithmetic operations (\(+\), \(-\), \(\times\) and \(\div\)) via overloaded binary operators:

```
auto r1 = int_t{4} + int_t{3};
assert(r1 == 7);
auto r2 = rat_t{4, 3} - rat_t{2, 5};
assert(r2 == rat_t{14, 15});
auto r3 = real128{5} * real128{2};
assert(r3 == 10.);
auto r4 = real{5} / real{2};
assert(r4 == 2.5);
```

It is of course possible to mix operands of different types, and the type of the result will be determined by the type coercion rules explained earlier:

```
auto r1 = int_t{4} + 3; // r1 will be of type int_t.
assert(r1 == 7);
auto r2 = -0.75 + rat_t{1, 2}; // r2 will be of type double.
assert(r2 == -.25);
auto r3 = real128{5} * 2; // r3 will be of type real128.
assert(r3 == 10.);
auto r4 = real{5} / int_t{2}; // r4 will be of type real.
assert(r4 == 2.5);
```

The behaviour of the division operator varies depending on the types involved. If only
integral types are involved, division truncates, and division by zero throws
a `zero_division_error`

exception:

```
auto r1 = int_t{5} / 2; // Integral division truncates.
assert(r1 == 2);
int_t{1} / 0; // This will throw a zero_division_error exception.
```

If floating-point types are involved, division by zero is allowed and results in infinity:

```
auto r1 = real128{1} / 0; // Floating-point division by zero generates an infinity.
assert(isinf(r1))
```

Rational division is always exact, unless the divisor is zero:

```
auto r1 = rat_t{3} / 4;
assert(r1 == rat_t{3, 4});
rat_t{2} / 0; // This will throw a zero_division_error exception.
```

The in-place versions of the binary operators are available as well. Given a binary operator, its corresponding in-place counterpart behaves as a binary operation followed by assignment:

```
int_t r1{4};
r1 += 5; // Equivalent to: r1 = r1 + 5
assert(r1 == 9);
rat_t r2{4, 3};
r2 -= 1.5; // Equivalent to: r2 = r2 - 1.5
assert(r2 == rat_t{-1, 6});
real128 r3{5};
r3 *= rat_t{1, 2}; // Equivalent to: r3 = r3 * rat_t{1, 2}
assert(r3 == 2.5);
real r4{42};
r4 /= real128{0}; // Equivalent to: r4 = r4 / real128{0}
assert(isinf(r4));
```

It is also possible to use fundamental C++ types on the left-hand side of in-place operators:

```
int n = 5;
n += int_t{5};
assert(n == 10);
n -= rat_t{3, 4}
assert(n == 9);
double x = 1.5;
x *= real128{2};
assert(x == 3.);
x /= real{3};
assert(x == 1.);
```

The identity, negation, pre/post increment/decrement operators are also supported for all of mp++’s multiprecision classes:

```
int_t n;
assert(++n == 1);
n++;
assert(n == 2);
assert(--n == 1);
n--;
assert(n == 0);
rat_t q{1, 2};
assert(+q == q);
assert(-q == rat_t{-1, 2});
```

All of mp++’s multiprecision classes are contextually convertible to `bool`

, following the usual rule
that nonzero values convert to `true`

and zero values convert to `false`

:

```
int_t n{3};
if (n) {
std::cout << "n is nonzero!\n";
}
rat_t q{0};
if (!q) {
std::cout << "q is zero!\n";
}
real r{1.23};
if (!!r) {
std::cout << "r is nonzero!\n";
}
```

In addition to the common arithmetic operators, all of mp++’s multiprecision classes support the relational operators \(=\), \(\neq\), \(>\), \(\geq\), \(<\) and \(\leq\). Any combination of multiprecision and numerical C++ types is supported:

```
assert(int_t{42} == 42);
assert(3 != rat_t{1, 3});
assert(0.9 < int_t{1});
assert(real128{15} <= int_t{15});
assert(real{"inf", 100} > rat_t{123, 456});
assert(int_t{4} >= rat_t{16, 4});
```

The comparison operators treat NaN values in the standard way: comparing NaN to any other value returns always
`false`

, apart from the \(\neq\) operator which always returns `true`

when NaN is involved. For the floating-point multiprecision
classes, custom comparison functions with special NaN handling are also available (e.g., `real_lt()`

,
`real128_equal_to()`

, etc.). These functions can be used as replacements for the comparison operators
in facilities of the standard library such as `std::sort()`

, `std::set`

, etc.