# Aarith’s Philosophy

Aarith is build with the following points in mind:

- Aarith is should easy to use:
e.g. no functions such as

`u_add_32(num_a, num_b)`

, just plain`num_a + num_b`

easily define new number formats, e.g.

`using bfloat16 = floating_point<8, 7, uint64_t>;`

(see [Burgess2019])

- Aarith should allow for easy access to the individual bits of the stored number:
for the design of new hardware units (e.g., implementing arithmetic units such as the FAU Adder [Echavarria2016], see example

for debugging unexpected results

Aarith should be publicly available

## Easy to use

We want Aarith to blend in with `C++`

. That is, we want it to provide the usual operations, such as `+`

or `<<`

.

The following program computes the sum of `1.0`

and `2.0`

using 200 digits using the MPFR
library.

```
#include <stdio.h>
#include <gmp.h>
#include <mpfr.h>
int main (void)
{
unsigned int i;
mpfr_t s, t, u;
mpfr_init2 (t, 200);
mpfr_set_d (t, 1.0, GMP_RNDD);
mpfr_init2 (s, 200);
mpfr_set_d (s, 2.0, GMP_RNDD);
mpfr_init2 (u, 200);
mpfr_add (s, s, u, GMP_RNDD);
printf ("Sum is ");
mpfr_out_str (stdout, 10, 0, s, GMP_RNDD);
putchar ('\n');
mpfr_clear (s);
mpfr_clear (t);
mpfr_clear (u);
return 0;
}
```

The equivalent program using Aarith looks like this (the parameters for the exponent and mantissa width, i.e. `E`

and
`M`

, need to be chosen large enough to fit a 200 digits number):

```
#include <aarith/float.hpp>
#include <aarith/integer.hpp>
int main()
{
floating_point<E,M> x_{1.0F}, y_{2.0F};
std::cout << "Sum is " << (x + y) << "\n";
}
```

## No Surprises!

Aarith performs very little implicit type conversions. Most of the constructors are `explicit`

. Especially,
Aarith does not use `typedef`

’s involving native data types. This is motivated by the following situation.
Consider the following program:

```
uint8_t u8 = 42; uinteger<8> aarith_u8{u8};
std::cout << "uint8_t=" << u8
<< " (as int=" << int{u8} << ")"
<< " aarith::uinteger<8>="
<< aarith_u8 << "\n";
```

Running this program gives the following output:

```
$ ./output_example
uint8_t=* (as int=42) aarith::uinteger<8>=42
```

The asterisk `*`

most likely was not was the user was expecting to see. Such a conversion is never carried
out by Aarith.

## Speed

Aarith is *not* extensively optimized for speed! There are other libraries for that. If raw speed is your
goal, try MPFR and MPIR.