Rust bindings for GMP and MPFR

The `gmp_mpfr` crate uses the GNU Multiple Precision Arithmetic Library (GMP), for integer and rational numbers. The GNU MPFR Library, a library for multiple-precision floating-point computations, is used for floating-point numbers.

To understand the exact operation of the functions in this crate, you can see the online documentation available at the GMP and MPFR pages.

Just like GMP and MPFR, this crate is free software: you can redistribute it and/or modify it under the terms of either

• the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version, or

Basic use

There are three main types defined in this crate:

You can construct these types from primitive data types. The standard arithmetic operators work on these types. Operators can also operate on these types and primitive types; in this case, the result is returned as an arbitrary precision type.

Examples

You can construct arbitrary precision types from primitive types:

```use gmp_mpfr::{Float, FromPrec, Integer, Rational};

// Create an integer initialized as zero.
let int = Integer::new();
// Create a rational number, -22 / 4.
let rat = Rational::from((-22, 4));
// Create floating-point number with 16 bits of precision.
let flo = Float::from_prec(0xff00ff, 16);

assert!(int.to_u32() == 0);
assert!(int == 0);
assert!(rat.numer().to_i32() == -11);
assert!(rat.denom().to_i32() == 2);
assert!(rat.to_f32() == -5.5);
assert!(flo.to_f64() == 0xff0100 as f64);```

Arithmetic operations with mixed arbitrary and primitive types are allowed.

```use gmp_mpfr::Integer;

let mut a = Integer::from(0xc);
a = (a << 80) + 0xffee;
//                                 ^   ^   ^   ^   ^
//                                80  64  48  32  16```

Note that in the above example, there is only one construction. The `Integer` instance is moved into the shift operation so that the result can be stored in the same instance, then that result is similarly consumed by the addition operation.

Structs

 Float A multi-precision floating-point number. The precision has to be set during construction. Integer `Integer` holds an arbitrary-precision integer. Standard arithmetic operations, bitwise operations and comparisons are supported. In standard arithmetic operations such as addition, you can mix `Integer` and primitive integer types; the result will be an `Integer`. MutNumerDenom Used to borrow the numerator and denominator of a `Rational` mutably. The `Rational` number is canonicalized when the borrow ends. See the `Rational::as_mut_numer_denom()` method. Rational An arbitrary-precision rational number.

Enums

 Constant The available floating-point constants. Round The rounding methods for floating-point values. Special Special floating-point values.

Traits

 AddRound Provides addition with a specified rounding method. Assign Assigns to a number from another value. AssignRound Assigns to a number from another value, applying the specified rounding method. DivFromAssign Divide and assign the result to the rhs operand. `rhs.div_from_assign(lhs)` has the same effect as `rhs = lhs / rhs`. DivRound Provides division with a specified rounding method. FromPrec Construct `Self` via a conversion with a specified precision. FromPrecRound Construct `Self` via a conversion with a specified precision, applying the specified rounding method. MulRound Provides multiplication with a specified rounding method. NegAssign Negates the value inside `self`. NegRound Provides negation with a specified rounding method. Pow Provides the power operation. PowAssign Provides the power operation inside `self`. PowRound Provides the power operation inside `self` with a specified rounding method. ShlRound Provides the left shift operation with a specified rounding method. ShrRound Provides the right shift operation with a specified rounding method. SubFromAssign Subtract and assigns the result to the rhs operand. `rhs.sub_from_assign(lhs)` has the same effect as `rhs = lhs - rhs`. SubRound Provides subtraction with a specified rounding method.

Functions

 exp_max Returns the maximum value for the exponent. exp_min Returns the minimum value for the exponent. prec_max Returns the maximum value for the precision. prec_min Returns the minimum value for the precision.

Type Definitions

 BitCount The type for the bit count of an `Integer` value. Exp The type for the exponent of a `Float` value. Prec The type for the precision of a `Float` value.