# Struct openssl::bn::BigNum [−] [src]

    pub struct BigNum(_);

Dynamically sized large number implementation

Perform large number mathematics. Create a new BigNum with `new`. Perform standard mathematics on large numbers using methods from `Dref<Target = BigNumRef>`

OpenSSL documenation at `BN_new`.

# Examples

    use openssl::bn::BigNum;
    let little_big = BigNum::from_u32(std::u32::MAX)?;
    assert_eq!(*&little_big.num_bytes(), 4);

## Implementations

### `impl BigNum` [src]

#### `pub fn new() -> Result<BigNum, ErrorStack>` [src]

Creates a new `BigNum` with the value 0.

#### `pub fn from_u32(n: u32) -> Result<BigNum, ErrorStack>` [src]

Creates a new `BigNum` with the given value.

OpenSSL documentation at `BN_set_word`

#### `pub fn from_dec_str(s: &str) -> Result<BigNum, ErrorStack>` [src]

Creates a `BigNum` from a decimal string.

OpenSSL documentation at `BN_dec2bn`

#### `pub fn from_hex_str(s: &str) -> Result<BigNum, ErrorStack>` [src]

Creates a `BigNum` from a hexadecimal string.

OpenSSL documentation at `BN_hex2bn`

#### `pub fn get_rfc2409_prime_768() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 2409`. This prime number is in the order of magnitude of `2 ^ 768`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled Oakley group id 1.

OpenSSL documentation at `BN_get_rfc2409_prime_768`

#### `pub fn get_rfc2409_prime_1024() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 2409`. This prime number is in the order of magnitude of `2 ^ 1024`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled Oakly group 2.

OpenSSL documentation at `BN_get_rfc2409_prime_1024`

#### `pub fn get_rfc3526_prime_1536() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 1536`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 5.

OpenSSL documentation at `BN_get_rfc3526_prime_1536`

#### `pub fn get_rfc3526_prime_2048() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 2048`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 14.

OpenSSL documentation at `BN_get_rfc3526_prime_2048`

#### `pub fn get_rfc3526_prime_3072() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 3072`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 15.

OpenSSL documentation at `BN_get_rfc3526_prime_3072`

#### `pub fn get_rfc3526_prime_4096() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 4096`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 16.

OpenSSL documentation at `BN_get_rfc3526_prime_4096`

#### `pub fn get_rfc3526_prime_6144() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 6144`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 17.

OpenSSL documentation at `BN_get_rfc3526_prime_6144`

#### `pub fn get_rfc3526_prime_8192() -> Result<BigNum, ErrorStack>` [src]

Returns a constant used in IKE as defined in `RFC 3526`. The prime is in the order of magnitude of `2 ^ 8192`. This number is used during calculated key exchanges such as Diffie-Hellman. This number is labeled MODP group 18.

OpenSSL documentation at `BN_get_rfc3526_prime_8192`

#### `pub fn from_slice(n: &[u8]) -> Result<BigNum, ErrorStack>` [src]

Creates a new `BigNum` from an unsigned, big-endian encoded number of arbitrary length.

OpenSSL documentation at `BN_bin2bn`

    let bignum = BigNum::from_slice(&[0x12, 0x00, 0x34]).unwrap();

    assert_eq!(bignum, BigNum::from_u32(0x120034).unwrap());

## Methods from Deref<Target = BigNumRef>

#### `pub fn clear(&mut self)` [src]

Erases the memory used by this `BigNum`, resetting its value to 0.

This can be used to destroy sensitive data such as keys when they are no longer needed.

OpenSSL documentation at `BN_clear`

#### `pub fn add_word(&mut self, w: u32) -> Result<(), ErrorStack>` [src]

Adds a `u32` to `self`.

OpenSSL documentation at `BN_add_word`

#### `pub fn sub_word(&mut self, w: u32) -> Result<(), ErrorStack>` [src]

Subtracts a `u32` from `self`.

OpenSSL documentation at `BN_sub_word`

#### `pub fn mul_word(&mut self, w: u32) -> Result<(), ErrorStack>` [src]

Multiplies a `u32` by `self`.

OpenSSL documentation at `BN_mul_word`

#### `pub fn div_word(&mut self, w: u32) -> Result<u64, ErrorStack>` [src]

Divides `self` by a `u32`, returning the remainder.

OpenSSL documentation at `BN_div_word`

#### `pub fn mod_word(&self, w: u32) -> Result<u64, ErrorStack>` [src]

Returns the result of `self` modulo `w`.

OpenSSL documentation at `BN_mod_word`

#### `pub fn rand_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack>` [src]

Places a cryptographically-secure pseudo-random nonnegative number less than `self` in `rnd`.

OpenSSL documentation at `BN_rand_range`

#### `pub fn pseudo_rand_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack>` [src]

The cryptographically weak counterpart to `rand_in_range`.

OpenSSL documentation at `BN_pseudo_rand_range`

#### `pub fn set_bit(&mut self, n: i32) -> Result<(), ErrorStack>` [src]

Sets bit `n`. Equivalent to `self |= (1 << n)`.

When setting a bit outside of `self`, it is expanded.

OpenSSL documentation at `BN_set_bit`

#### `pub fn clear_bit(&mut self, n: i32) -> Result<(), ErrorStack>` [src]

Clears bit `n`, setting it to 0. Equivalent to `self &= ~(1 << n)`.

When clearing a bit outside of `self`, an error is returned.

OpenSSL documentation at `BN_clear_bit`

#### `pub fn is_bit_set(&self, n: i32) -> bool` [src]

Returns `true` if the `n`th bit of `self` is set to 1, `false` otherwise.

OpenSSL documentation at `BN_is_bit_set`

#### `pub fn mask_bits(&mut self, n: i32) -> Result<(), ErrorStack>` [src]

Truncates `self` to the lowest `n` bits.

An error occurs if `self` is already shorter than `n` bits.

OpenSSL documentation at `BN_mask_bits`

#### `pub fn lshift1(&mut self, a: &BigNumRef) -> Result<(), ErrorStack>` [src]

Places `a << 1` in `self`. Equivalent to `self * 2`.

OpenSSL documentation at `BN_lshift1`

#### `pub fn rshift1(&mut self, a: &BigNumRef) -> Result<(), ErrorStack>` [src]

Places `a >> 1` in `self`. Equivalent to `self / 2`.

OpenSSL documentation at `BN_rshift1`

#### `pub fn checked_add(
&mut self,
a: &BigNumRef,
b: &BigNumRef
) -> Result<(), ErrorStack>` [src]

Places `a + b` in `self`. `core::ops::Add` is also implemented for `BigNumRef`.

OpenSSL documentation at `BN_add`

#### `pub fn checked_sub(
&mut self,
a: &BigNumRef,
b: &BigNumRef
) -> Result<(), ErrorStack>` [src]

Places `a - b` in `self`. `core::ops::Sub` is also implemented for `BigNumRef`.

OpenSSL documentation at `BN_sub`

#### `pub fn lshift(&mut self, a: &BigNumRef, n: i32) -> Result<(), ErrorStack>` [src]

Places `a << n` in `self`. Equivalent to `a * 2 ^ n`.

OpenSSL documentation at `BN_lshift`

#### `pub fn rshift(&mut self, a: &BigNumRef, n: i32) -> Result<(), ErrorStack>` [src]

Places `a >> n` in `self`. Equivalent to `a / 2 ^ n`.

OpenSSL documentation at `BN_rshift`

#### `pub fn to_owned(&self) -> Result<BigNum, ErrorStack>` [src]

Creates a new BigNum with the same value.

OpenSSL documentation at `BN_dup`

#### `pub fn set_negative(&mut self, negative: bool)` [src]

Sets the sign of `self`. Pass true to set `self` to a negative. False sets `self` positive.

#### `pub fn ucmp(&self, oth: &BigNumRef) -> Ordering` [src]

Compare the absolute values of `self` and `oth`.

OpenSSL documentation at `BN_ucmp`

# Examples

    let s = -BigNum::from_u32(8).unwrap();
    let o = BigNum::from_u32(8).unwrap();

    assert_eq!(s.ucmp(&o), Ordering::Equal);

#### `pub fn is_negative(&self) -> bool` [src]

Returns `true` if `self` is negative.

#### `pub fn num_bits(&self) -> i32` [src]

Returns the number of significant bits in `self`.

OpenSSL documentation at `BN_num_bits`

#### `pub fn num_bytes(&self) -> i32` [src]

Returns the size of `self` in bytes. Implemented natively.

#### `pub fn rand(
&mut self,
bits: i32,
msb: MsbOption,
odd: bool
) -> Result<(), ErrorStack>` [src]

Generates a cryptographically strong pseudo-random `BigNum`, placing it in `self`.

# Parameters

- `bits`: Length of the number in bits.
- `msb`: The desired properties of the most significant bit. See `constants`.
- `odd`: If `true`, the generated number will be odd.

# Examples

    use openssl::bn::{BigNum, MsbOption};
    use openssl::error::ErrorStack;

    fn generate_random() -> Result< BigNum, ErrorStack > {
       let mut big = BigNum::new()?;

       // Generates a 128-bit odd random number
       big.rand(128, MsbOption::MAYBE_ZERO, true);
       Ok((big))
    }

OpenSSL documentation at `BN_rand`

#### `pub fn pseudo_rand(
&mut self,
bits: i32,
msb: MsbOption,
odd: bool
) -> Result<(), ErrorStack>` [src]

The cryptographically weak counterpart to `rand`. Not suitable for key generation.

OpenSSL documentation at `BN_psuedo_rand`

#### `pub fn generate_prime(
&mut self,
bits: i32,
safe: bool,
add: Option<&BigNumRef>,
rem: Option<&BigNumRef>
) -> Result<(), ErrorStack>` [src]

Generates a prime number, placing it in `self`.

# Parameters

- `bits`: The length of the prime in bits (lower bound).
- `safe`: If true, returns a “safe” prime `p` so that `(p-1)/2` is also prime.
- `add`/`rem`: If `add` is set to `Some(add)`, `p % add == rem` will hold, where `p` is the generated prime and `rem` is `1` if not specified (`None`).

# Examples

    use openssl::bn::BigNum;
    use openssl::error::ErrorStack;

    fn generate_weak_prime() -> Result< BigNum, ErrorStack > {
       let mut big = BigNum::new()?;

       // Generates a 128-bit simple prime number
       big.generate_prime(128, false, None, None);
       Ok((big))
    }

OpenSSL documentation at `BN_generate_prime_ex`

#### `pub fn checked_mul(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a * b` in `self`. `core::ops::Mul` is also implemented for `BigNumRef`.

OpenSSL documentation at `BN_mul`

#### `pub fn checked_div(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a / b` in `self`. The remainder is discarded. `core::ops::Div` is also implemented for `BigNumRef`.

OpenSSL documentation at `BN_div`

#### `pub fn checked_rem(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a % b` in `self`.

OpenSSL documentation at `BN_div`

#### `pub fn div_rem(
&mut self,
rem: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a / b` in `self` and `a % b` in `rem`.

OpenSSL documentation at `BN_div`

#### `pub fn sqr(
&mut self,
a: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a²` in `self`.

OpenSSL documentation at `BN_sqr`

#### `pub fn nnmod(
&mut self,
a: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a mod m` in `self`. As opposed to `div_rem` the result is non-negative.

OpenSSL documentation at `BN_nnmod`

#### `pub fn mod_add(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `(a + b) mod m` in `self`.

OpenSSL documentation at `BN_mod_add`

#### `pub fn mod_sub(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `(a - b) mod m` in `self`.

OpenSSL documentation at `BN_mod_sub`

#### `pub fn mod_mul(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `(a * b) mod m` in `self`.

OpenSSL documentation at `BN_mod_mul`

#### `pub fn mod_sqr(
&mut self,
a: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a² mod m` in `self`.

OpenSSL documentation at `BN_mod_sqr`

#### `pub fn exp(
&mut self,
a: &BigNumRef,
p: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a^p` in `self`.

OpenSSL documentation at `BN_exp`

#### `pub fn mod_exp(
&mut self,
a: &BigNumRef,
p: &BigNumRef,
m: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the result of `a^p mod m` in `self`.

OpenSSL documentation at `BN_mod_exp`

#### `pub fn mod_inverse(
&mut self,
a: &BigNumRef,
n: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the inverse of `a` modulo `n` in `self`.

#### `pub fn gcd(
&mut self,
a: &BigNumRef,
b: &BigNumRef,
ctx: &mut BigNumContextRef
) -> Result<(), ErrorStack>` [src]

Places the greatest common denominator of `a` and `b` in `self`.

OpenSSL documentation at `BN_gcd`

#### `pub fn is_prime(
&self,
checks: i32,
ctx: &mut BigNumContextRef
) -> Result<bool, ErrorStack>` [src]

Checks whether `self` is prime.

Performs a Miller-Rabin probabilistic primality test with `checks` iterations.

OpenSSL documentation at `BN_is_prime_ex`

# Return Value

Returns `true` if `self` is prime with an error probability of less than `0.25 ^ checks`.

#### `pub fn is_prime_fasttest(
&self,
checks: i32,
ctx: &mut BigNumContextRef,
do_trial_division: bool
) -> Result<bool, ErrorStack>` [src]

Checks whether `self` is prime with optional trial division.

If `do_trial_division` is `true`, first performs trial division by a number of small primes. Then, like `is_prime`, performs a Miller-Rabin probabilistic primality test with `checks` iterations.

OpenSSL documentation at `BN_is_prime_fasttest_ex`

# Return Value

Returns `true` if `self` is prime with an error probability of less than `0.25 ^ checks`.

#### `pub fn to_vec(&self) -> Vec<u8>` [src]

Returns a big-endian byte vector representation of the absolute value of `self`.

`self` can be recreated by using `from_slice`.

    let s = -BigNum::from_u32(4543).unwrap();
    let r = BigNum::from_u32(4543).unwrap();

    let s_vec = s.to_vec();
    assert_eq!(BigNum::from_slice(&s_vec).unwrap(), r);

#### `pub fn to_dec_str(&self) -> Result<OpensslString, ErrorStack>` [src]

Returns a decimal string representation of `self`.

    let s = -BigNum::from_u32(12345).unwrap();

    assert_eq!(&**s.to_dec_str().unwrap(), "-12345");

#### `pub fn to_hex_str(&self) -> Result<OpensslString, ErrorStack>` [src]

Returns a hexadecimal string representation of `self`.

    let s = -BigNum::from_u32(0x99ff).unwrap();

    assert_eq!(&**s.to_hex_str().unwrap(), "-99FF");

#### `pub fn to_asn1_integer(&self) -> Result<Asn1Integer, ErrorStack>` [src]

Returns an `Asn1Integer` containing the value of `self`.

## Trait Implementations

### `impl<'a, 'b> Add<&'b BigNum> for &'a BigNumRef` [src]

#### `type Output = BigNum`

The resulting type after applying the `+` operator.

#### `fn add(self, oth: &BigNum) -> BigNum` [src]

Performs the `+` operation. Read more

### `impl<'a, 'b> Add<&'b BigNum> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `+` operator.

#### `fn add(self, oth: &BigNum) -> BigNum` [src]

Performs the `+` operation. Read more

### `impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `+` operator.

#### `fn add(self, oth: &BigNumRef) -> BigNum` [src]

Performs the `+` operation. Read more

### `impl AsRef<BigNumRef> for BigNum` [src]

#### `fn as_ref(&self) -> &BigNumRef` [src]

Performs the conversion.

### `impl Borrow<BigNumRef> for BigNum` [src]

#### `fn borrow(&self) -> &BigNumRef` [src]

Immutably borrows from an owned value. Read more

### `impl Debug for BigNum` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Deref for BigNum` [src]

#### `type Target = BigNumRef`

The resulting type after dereferencing.

#### `fn deref(&self) -> &BigNumRef` [src]

Dereferences the value.

### `impl DerefMut for BigNum` [src]

#### `fn deref_mut(&mut self) -> &mut BigNumRef` [src]

Mutably dereferences the value.

### `impl Display for BigNum` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<'a, 'b> Div<&'b BigNum> for &'a BigNumRef` [src]

#### `type Output = BigNum`

The resulting type after applying the `/` operator.

#### `fn div(self, oth: &BigNum) -> BigNum` [src]

Performs the `/` operation. Read more

### `impl<'a, 'b> Div<&'b BigNum> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `/` operator.

#### `fn div(self, oth: &BigNum) -> BigNum` [src]

Performs the `/` operation. Read more

### `impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `/` operator.

#### `fn div(self, oth: &BigNumRef) -> BigNum` [src]

Performs the `/` operation. Read more

### `impl Drop for BigNum` [src]

#### `fn drop(&mut self)` [src]

Executes the destructor for this type. Read more

### `impl Eq for BigNum` [src]

### `impl ForeignType for BigNum` [src]

#### `type CType = BIGNUM`

The raw C type.

#### `type Ref = BigNumRef`

The type representing a reference to this type.

#### `unsafe fn from_ptr(ptr: *mut BIGNUM) -> BigNum` [src]

Constructs an instance of this type from its raw type.

#### `fn as_ptr(&self) -> *mut BIGNUM` [src]

Returns a raw pointer to the wrapped value.

### `impl<'a, 'b> Mul<&'b BigNum> for &'a BigNumRef` [src]

#### `type Output = BigNum`

The resulting type after applying the `*` operator.

#### `fn mul(self, oth: &BigNum) -> BigNum` [src]

Performs the `*` operation. Read more

### `impl<'a, 'b> Mul<&'b BigNum> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `*` operator.

#### `fn mul(self, oth: &BigNum) -> BigNum` [src]

Performs the `*` operation. Read more

### `impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `*` operator.

#### `fn mul(self, oth: &BigNumRef) -> BigNum` [src]

Performs the `*` operation. Read more

### `impl<'a> Neg for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> BigNum` [src]

Performs the unary `-` operation. Read more

### `impl Neg for BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> BigNum` [src]

Performs the unary `-` operation. Read more

### `impl Ord for BigNum` [src]

#### `fn cmp(&self, oth: &BigNum) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl PartialEq<BigNum> for BigNumRef` [src]

#### `fn eq(&self, oth: &BigNum) -> bool` [src]

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

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PartialEq<BigNum> for BigNum` [src]

#### `fn eq(&self, oth: &BigNum) -> bool` [src]

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

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PartialEq<BigNumRef> for BigNum` [src]

#### `fn eq(&self, oth: &BigNumRef) -> bool` [src]

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

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PartialOrd<BigNum> for BigNumRef` [src]

#### `fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>` [src]

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

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

### `impl PartialOrd<BigNum> for BigNum` [src]

#### `fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>` [src]

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

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

### `impl PartialOrd<BigNumRef> for BigNum` [src]

#### `fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering>` [src]

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

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

### `impl<'a, 'b> Rem<&'b BigNum> for &'a BigNumRef` [src]

#### `type Output = BigNum`

The resulting type after applying the `%` operator.

#### `fn rem(self, oth: &BigNum) -> BigNum` [src]

Performs the `%` operation. Read more

### `impl<'a, 'b> Rem<&'b BigNum> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `%` operator.

#### `fn rem(self, oth: &BigNum) -> BigNum` [src]

Performs the `%` operation. Read more

### `impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `%` operator.

#### `fn rem(self, oth: &BigNumRef) -> BigNum` [src]

Performs the `%` operation. Read more

### `impl Send for BigNum` [src]

### `impl<'a> Shl<i32> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `<<` operator.

#### `fn shl(self, n: i32) -> BigNum` [src]

Performs the `<<` operation. Read more

### `impl<'a> Shr<i32> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `>>` operator.

#### `fn shr(self, n: i32) -> BigNum` [src]

Performs the `>>` operation. Read more

### `impl<'a, 'b> Sub<&'b BigNum> for &'a BigNumRef` [src]

#### `type Output = BigNum`

The resulting type after applying the `-` operator.

#### `fn sub(self, oth: &BigNum) -> BigNum` [src]

Performs the `-` operation. Read more

### `impl<'a, 'b> Sub<&'b BigNum> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `-` operator.

#### `fn sub(self, oth: &BigNum) -> BigNum` [src]

Performs the `-` operation. Read more

### `impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNum` [src]

#### `type Output = BigNum`

The resulting type after applying the `-` operator.

#### `fn sub(self, oth: &BigNumRef) -> BigNum` [src]

Performs the `-` operation. Read more

### `impl Sync for BigNum` [src]

## Auto Trait Implementations

### `impl RefUnwindSafe for BigNum`

### `impl Unpin for BigNum`

### `impl UnwindSafe for BigNum`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.