gmp bindings for rust

This PR clears all Clippy warnings (incl. nightly) except for documentation of unsafe

warning: unsafe function's docs miss `# Safety` section

Please note, the first patch runs cargo fmt if that is not wanted I can remove it.

Commit d7f6956 Use std::mem::MaybeUninit needs special attention please.

This is kinda a big PR for my first one so if you'd like me to split the more trivial patches out into a separate PR I can do that also.

Thanks

As far as I can tell the corresponding traits from std are deprecated in favour of the traits from num. This also matches with what is done in e.g. ramp.

I noticed that the mpz_struct inside Mpz is public, but it really shouldn't be. It's not safe to modify the contents. If clients need access to the contents, there should be safe accessors instead.

Mpq::ratio is unsafe:

extern crate gmp;
use gmp::mpq::Mpq;
use gmp::mpz::Mpz;
fn main() {
    println!("{:?}", Mpq::ratio(&Mpz::one(), &-Mpz::one()));
    //                                        ^--- (!)
}

results in:

zsh: segmentation fault (core dumped)

Tested this using gmp-6.1.2 on Arch Linux.

To quote the manual:

Note that if an assignment to the numerator and/or denominator could take an mpq_t out of the canonical form described at the start of this chapter (see Rational Number Functions) then mpq_canonicalize must be called before any other mpq functions are applied to that mpq_t.

There are probably other rational functions that need to be scrutinized as well.

Added functions to get the sign of Mpz, Mpq, and Mpf. Although mp{z,q,f}_sgn functions appear to exist in the original C++ API, they are actually macros and cannot be used here.

Old way of getting sign:

match n.cmp(&Mpz::zero()) { // allocation :(
    Ordering::Less => ...,
    Ordering::Equal => ...,
    Ordering::Greater => ...,
}

New way:

match n.sign() {
    Sign::Negative => ...,
    Sign::Zero => ...,
    Sign::Positive => ...,
}

I'm new to Rust, so any feedback is appreciated!

When using GMP for cryptographic applications it is often desirable to have functions resilient to timing attacks, such as powm_sec for integer exponentiation (https://gmplib.org/manual/Integer-Exponentiation.html#Integer-Exponentiation). This PR exposes this function.

Hey,

This pull request contains linking for the c functions to create Mpf structs from Mpz and Mpq structs.

The functions works exacly like the set_z function on Mpq.

Cheers!

Mpf::zero() creates a new Mpf with value zero Mpf::set_from_str() sets the Mpf to the value in str in the given base Mpf::set_from_si() sets the value from a signed int Mpf::get_str() gets a string of the Mpf, see GMP docs for formatting. Mpf::sqrt() is self-explanatory

Also increments version number.

this is the behavior I'm experiencing. Let me know if you need more context. I'm also on nightly, which could just totally be screwing this up.

extern crate gmp;
extern crate num;

use self::gmp::mpz::Mpz;
use self::num::FromPrimitive;

let i = 5;
let mpz_i: Mpz = FromPrimitive::from_u64(i as u64).unwrap();

The wrapper for mpf_get_str passes it a pointer to a string of length 0. This means that when a user specifies the number of digits, the function overwrites memory starting from the empty string. This will overwrite the null on the end of the CString.

However, the fix for this is relatively simple.

When mpf_get_str has a null passed to it as the first argument, it uses malloc to create a CString of correct size, which it then returns. By using this, and then freeing the data afterwards (as to_string takes a copy), this is fixed with no memory leaks!

GMP guarantees that it’s safe for two threads to read from the same GMP variable simultaneously (https://gmplib.org/manual/Reentrancy.html), so the types should be marked Sync. The Rust type system still protects against read/write and write/write races.

These seem arbitrarily left out, which means you need to jump through a few additional hoops if you want, for example, Mpz::from(vec.len()) or the like.

We needed serde for Mpz in one of our upper layer (dependency). Here is a PR if you are interested, I added it as a feature.

cargo build --features "serde_support"
cargo test --features "serde_support"

Thanks,

I'm a bit confused, looking on https://crates.io/ for a rust wrapper for the GMP library I found both:

• rust-gmp = "0.5.0"
• gmp = "0.3.1"

linking this GitHub repository!

bug was introduced in 877104f58239fd19a4f3f5aed13bdd677c65f28b.

the intent here is to allocate enough space for gmpf_get_str to plop a string. if all digits are requested (n_digits == 0), we defer to gmpf_get_str itself to figure out how much space is needed (because the limb nonsense is too tedious to deal with) by passing nullptr to the first argument, as documented in the manual:

If str is NULL, the result string is allocated using the current allocation function (see Custom Allocation). The block will be strlen(str)+1 bytes, that being exactly enough for the string and null-terminator.

if the number of digits requested is known (non-zero n_digits), then simply allocate a correctly sized cstring (unlike 877104f58239fd19a4f3f5aed13bdd677c65f28b, which allocates a 0-byte string).

to avoid memory leaks from repeated get_str(n_digits=0) calls, a wrapper is used to de-allocate on drop the gmp-allocated string.

with this patch, #24 passes.