Struct clacc::gmp::BigInt

pub struct BigInt { /* private fields */ }

Implementation of BigInt using rust-gmp.

Trait Implementations

impl BigInt for BigInt

fn add(&self, other: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 18.into();
let b: BigInt = 2.into();
let c = a.add(&b);
assert_eq!(c, (18 + 2).into());

fn sub(&self, other: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 18.into();
let b: BigInt = 2.into();
let c = a.sub(&b);
assert_eq!(c, (18 - 2).into());

fn mul(&self, other: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 18.into();
let b: BigInt = 2.into();
let c = a.mul(&b);
assert_eq!(c, (18 * 2).into());

fn div(&self, other: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 18.into();
let b: BigInt = 2.into();
let c = a.div(&b);
assert_eq!(c, (18 / 2).into());

fn gcdext(&self, y: &Self) -> (Self, Self, Self)

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let x: BigInt = 240.into();
let y: clacc::gmp::BigInt = 46.into();
let (g, a, b) = x.gcdext(&y);
assert_eq!(g, 2.into());
assert_eq!(a, (-9).into());
assert_eq!(b, 47.into());

fn modulus(&self, m: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let b: BigInt = 11.into();
let n: BigInt = 7.into();
let m = b.modulus(&n);
assert_eq!(m, 4.into());

fn powm(&self, e: &Self, m: &Self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let b: BigInt = 5.into();
let e: BigInt = 3.into();
let m: BigInt = 13.into();
let c = b.powm(&e, &m);
assert_eq!(c, 8.into());

fn invert(&self, m: &Self) -> Option<Self>

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 123.into();
let n: BigInt = 4567.into();
let i = a.invert(&n).unwrap();
assert_eq!(i, 854.into());

fn next_prime(&self) -> Self

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let x: BigInt = 32.into();
let p = x.next_prime();
assert_eq!(p, 37.into());

fn size_in_bits(&self) -> usize

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let a: BigInt = 3.into();
assert_eq!(a.size_in_bits(), 2);
let b: BigInt = 256.into();
assert_eq!(b.size_in_bits(), 9);

fn to_vec(&self) -> Vec<u8>

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let x: BigInt = 15.into();
assert_eq!(x.to_vec(), vec![0x0f]);

impl Clone for BigInt

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BigInt

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for BigInt

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BigInt

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BigInt

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a [u8]> for BigInt

fn from(other: &'a [u8]) -> Self

Converts to this type from the input type.

impl From<&Mpz> for BigInt

fn from(other: &Mpz) -> Self

Converts to this type from the input type.

impl From<Mpz> for BigInt

fn from(other: Mpz) -> Self

Converts to this type from the input type.

impl From<i64> for BigInt

fn from(other: i64) -> Self

Converts to this type from the input type.

impl LowerHex for BigInt

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq<BigInt> for BigInt

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<BigInt> for BigInt

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for BigInt

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

use clacc::{BigInt as BigIntTrait, gmp::BigInt};
let x: BigInt = 6666666666.into();
let bytes = velocypack::to_bytes(&x).unwrap();
let de = velocypack::from_bytes(&bytes).unwrap();
assert_eq!(x, de);

impl UpperHex for BigInt

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for BigInt