Crate gmp_mpfr [−] [src]
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
multipleprecision floatingpoint computations, is used for
floatingpoint 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
 the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
Basic use
There are three main types defined in this crate:
Integer
which holds an arbitrary precision integer,Rational
which holds an arbitrary precision rational number, andFloat
which holds a floatingpoint number with an exact precision.
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 floatingpoint 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; assert!(a.to_string_radix(16) == "c0000000000000000ffee"); // ^ ^ ^ ^ ^ // 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 multiprecision floatingpoint number. The precision has to be set during construction. 
Integer 

MutNumerDenom 
Used to borrow the numerator and denominator of a

Rational 
An arbitraryprecision rational number. 
Enums
Constant 
The available floatingpoint constants. 
Round 
The rounding methods for floatingpoint values. 
Special 
Special floatingpoint 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.

DivRound 
Provides division with a specified rounding method. 
FromPrec 
Construct 
FromPrecRound 
Construct 
MulRound 
Provides multiplication with a specified rounding method. 
NegAssign 
Negates the value inside 
NegRound 
Provides negation with a specified rounding method. 
Pow 
Provides the power operation. 
PowAssign 
Provides the power operation inside 
PowRound 
Provides the power operation inside 
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.

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 
Exp 
The type for the exponent of a 
Prec 
The type for the precision of a 