GNU Multiple Precision Arithmetic Library

https://gmplib.org/manual/
Admin
GNU MP is a portable C library for arbitrary precision arithmetic on integers, rational numbers, and...
Tokens:128,040
Snippets:1,400
Trust Score:9.4
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install GMP

Source: https://gmplib.org/manual/Installing-GMP.html

Run this command to install GMP after successful configuration and testing. By default, it installs under /usr/local.

```bash
make install

```

--------------------------------

### Configure and Build GMP

Source: https://gmplib.org/manual/Installing-GMP.html

Use this snippet to configure and build GMP from source on a Unix-like system. This is the standard first step for installation.

```bash
./configure
make

```

--------------------------------

### Example: Get Current Free Function

Source: https://gmplib.org/manual/Custom-Allocation

This example demonstrates how to retrieve only the current free function pointer using `mp_get_memory_functions`.

```c
void (*freefunc) (void *, size_t);

mp_get_memory_functions (NULL, NULL, &freefunc);
```

--------------------------------

### Basic mpz_class Arithmetic Example

Source: https://gmplib.org/manual/C_002b_002b-Interface-General

Demonstrates basic arithmetic operations (addition, absolute value) with the mpz_class type. Shows initialization, assignment, and outputting results.

```cpp
int
main (void)
{
  mpz_class a, b, c;

  a = 1234;
  b = "-5678";
  c = a+b;
  cout << "sum is " << c << "\n";
  cout << "absolute value is " << abs(c) << "\n";

  return 0;
}

```

--------------------------------

### Configure GMP for cross-compiling ABI=64 on Solaris

Source: https://gmplib.org/manual/ABI-and-ISA

Example configuration command for building GMP with ABI=64 on Solaris 2.7 when the kernel is in 32-bit mode, to overcome build rejections.

```bash
./configure --build=none --host=sparcv9-sun-solaris2.7 ABI=64
```

--------------------------------

### Configure for Cross-Compilation

Source: https://gmplib.org/manual/Build-Options

When cross-compiling, use --build to specify the system where compilation occurs and --host to specify the system where the library will run. This example shows building for GNU/Linux m68k on a FreeBSD Athlon system.

```bash
./configure --build=athlon-pc-freebsd3.5 --host=m68k-mac-linux-gnu
```

--------------------------------

### Create GMP Import Library with MS lib

Source: https://gmplib.org/manual/Notes-for-Particular-Systems

Libtool does not install a .lib format import library for MINGW DLL builds. This command creates it using Microsoft's 'lib' tool.

```bash
cd .libs
lib /def:libgmp-3.dll.def /out:libgmp-3.lib
```

--------------------------------

### Include GMP Header with stdio.h

Source: https://gmplib.org/manual/Headers-and-Libraries.html

Include GMP header after stdio.h to get prototypes for functions using FILE*.

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

```

--------------------------------

### Check for GMP Library

Source: https://gmplib.org/manual/Autoconf.html

Use AC_CHECK_LIB to verify if the GMP library is installed. This snippet uses default actions for found or not found scenarios.

```autoconf
AC_CHECK_LIB(gmp, __gmpz_init)

```

--------------------------------

### Example C++ Formatted Output

Source: https://gmplib.org/manual/C_002b_002b-Formatted-Output

Demonstrates the typical usage of GMP type output operators within a C++ program. Note that only stream operators are overloaded for these types.

```cpp
mpz_t  z;
int    n;
...
cout << "iteration " << n << " value " << z << "\n";


```

--------------------------------

### Build and Run pexpr Demonstration

Source: https://gmplib.org/manual/Demonstration-Programs.html

This snippet shows how to build the 'pexpr' demonstration program using 'make' and then execute it with a sample expression.

```bash
make pexpr
./pexpr 68^975+10
```

--------------------------------

### Getting Double Representation of mpq_class

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Converts an mpq_class to a double-precision floating-point number.

```cpp
double mpq_class::get_d (void);
```

--------------------------------

### Constructing mpq_class Objects

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Demonstrates various ways to construct mpq_class objects, including from single values, fractions, and explicit conversions.

```cpp
mpq_class q (99);
mpq_class q (1.75);
mpq_class q (1, 3);
```

--------------------------------

### Absolute Value and Sign

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Functions to get the absolute value and sign of an `mpq_class` object.

```APIDOC
## Absolute Value and Sign

### Description
Provides functions to determine the absolute value and the sign of a rational number.

### Functions

- **mpq_class abs(mpq_class op)**: Returns the absolute value of `op`.
- **int sgn(mpq_class op)**: Returns the sign of `op` (-1 for negative, 0 for zero, 1 for positive).
```

--------------------------------

### Getting String Representation of mpq_class

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Converts an mpq_class to its string representation in a specified base.

```cpp
string mpq_class::get_str (int base = 10);
```

--------------------------------

### Build DLL on Windows (Cygwin, MinGW, PW32)

Source: https://gmplib.org/manual/Notes-for-Particular-Systems

By default, GMP builds only a static library on Windows systems. Use this configuration to build a DLL instead.

```bash
./configure --disable-static --enable-shared
```

--------------------------------

### Initialize mpf_t variables

Source: https://gmplib.org/manual/Initializing-Floats

Demonstrates initializing mpf_t variables using default and specified precision. Remember to clear variables when done.

```c
{
  mpf_t x, y;
  mpf_init (x);           /* use default precision */
  mpf_init2 (y, 256);     /* precision _at least_ 256 bits */
  …
  /* Unless the program is about to exit, do ... */
  mpf_clear (x);
  mpf_clear (y);
}
```

--------------------------------

### Accessing Numerator and Denominator

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Provides methods to get references to the numerator and denominator of an `mpq_class` object.

```APIDOC
## Accessing Numerator and Denominator

### Description
Allows read and write access to the numerator and denominator of an `mpq_class` object.

### Methods

- **mpz_class& mpq_class::get_num()**: Returns a reference to the numerator (`mpz_class`).
- **mpz_class& mpq_class::get_den()**: Returns a reference to the denominator (`mpz_class`).

**Important**: If direct manipulation of the returned `mpz_class` results in a non-canonical form, `mpq_class::canonicalize()` must be called afterward.
```

--------------------------------

### Get mpz_class as string

Source: https://gmplib.org/manual/C_002b_002b-Interface-Integers

Converts an mpz_class to its string representation in a specified base. Defaults to base 10.

```cpp
string mpz_class::get_str(int base = 10);
```

--------------------------------

### Getting Sign of mpq_class

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Returns the sign of an mpq_class: -1 for negative, 0 for zero, 1 for positive.

```cpp
int sgn (mpq_class op);
```

--------------------------------

### Declaring Random State (gmp_randstate_t)

Source: https://gmplib.org/manual/Nomenclature-and-Types.html

Example of declaring a variable of type gmp_randstate_t for random number generation state.

```c
gmp_randstate_t rstate;

```

--------------------------------

### Initialize with Linear Congruential Algorithm (Size-Based)

Source: https://gmplib.org/manual/Random-State-Initialization

Use `gmp_randinit_lc_2exp_size` to initialize a linear congruential algorithm where parameters are chosen based on the desired output size. Returns non-zero on success, zero if the requested size is too large (max 128 bits).

```c
int gmp_randinit_lc_2exp_size (gmp_randstate_t state, mp_bitcnt_t size);
```

--------------------------------

### Declaring Multiple Precision Integers (mpz_t)

Source: https://gmplib.org/manual/Nomenclature-and-Types.html

Examples of how to declare variables of type mpz_t for multiple precision integers.

```c
mpz_t sum;

struct foo { mpz_t x, y; };

mpz_t vec[20];

```

--------------------------------

### Initialize with Linear Congruential Algorithm

Source: https://gmplib.org/manual/Random-State-Initialization

Use `gmp_randinit_lc_2exp` to initialize with a linear congruential algorithm. Note that the low bits of X are not very random and only the high half is used. Multiple iterations are used for generating numbers larger than m2exp/2.

```c
void gmp_randinit_lc_2exp (gmp_randstate_t state, const mpz_t a, unsigned long c, mp_bitcnt_t m2exp);
```

--------------------------------

### Get Denominator of mpq_t

Source: https://gmplib.org/manual/Applying-Integer-Functions

Copies the denominator of a rational number into a given `mpz_t`. Direct use of `mpq_denref` is recommended instead.

```c
void mpq_get_den (mpz_t denominator, const mpq_t rational)
```

--------------------------------

### Initialize with Default Algorithm

Source: https://gmplib.org/manual/Random-State-Initialization

Use `gmp_randinit_default` for applications with no special requirements, as it provides a balance between speed and randomness. It currently defaults to the Mersenne Twister algorithm.

```c
void gmp_randinit_default (gmp_randstate_t state);
```

--------------------------------

### Enable Fat Binary Build on x86

Source: https://gmplib.org/manual/Build-Options

Enable a 'fat binary' build on x86 architectures. This includes optimized low-level subroutines that are chosen at runtime based on the detected CPU, offering good performance across different x86 chips.

```bash
--enable-fat
```

--------------------------------

### Get Numerator of mpq_t

Source: https://gmplib.org/manual/Applying-Integer-Functions

Copies the numerator of a rational number into a given `mpz_t`. Direct use of `mpq_numref` is recommended instead.

```c
void mpq_get_num (mpz_t numerator, const mpq_t rational)
```

--------------------------------

### Get mpf_class Precision

Source: https://gmplib.org/manual/C_002b_002b-Interface-Floats

Retrieves the current precision of an mpf_class object. This function is part of the C++ interface for GMP floats.

```cpp
mp_bitcnt_t mpf_class::get_prec ()

```

--------------------------------

### Initialize with Mersenne Twister Algorithm

Source: https://gmplib.org/manual/Random-State-Initialization

Use `gmp_randinit_mt` to initialize the state with the Mersenne Twister algorithm, known for its speed and good randomness properties.

```c
void gmp_randinit_mt (gmp_randstate_t state);
```

--------------------------------

### Constructing Rationals with C++11 User-Defined Literals

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Shows how to construct integral and fractional rationals using C++11 user-defined literals for convenience.

```cpp
mpq_class q = 123_mpq;
mpq_class r = -1_mpq/2;
mpq_class s = 0xb_mpq/123456_mpz;
```

--------------------------------

### Specify Build System for Native Compilation

Source: https://gmplib.org/manual/Build-Options

Use the --build option to explicitly define the system for native compilation. This is often determined automatically by './config.guess', but can be specified for clarity or when auto-detection fails.

```bash
./configure --build=ultrasparc-sun-solaris2.7
```

--------------------------------

### Accessing Underlying mpz_t Numerator and Denominator

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Provides methods to get references to the underlying `mpz_t` numerator and denominator for C compatibility.

```APIDOC
## Accessing Underlying mpz_t Numerator and Denominator

### Description
Provides access to the raw `mpz_t` types representing the numerator and denominator, useful for interfacing with C functions.

### Methods

- **mpz_t mpq_class::get_num_mpz_t()**: Returns a reference to the underlying `mpz_t` numerator.
- **mpz_t mpq_class::get_den_mpz_t()**: Returns a reference to the underlying `mpz_t` denominator.

**Important**: Modifications to the returned `mpz_t` will affect the original `mpq_class`. If direct manipulation might produce a non-canonical value, `mpq_class::canonicalize()` must be called subsequently.
```

--------------------------------

### Run GMP tuneup program

Source: https://gmplib.org/manual/Performance-optimization.html

Execute the `tuneup` program from the `tune` subdirectory to generate optimized parameters for GMP. This is particularly important for long-running applications and those demanding extremely large numbers.

```bash
cd tune
make tuneup
./tuneup

```

--------------------------------

### Declaring Multiple Precision Rational Numbers (mpq_t)

Source: https://gmplib.org/manual/Nomenclature-and-Types.html

Example of declaring a variable of type mpq_t for multiple precision rational numbers (fractions).

```c
mpq_t quotient;

```

--------------------------------

### Get Current Memory Allocation Functions

Source: https://gmplib.org/manual/Custom-Allocation

Retrieve the current memory allocation functions used by GMP. Pass NULL for arguments you are not interested in.

```c
void mp_get_memory_functions (void *(**alloc_func_ptr) (size_t), void *(**realloc_func_ptr) (void *, size_t, size_t), void (**free_func_ptr) (void *, size_t))
```

--------------------------------

### Direct mpq_t Operations using Numerator and Denominator References

Source: https://gmplib.org/manual/Efficiency

Demonstrates how to perform arithmetic operations directly on the numerator and denominator of an mpq_t value using mpz_add, mpz_addmul_ui, and mpz_submul. This can be faster than using standard mpq_add for certain operations.

```c
/* mpq increment */
mpz_add (mpq_numref(q), mpq_numref(q), mpq_denref(q));

/* mpq += unsigned long */
mpz_addmul_ui (mpq_numref(q), mpq_denref(q), 123UL);

/* mpq -= mpz */
mpz_submul (mpq_numref(q), mpq_denref(q), z);
```

--------------------------------

### Initialize by Copying State

Source: https://gmplib.org/manual/Random-State-Initialization

Use `gmp_randinit_set` to initialize a new random state by copying the algorithm and current state from an existing one.

```c
void gmp_randinit_set (gmp_randstate_t rop, gmp_randstate_t op);
```

--------------------------------

### Declaring Arbitrary Precision Floating Point Numbers (mpf_t)

Source: https://gmplib.org/manual/Nomenclature-and-Types.html

Example of declaring a variable of type mpf_t for arbitrary precision floating point numbers.

```c
mpf_t fp;

```

--------------------------------

### mpq_inits

Source: https://gmplib.org/manual/Initializing-Rationals

Initializes a NULL-terminated list of rational number variables, setting each to 0/1.

```APIDOC
## mpq_inits

### Description
Initializes a NULL-terminated list of `mpq_t` variables, and sets their values to 0/1.

### Function Signature
`void mpq_inits(mpq_t x, ...)`
```

--------------------------------

### Get Denominator Reference of mpq_t

Source: https://gmplib.org/manual/Applying-Integer-Functions

Returns a reference to the denominator of an `mpq_t`. Integer functions can be used on the result, but care must be taken to maintain the canonical form.

```c
mpz_ptr mpq_denref (const mpq_t op)
```

--------------------------------

### mpq_init

Source: https://gmplib.org/manual/Initializing-Rationals

Initializes a rational number variable `x` and sets its value to 0/1. Each variable should be initialized once or cleared before re-initialization.

```APIDOC
## mpq_init

### Description
Initializes `x` to 0/1. Each variable should normally only be initialized once, or at least cleared out between initializations.

### Function Signature
`void mpq_init(mpq_t x)`
```

--------------------------------

### Get Numerator Reference of mpq_t

Source: https://gmplib.org/manual/Applying-Integer-Functions

Returns a reference to the numerator of an `mpq_t`. Integer functions can be used on the result, but care must be taken to maintain the canonical form.

```c
mpz_ptr mpq_numref (const mpq_t op)
```

--------------------------------

### Diagram: 16x32-bit Products for mpn_mul_1/mpn_addmul_1

Source: https://gmplib.org/manual/Assembly-Floating-Point.html

Illustrates the breakdown of operands V and U and the generation of partial products for multiplication routines on a 64-bit limb. This is relevant for understanding the intermediate steps in floating-point assisted multiplication.

```text
                +---+---+---+---+
                |v48|v32|v16|v00|    V operand
                +---+---+---+---+

                +-------+---+---+
            x   |  u32  |  u00  |    U operand (one limb)
                +---------------+ 

--------------------------------- 

                    +-----------+
                    | u00 x v00 |    p00    48-bit products
                    +-----------+
                +-----------+
                | u00 x v16 |        p16
                +-----------+
            +-----------+
            | u00 x v32 |            p32
            +-----------+
        +-----------+
        | u00 x v48 |                p48
        +-----------+
            +-----------+
            | u32 x v00 |            r32
            +-----------+
        +-----------+
        | u32 x v16 |                r48
        +-----------+
    +-----------+
    | u32 x v32 |                    r64
    +-----------+
+-----------+
| u32 x v48 |                        r80
+-----------+
```

--------------------------------

### Initialize and Use mpz_t Variable

Source: https://gmplib.org/manual/Initializing-Integers

Demonstrates the basic pattern of initializing an mpz_t variable, performing operations, and then clearing it. Always clear mpz_t variables when done to free memory.

```c
mpz_t integ;
mpz_init (integ);

  …

mpz_add (integ, …);
  …
mpz_sub (integ, …);

  /* Unless the program is about to exit, do ... */
mpz_clear (integ);
```

--------------------------------

### mpn_scan1

Source: https://gmplib.org/manual/Low_002dlevel-Functions

Scans a limb array from a specified bit position to find the next set bit. It is guaranteed that a set bit exists at or beyond the starting position.

```APIDOC
## mpn_scan1

### Description
Scans a limb array from a specified bit position to find the next set bit. It is guaranteed that a set bit exists at or beyond the starting position.

### Function Signature
`mp_bitcnt_t mpn_scan1(const mp_limb_t *s1p, mp_bitcnt_t bit)`

### Parameters
* **s1p** (`const mp_limb_t *`) - Pointer to the limb array.
* **bit** (`mp_bitcnt_t`) - The starting bit position for the scan.

### Return Value
* **mp_bitcnt_t** - The position of the next set bit.
```

--------------------------------

### mpn_scan0

Source: https://gmplib.org/manual/Low_002dlevel-Functions

Scans a limb array from a specified bit position to find the next clear bit. It is guaranteed that a clear bit exists at or beyond the starting position.

```APIDOC
## mpn_scan0

### Description
Scans a limb array from a specified bit position to find the next clear bit. It is guaranteed that a clear bit exists at or beyond the starting position.

### Function Signature
`mp_bitcnt_t mpn_scan0(const mp_limb_t *s1p, mp_bitcnt_t bit)`

### Parameters
* **s1p** (`const mp_limb_t *`) - Pointer to the limb array.
* **bit** (`mp_bitcnt_t`) - The starting bit position for the scan.

### Return Value
* **mp_bitcnt_t** - The position of the next clear bit.
```

--------------------------------

### Compile application for 64-bit ABI on AMD64

Source: https://gmplib.org/manual/ABI-and-ISA

When using the 64-bit ABI on AMD64 systems, applications should typically be compiled with the -m64 flag for optimal performance and full utilization of the architecture.

```bash
gcc -m64
```

--------------------------------

### Enable C++ Support

Source: https://gmplib.org/manual/Build-Options

Enable C++ support in GMP using '--enable-cxx'. Alternatively, use '--enable-cxx=detect' to enable it only if a C++ compiler is found. This provides the libgmpxx.la library and gmpxx.h header.

```bash
--enable-cxx
```

```bash
--enable-cxx=detect
```

--------------------------------

### Initialize GMP Integer using MPZ_ROINIT_N Macro

Source: https://gmplib.org/manual/Integer-Special-Functions

Illustrates initializing an mpz_t integer using the MPZ_ROINIT_N macro for constant values. The limb array must be normalized and non-zero if the size is non-zero.

```c
void foo (mpz_t x)
{
  static const mp_limb_t ya[3] = { 0x1, 0x2, 0x3 };
  static const mpz_t y = MPZ_ROINIT_N ((mp_limb_t *) ya, 3);

  mpz_add (x, x, y);
}

```

--------------------------------

### Get Sign of mpz_t Integer

Source: https://gmplib.org/manual/Integer-Comparisons

Returns +1 if the integer is positive, 0 if it is zero, and -1 if it is negative. This function is implemented as a macro and evaluates its argument multiple times.

```c
int mpz_sgn (const mpz_t op);
```

--------------------------------

### External Heap Debugging Tools

Source: https://gmplib.org/manual/Debugging

These are external tools that can be used to debug heap corruption issues in GMP applications. Ensure you have the necessary libraries or stubs installed for them to function correctly.

```text
http://cs.ecs.baylor.edu/~donahoo/tools/ccmalloc/
```

```text
http://dmalloc.com/
```

```text
https://wiki.gnome.org/Apps/MemProf
```

--------------------------------

### gmp_randinit_lc_2exp

Source: https://gmplib.org/manual/Random-State-Initialization

Initializes the random state using a linear congruential algorithm with the formula X = (a*X + c) mod 2^m2exp. Note that the low bits of X are not very random.

```APIDOC
## gmp_randinit_lc_2exp

### Description
Initializes state with a linear congruential algorithm _X = ( a*X + c) mod 2^m2exp_. The low bits of _X_ in this algorithm are not very random. The least significant bit will have a period no more than 2, and the second bit no more than 4, etc. For this reason only the high half of each _X_ is actually used. When a random number of more than _m2exp /2_ bits is to be generated, multiple iterations of the recurrence are used and the results concatenated.

### Function Signature
`void gmp_randinit_lc_2exp(gmp_randstate_t state, const mpz_t a, unsigned long c, mp_bitcnt_t m2exp)`
```

--------------------------------

### Constructing gmp_randclass with randinit functions

Source: https://gmplib.org/manual/C_002b_002b-Interface-Random-Numbers

Demonstrates various ways to construct a gmp_randclass object using different GMP random number initialization functions. Choose the constructor that matches the desired initialization function and its arguments.

```cpp
gmp_randclass r1 (gmp_randinit_default);
gmp_randclass r2 (gmp_randinit_lc_2exp_size, 32);
gmp_randclass r3 (gmp_randinit_lc_2exp, a, c, m2exp);
gmp_randclass r4 (gmp_randinit_mt);
```

--------------------------------

### Accessing Denominator of mpq_class

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Gets a reference to the denominator of an mpq_class as an mpz_class. Modifications to the returned reference affect the original mpq_class. Canonicalize must be called if modifications result in a non-canonical form.

```cpp
mpz_class& mpq_class::get_den ();
```

--------------------------------

### Accessing Numerator of mpq_class

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Gets a reference to the numerator of an mpq_class as an mpz_class. Modifications to the returned reference affect the original mpq_class. Canonicalize must be called if modifications result in a non-canonical form.

```cpp
mpz_class& mpq_class::get_num ();
```

--------------------------------

### Configure Compaq C++ with Standard iostream

Source: https://gmplib.org/manual/Notes-for-Particular-Systems

Compaq C++ on OSF 5.1 requires the standard iostream to be explicitly enabled. This configuration flag ensures GMP uses the correct iostream.

```bash
./configure --enable-cxx CPPFLAGS=-D__USE_STD_IOSTREAM
```

--------------------------------

### Compile PowerPC 64-bit ABI on GNU/Linux, BSD, Mac OS X

Source: https://gmplib.org/manual/ABI-and-ISA

Compile applications for the 64-bit ABI on 64-bit GNU/Linux, BSD, and Mac OS X/Darwin systems.

```bash
gcc  -m64
```

--------------------------------

### Compile application for x32 ABI on AMD64

Source: https://gmplib.org/manual/ABI-and-ISA

The x32 ABI uses 64-bit limbs but 32-bit pointers, leveraging the chip's arithmetic capabilities. Applications require the -mx32 flag. This ABI is not universally supported.

```bash
gcc -mx32
```

--------------------------------

### Get mpz_class as standard types

Source: https://gmplib.org/manual/C_002b_002b-Interface-Integers

Converts an mpz_class to standard C++ types like double, long, and unsigned long. Behavior for values exceeding the target type's range is undefined.

```cpp
double mpz_class::get_d(void);
```

```cpp
long mpz_class::get_si(void);
```

```cpp
unsigned long mpz_class::get_ui(void);
```

--------------------------------

### Obsolete: Initialize Random State

Source: https://gmplib.org/manual/Random-State-Initialization

The `gmp_randinit` function is obsolete and should not be used. It initializes the state with a specified algorithm and size, but has thread-unsafe error reporting. Prefer `gmp_randinit_lc_2exp_size`.

```c
void gmp_randinit (gmp_randstate_t state, gmp_randalg_t alg, ...);
```

--------------------------------

### Accessing Underlying mpz_t Denominator

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Gets a reference to the underlying mpz_t denominator of an mpq_class, suitable for passing to C functions. Modifications affect the original mpq_class. Canonicalize must be called if modifications result in a non-canonical form.

```cpp
mpz_t mpq_class::get_den_mpz_t ();
```

--------------------------------

### Initializing mpz_class from mpz_t

Source: https://gmplib.org/manual/C_002b_002b-Interface-General

Demonstrates initializing an mpz_class object from an existing mpz_t C type. This creates a copy of the value, not an associated object.

```cpp
mpz_t z;
// ... init and calculate z ...
mpz_class x(z);
mpz_class y;
y = mpz_class (z);

```

--------------------------------

### Accessing Underlying mpz_t Numerator

Source: https://gmplib.org/manual/C_002b_002b-Interface-Rationals

Gets a reference to the underlying mpz_t numerator of an mpq_class, suitable for passing to C functions. Modifications affect the original mpq_class. Canonicalize must be called if modifications result in a non-canonical form.

```cpp
mpz_t mpq_class::get_num_mpz_t ();
```

--------------------------------

### GMP Build with GCC Instrument Functions Profiling

Source: https://gmplib.org/manual/Profiling

Enable GCC's '-finstrument-functions' option for exact timing and full call graph construction. This requires support from an external library like libfc, which should be included in LIBS during configuration. On GNU systems, the C library provides dummy functions.

```bash
./configure --enable-profiling=instrument LIBS=-lfc
```

--------------------------------

### Obsolete: Divide and get remainder (limb array by single limb)

Source: https://gmplib.org/manual/Low_002dlevel-Functions

Obsolete function for dividing a limb array by a single limb, returning the remainder. Use mpn_divrem_1 instead. The areas at r1p and s2p must be identical or completely separate.

```c
mp_limb_t mpn_divmod (mp_limb_t *r1p, mp_limb_t *rs2p, mp_size_t rs2n, const mp_limb_t *s3p, mp_size_t s3n)
```

--------------------------------

### Raw Output Format Structure

Source: https://gmplib.org/manual/Raw-Output-Internals.html

Illustrates the structure of the raw output format, showing the 'size' and 'data bytes' fields.

```text
+------+------------------------+
| size |       data bytes       |
+------+------------------------+

```

--------------------------------

### Direct use of GMP division functions

Source: https://gmplib.org/manual/C_002b_002b-Interface-Integers

Demonstrates how to directly call GMP C functions like mpz_fdiv_q for specific division rounding behavior when needed.

```cpp
mpz_class q, a, d;
...
mpz_fdiv_q (q.get_mpz_t(), a.get_mpz_t(), d.get_mpz_t());
```

--------------------------------

### Obsolete: Divide and get remainder (limb array by limb array)

Source: https://gmplib.org/manual/Low_002dlevel-Functions

Obsolete function for dividing a limb array by another limb array, returning the most significant limb of the quotient and storing the remainder. Use mpn_tdiv_qr instead. Requires rs2n >= s3n and the most significant bit of the divisor to be set.

```c
mp_limb_t mpn_divrem (mp_limb_t *r1p, mp_size_t qxn, mp_limb_t *rs2p, mp_size_t rs2n, const mp_limb_t *s3p, mp_size_t s3n)
```

--------------------------------

### mpz_scan1

Source: https://gmplib.org/manual/Integer-Logic-and-Bit-Fiddling

Scans op starting from starting_bit towards more significant bits until the first 1 bit is found. Returns the index of the found bit. If the bit at starting_bit is already 1, starting_bit is returned. If no 1 bit is found (e.g., past the end of a non-negative number), the largest possible mp_bitcnt_t is returned.

```APIDOC
## mpz_scan1

### Description
Scans op for the first 1 bit starting from starting_bit.

### Function Signature
`mp_bitcnt_t mpz_scan1(const mpz_t op, mp_bitcnt_t starting_bit)`

### Parameters
- **op** (const mpz_t) - The operand to scan.
- **starting_bit** (mp_bitcnt_t) - The bit index to start scanning from.

### Return Value
- The index of the first 1 bit found, or the largest possible `mp_bitcnt_t` if no 1 bit is found.
```

--------------------------------

### Compile application for IA-64 64-bit ABI on HP-UX

Source: https://gmplib.org/manual/ABI-and-ISA

The 64-bit ABI on IA-64 under HP-UX uses 64-bit `long`s and pointers, with GMP using a 32-bit `long` for a limb. Applications must be compiled with specific flags.

```bash
gcc -mlp64
cc +DD64
```

--------------------------------

### Compile Sparc V9 with 64-bit ABI on Solaris

Source: https://gmplib.org/manual/ABI-and-ISA

Compile applications with the 64-bit V9 ABI on Solaris systems. Requires GCC 3.2 or higher or Sun cc.

```bash
gcc  -m64 -mptr64 -Wa,-xarch=v9 -mcpu=v9
cc   -xarch=v9
```

--------------------------------

### mpz_scan0

Source: https://gmplib.org/manual/Integer-Logic-and-Bit-Fiddling

Scans op starting from starting_bit towards more significant bits until the first 0 bit is found. Returns the index of the found bit. If the bit at starting_bit is already 0, starting_bit is returned. If no 0 bit is found (e.g., past the end of a negative number), the largest possible mp_bitcnt_t is returned.

```APIDOC
## mpz_scan0

### Description
Scans op for the first 0 bit starting from starting_bit.

### Function Signature
`mp_bitcnt_t mpz_scan0(const mpz_t op, mp_bitcnt_t starting_bit)`

### Parameters
- **op** (const mpz_t) - The operand to scan.
- **starting_bit** (mp_bitcnt_t) - The bit index to start scanning from.

### Return Value
- The index of the first 0 bit found, or the largest possible `mp_bitcnt_t` if no 0 bit is found.
```

--------------------------------

### gmp_randinit_default

Source: https://gmplib.org/manual/Random-State-Initialization

Initializes the random state with a default algorithm, which is a compromise between speed and randomness. Currently defaults to gmp_randinit_mt.

```APIDOC
## gmp_randinit_default

### Description
Initializes the random state with a default algorithm. This will be a compromise between speed and randomness, and is recommended for applications with no special requirements. Currently this is `gmp_randinit_mt`.

### Function Signature
`void gmp_randinit_default(gmp_randstate_t state)`
```
Tokens:
Raw