Nowadays, technologies like Cryptography need computers to compute complex mathematical operations. These algorithms need the CPU to perform arithmetic operations on large numbers with high precision.

The amount of data a processor can execute at once depends on its number of virtual memory addresses. The maximum integer representation a 32-bit processor can work with is 4,294,967,295 (2^32 − 1), while for a 64-bit processor is 18,446,744,073,709,551,615 (2^64 − 1). These bit constraints affect C standard integer and float data types.

Most high-level languages, like Python, allows programmers to work with larger numbers. Allowing programmers to write programs for processing numbers larger than what the CPU can handle. It's possible to write programs for calculating big numbers in C, but it can get very complex and confusing.

GMP, GNU Multiple Precision Arithmetic Library, streamlines the complexity of working with big numbers in C. This article covers how you can use the GMP Library to perform basic mathematical operations on various kinds of numbers.

## Prerequisites

To follow this article, you need to have;

A basic understanding of C,

GCC installed - for compiling C programs,

Basic understanding of GCC,

Access to the internet - for installing GMP, and

A text editor was installed.

## What is GMP?

GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. There is no practical limit to the precision except the ones implied by the available memory in the machine GMP runs on. GMP has a rich set of functions, and the functions have a regular interface. - gmplib.org

GMP allows you to calculate big numbers of many kinds with high precision. It represents numbers in its program as strings.

## Installing GMP

To install the GMP library, you can follow this informative guide. It explains how you can download, configure and build the library on Windows, Mac, and Linux.

## Performing Arithmetical Operations Using GMP

After installing the library, you need to include the GMP header file in your program to use the library for calculations.

### Addition

For adding two integers, you need to declare and initialize the variables in a special way before calculations.

Include GMP library header. This allows you to access the types and macros declared in the header file.

```
#include <gmp.h>
```

Declare and initialize the variables for the result, and the numbers to add together.

```
mpz_t res, num_a, num_b;
/* Initializing integers */
mpz_init(res), mpz_init(num_a), mpz_init(num_b);
```

Initializing the variables using `mpz_init`

function tells GMP to allocate memory space to the variables. Then you can assign any large number to the initialized variables.

The lines below assign `3479349783486297692763769376273723897236`

to `num_a`

and `9223372036854775807`

to `num_b`

. There is no limit to the amount of precision you get when using GMP for calculations.

```
/* Assigning integers */
mpz_set_str(num_a, "3479349783486297692763769376273723897236", 10);
mpz_set_str(num_b, "9223372036854775807", 10);
```

The `mpz_set_str`

function takes the first argument as the variable to assign a value. The second argument is the string representation of the integer you want to assign. The third argument represents the base of the integer (which, in this case, is the second argument). In the above example, the integers are in base 10, meaning decimal numbers.

Now you can add the number together using the `mpz_add`

function from the GMP library. The function sets `res`

to `num_a + num_b`

. Then you can use `gmp_printf`

to print the values. It works like C standard library printf function. The only difference is that `gmp_printf`

allows you to format larger numbers. The `%Zd`

flag in the format string in `gmp_printf`

is to format large integers.

```
/* Addition */
mpz_add(res, num_a, num_b);
gmp_printf("Addition:\n%Zd + %Zd = %Zd\n\n", num_a, num_b, res);
```

Now you need to clear the variables. Clearing the variables frees the memory allocated for the variables.

```
/* Clearing memory */
mpz_clear(res), mpz_clear(num_a), mpz_clear(num_b);
```

The full program should look like this.

```
// main.c
#include <gmp.h>
int main(void)
{
mpz_t res, num_a, num_b;
/* Initializing integers */
mpz_init(res), mpz_init(num_a), mpz_init(num_b);
/* Assigning integers */
mpz_set_str(num_a, "3479349783486297692763769376273723897236", 10);
mpz_set_str(num_b, "9223372036854775807", 10);
/* Addition */
mpz_add(res, num_a, num_b);
gmp_printf("Addition:\n%Zd + %Zd = %Zd\n\n", num_a, num_b, res);
/* Clearing memory */
mpz_clear(res), mpz_clear(num_a), mpz_clear(num_b);
return (0);
}
```

You need to link the GMP library when compiling your program. You can only link the dynamic or static library if you have installed GMP on your machine. If you haven’t, go back to the installation section above.

Run the command below to build your program. The `-lgmp`

flag tells gcc to search for the GMP library when linking. GCC will search the list of standard directories to find the library.

```
gcc main.c -o main -lgmp
```

If it could not find the GMP library on your machine. Try with the build flags below. The `-L~/gmp-6.2.1/.libs`

flag tells gcc to also check the `~/gmp-6.2.1/.libs`

directory if it could not find the library using the standard list. For you, this path is the location you installed GMP.

```
gcc main.c -o main -L~/gmp-6.2.1/.libs -lgmp -static
```

That covers how you can add large numbers in C and build your program.

### Subtraction

You can use the `mpz_sub`

function from the GMP library to subtract large numbers. Ensure you initialize the variables and assign their integers respectively.

This subtracts `num_b`

from `num_a`

and assigns the result to `res`

.

```
/* Subtraction */
mpz_sub(res, num_b, num_a);
gmp_printf("Substraction:\n%Zd - %Zd = %Zd\n\n", num_a, num_b, res);
```

Your full program might look like this.

```
// main.c
#include <gmp.h>
int main(void)
{
mpz_t res, num_a, num_b;
/* Initializing integers */
mpz_init(res), mpz_init(num_a), mpz_init(num_b);
/* Assigning integers */
mpz_set_str(num_a, "3434234245245245252452452452", 10);
mpz_set_str(num_b, "9999943444444434344444444434232323232322", 10);
/* Subtraction */
mpz_sub(res, num_a, num_b);
gmp_printf("Substraction:\n%Zd - %Zd = %Zd\n\n", num_a, num_b, res);
/* Clearing memory */
mpz_clear(res), mpz_clear(num_a), mpz_clear(num_b);
return (0);
}
```

### Multiplication

For multiplying integers, use `mpz_mul`

function from the GMP library.

This multiplies `num_a`

and `num_b`

and assigns results to `res`

.

```
/* Multiplication */
mpz_mul(res, num_a, num_b);
gmp_printf("Multiplication:\n%Zd x %Zd = %Zd\n\n", num_a, num_b, res);
```

### Division

For division, things will look a little different. Instead of using the type `mpz_t`

to declare integers as you have seen before, you will use `mpf_t`

instead to declare floats.

To divide large numbers using GMP you need to declare and initialize floats and not integers.

```
mpf_t div_res, div_a, div_b;
```

Then you initialize the variables using `mpf_init`

.

```
/* Initializing floats */
mpf_init(div_res), mpf_init(div_a), mpf_init(div_b);
```

Assign values you want to the variables. They can be as large as needed. The last argument to `mpf_set_str`

tells GMP that the string is in a decimal format.

```
/* Assign floats */
mpf_set_str(div_a, "7347973477376467734.34322335550000000000", 10);
mpf_set_str(div_b, "489384838948848.4783873847", 10);
```

Divide and print out the results using the functions below. The GMP function `mpf_div`

divides `div_a`

by `div_b`

and assigns the result to `div_res`

. Then prints out the formatted string.

```
/* Division */
mpf_div(div_res, div_a, div_b);
gmp_printf("Division:\n%Ff / %Ff = %Ff\n\n", div_a, div_b, div_res);
```

Your final code should look like this.

```
// main.c
#include <gmp.h>
int main(void)
{
mpf_t div_res, div_a, div_b;
/* Initializing floats */
mpf_init(div_res), mpf_init(div_a), mpf_init(div_b);
/* Assign floats */
mpf_set_str(div_a, "7347973477376467734.34322335550000000000", 10);
mpf_set_str(div_b, "489384838948848.4783873847", 10);
/* Division */
mpf_div(div_res, div_a, div_b);
gmp_printf("Division:\n%Ff / %Ff = %Ff\n\n", div_a, div_b, div_res);
/* Clearing memory */
mpf_clear(div_res), mpf_clear(div_a), mpf_clear(div_b);
return (0);
}
```

### Square root

Ensure you declare and initialize the float variables. Then calculate the square root of that variable using `mpf_sqrt`

function. This function only accepts two arguments. The variable to square root and the variable to assign the result.

```
/* Squre root */
mpf_sqrt(div_res, div_a);
gmp_printf("Square root:\nsqrt(%Ff) = %Ff\n", div_a, div_res);
```

## Conclusion

You can perform other arithmetical operations that are not covered in this article using GMP. Check out the resources section below for their documentation to learn more. It covers how you can perform more Arithmetical operations with Logical and Bitwise operations. Also, you can calculate using C int types and rational numbers.

Use the resources provided below to learn more about working with big numbers in C using the GMP library. If you are looking for a challenge try writing a C function to add two large numbers.

Thanks for reading this article. 😊

## Resources

Linking libraries using GCC Compiler - https://gcc.gnu.org/onlinedocs/gcc/Link-Options.html

Installing GMP from the official website - https://gmplib.org/#DOWNLOAD

Guide to installing GMP on any machine - http://rstudio-pubs-static.s3.amazonaws.com/493124_a46782f9253a4b8193595b6b2a037d58.html