# Struct edn::BigInt
[−]
[src]

pub struct BigInt { /* fields omitted */ }

A big signed integer type.

## Methods

`impl BigInt`

[src]

`impl BigInt`

`pub fn new(sign: Sign, digits: Vec<u32>) -> BigInt`

[src]

`pub fn new(sign: Sign, digits: Vec<u32>) -> BigInt`

Creates and initializes a BigInt.

The digits are in little-endian base 2^{32}.

`pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt`

[src]

`pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt`

Creates and initializes a `BigInt`

.

The digits are in little-endian base 2^{32}.

`pub fn from_slice(sign: Sign, slice: &[u32]) -> BigInt`

[src]

`pub fn from_slice(sign: Sign, slice: &[u32]) -> BigInt`

Creates and initializes a `BigInt`

.

`pub fn assign_from_slice(&mut self, sign: Sign, slice: &[u32])`

[src]

`pub fn assign_from_slice(&mut self, sign: Sign, slice: &[u32])`

Reinitializes a `BigInt`

.

`pub fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt`

[src]

`pub fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt`

Creates and initializes a `BigInt`

.

The bytes are in big-endian byte order.

# Examples

use num_bigint::{BigInt, Sign}; assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"), BigInt::parse_bytes(b"65", 10).unwrap()); assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AA"), BigInt::parse_bytes(b"16705", 10).unwrap()); assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AB"), BigInt::parse_bytes(b"16706", 10).unwrap()); assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"Hello world!"), BigInt::parse_bytes(b"22405534230753963835153736737", 10).unwrap());

`pub fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt`

[src]

`pub fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt`

Creates and initializes a `BigInt`

.

The bytes are in little-endian byte order.

`pub fn from_signed_bytes_be(digits: &[u8]) -> BigInt`

[src]

`pub fn from_signed_bytes_be(digits: &[u8]) -> BigInt`

Creates and initializes a `BigInt`

from an array of bytes in
two's complement binary representation.

The digits are in big-endian base 2^{8}.

`pub fn from_signed_bytes_le(digits: &[u8]) -> BigInt`

[src]

`pub fn from_signed_bytes_le(digits: &[u8]) -> BigInt`

Creates and initializes a `BigInt`

from an array of bytes in two's complement.

The digits are in little-endian base 2^{8}.

`pub fn parse_bytes(buf: &[u8], radix: u32) -> Option<BigInt>`

[src]

`pub fn parse_bytes(buf: &[u8], radix: u32) -> Option<BigInt>`

Creates and initializes a `BigInt`

.

# Examples

use num_bigint::{BigInt, ToBigInt}; assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234)); assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD)); assert_eq!(BigInt::parse_bytes(b"G", 16), None);

`pub fn from_radix_be(sign: Sign, buf: &[u8], radix: u32) -> Option<BigInt>`

[src]

`pub fn from_radix_be(sign: Sign, buf: &[u8], radix: u32) -> Option<BigInt>`

Creates and initializes a `BigInt`

. Each u8 of the input slice is
interpreted as one digit of the number
and must therefore be less than `radix`

.

The bytes are in big-endian byte order.
`radix`

must be in the range `2...256`

.

# Examples

use num_bigint::{BigInt, Sign}; let inbase190 = vec![15, 33, 125, 12, 14]; let a = BigInt::from_radix_be(Sign::Minus, &inbase190, 190).unwrap(); assert_eq!(a.to_radix_be(190), (Sign:: Minus, inbase190));

`pub fn from_radix_le(sign: Sign, buf: &[u8], radix: u32) -> Option<BigInt>`

[src]

`pub fn from_radix_le(sign: Sign, buf: &[u8], radix: u32) -> Option<BigInt>`

Creates and initializes a `BigInt`

. Each u8 of the input slice is
interpreted as one digit of the number
and must therefore be less than `radix`

.

The bytes are in little-endian byte order.
`radix`

must be in the range `2...256`

.

# Examples

use num_bigint::{BigInt, Sign}; let inbase190 = vec![14, 12, 125, 33, 15]; let a = BigInt::from_radix_be(Sign::Minus, &inbase190, 190).unwrap(); assert_eq!(a.to_radix_be(190), (Sign::Minus, inbase190));

`pub fn to_bytes_be(&self) -> (Sign, Vec<u8>)`

[src]

`pub fn to_bytes_be(&self) -> (Sign, Vec<u8>)`

Returns the sign and the byte representation of the `BigInt`

in big-endian byte order.

# Examples

use num_bigint::{ToBigInt, Sign}; let i = -1125.to_bigint().unwrap(); assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101]));

`pub fn to_bytes_le(&self) -> (Sign, Vec<u8>)`

[src]

`pub fn to_bytes_le(&self) -> (Sign, Vec<u8>)`

Returns the sign and the byte representation of the `BigInt`

in little-endian byte order.

# Examples

use num_bigint::{ToBigInt, Sign}; let i = -1125.to_bigint().unwrap(); assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4]));

`pub fn to_signed_bytes_be(&self) -> Vec<u8>`

[src]

`pub fn to_signed_bytes_be(&self) -> Vec<u8>`

Returns the two's complement byte representation of the `BigInt`

in big-endian byte order.

# Examples

use num_bigint::ToBigInt; let i = -1125.to_bigint().unwrap(); assert_eq!(i.to_signed_bytes_be(), vec![251, 155]);

`pub fn to_signed_bytes_le(&self) -> Vec<u8>`

[src]

`pub fn to_signed_bytes_le(&self) -> Vec<u8>`

Returns the two's complement byte representation of the `BigInt`

in little-endian byte order.

# Examples

use num_bigint::ToBigInt; let i = -1125.to_bigint().unwrap(); assert_eq!(i.to_signed_bytes_le(), vec![155, 251]);

`pub fn to_str_radix(&self, radix: u32) -> String`

[src]

`pub fn to_str_radix(&self, radix: u32) -> String`

Returns the integer formatted as a string in the given radix.
`radix`

must be in the range `2...36`

.

# Examples

use num_bigint::BigInt; let i = BigInt::parse_bytes(b"ff", 16).unwrap(); assert_eq!(i.to_str_radix(16), "ff");

`pub fn to_radix_be(&self, radix: u32) -> (Sign, Vec<u8>)`

[src]

`pub fn to_radix_be(&self, radix: u32) -> (Sign, Vec<u8>)`

Returns the integer in the requested base in big-endian digit order.
The output is not given in a human readable alphabet but as a zero
based u8 number.
`radix`

must be in the range `2...256`

.

# Examples

use num_bigint::{BigInt, Sign}; assert_eq!(BigInt::from(-0xFFFFi64).to_radix_be(159), (Sign::Minus, vec![2, 94, 27])); // 0xFFFF = 65535 = 2*(159^2) + 94*159 + 27

`pub fn to_radix_le(&self, radix: u32) -> (Sign, Vec<u8>)`

[src]

`pub fn to_radix_le(&self, radix: u32) -> (Sign, Vec<u8>)`

Returns the integer in the requested base in little-endian digit order.
The output is not given in a human readable alphabet but as a zero
based u8 number.
`radix`

must be in the range `2...256`

.

# Examples

use num_bigint::{BigInt, Sign}; assert_eq!(BigInt::from(-0xFFFFi64).to_radix_le(159), (Sign::Minus, vec![27, 94, 2])); // 0xFFFF = 65535 = 27 + 94*159 + 2*(159^2)

`pub fn sign(&self) -> Sign`

[src]

`pub fn sign(&self) -> Sign`

Returns the sign of the `BigInt`

as a `Sign`

.

# Examples

use num_bigint::{ToBigInt, Sign}; assert_eq!(ToBigInt::to_bigint(&1234).unwrap().sign(), Sign::Plus); assert_eq!(ToBigInt::to_bigint(&-4321).unwrap().sign(), Sign::Minus); assert_eq!(ToBigInt::to_bigint(&0).unwrap().sign(), Sign::NoSign);

`pub fn bits(&self) -> usize`

[src]

`pub fn bits(&self) -> usize`

Determines the fewest bits necessary to express the `BigInt`

,
not including the sign.

`pub fn to_biguint(&self) -> Option<BigUint>`

[src]

`pub fn to_biguint(&self) -> Option<BigUint>`

Converts this `BigInt`

into a `BigUint`

, if it's not negative.

`pub fn checked_add(&self, v: &BigInt) -> Option<BigInt>`

[src]

`pub fn checked_add(&self, v: &BigInt) -> Option<BigInt>`

`pub fn checked_sub(&self, v: &BigInt) -> Option<BigInt>`

[src]

`pub fn checked_sub(&self, v: &BigInt) -> Option<BigInt>`

`pub fn checked_mul(&self, v: &BigInt) -> Option<BigInt>`

[src]

`pub fn checked_mul(&self, v: &BigInt) -> Option<BigInt>`

`pub fn checked_div(&self, v: &BigInt) -> Option<BigInt>`

[src]

`pub fn checked_div(&self, v: &BigInt) -> Option<BigInt>`

`pub fn modpow(&self, exponent: &BigInt, modulus: &BigInt) -> BigInt`

[src]

`pub fn modpow(&self, exponent: &BigInt, modulus: &BigInt) -> BigInt`

Returns `(self ^ exponent) mod modulus`

Note that this rounds like `mod_floor`

, not like the `%`

operator,
which makes a difference when given a negative `self`

or `modulus`

.
The result will be in the interval `[0, modulus)`

for `modulus > 0`

,
or in the interval `(modulus, 0]`

for `modulus < 0`

Panics if the exponent is negative or the modulus is zero.

## Trait Implementations

`impl<'a> Shl<usize> for &'a BigInt`

[src]

`impl<'a> Shl<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: usize) -> BigInt`

[src]

`fn shl(self, rhs: usize) -> BigInt`

Performs the `<<`

operation.

`impl Shl<usize> for BigInt`

[src]

`impl Shl<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: usize) -> BigInt`

[src]

`fn shl(self, rhs: usize) -> BigInt`

Performs the `<<`

operation.

`impl ToBigInt for BigInt`

[src]

`impl ToBigInt for BigInt`

`impl CheckedAdd for BigInt`

[src]

`impl CheckedAdd for BigInt`

`fn checked_add(&self, v: &BigInt) -> Option<BigInt>`

[src]

`fn checked_add(&self, v: &BigInt) -> Option<BigInt>`

Adds two numbers, checking for overflow. If overflow happens, `None`

is returned. Read more

`impl CheckedMul for BigInt`

[src]

`impl CheckedMul for BigInt`

`fn checked_mul(&self, v: &BigInt) -> Option<BigInt>`

[src]

`fn checked_mul(&self, v: &BigInt) -> Option<BigInt>`

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, `None`

is returned. Read more

`impl Clone for BigInt`

[src]

`impl Clone for BigInt`

`fn clone(&self) -> BigInt`

[src]

`fn clone(&self) -> BigInt`

Returns a copy of the value. Read more

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

1.0.0[src]

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

Performs copy-assignment from `source`

. Read more

`impl LowerHex for BigInt`

[src]

`impl LowerHex for BigInt`

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

[src]

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

Formats the value using the given formatter.

`impl<'a, 'b> Rem<&'a BigInt> for &'b u32`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b u32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b i64> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i64) -> BigInt`

[src]

`fn rem(self, other: &i64) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b i32> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i32) -> BigInt`

[src]

`fn rem(self, other: &i32) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b isize> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &isize) -> BigInt`

[src]

`fn rem(self, other: &isize) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for BigInt`

[src]

`impl Rem<BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a i64`

[src]

`impl<'a> Rem<BigInt> for &'a i64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for i32`

[src]

`impl<'a> Rem<&'a BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<i32> for BigInt`

[src]

`impl Rem<i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i32) -> BigInt`

[src]

`fn rem(self, other: i32) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a u8`

[src]

`impl<'a> Rem<BigInt> for &'a u8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<u64> for BigInt`

[src]

`impl Rem<u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u64) -> BigInt`

[src]

`fn rem(self, other: u64) -> BigInt`

Performs the `%`

operation.

`impl Rem<i64> for BigInt`

[src]

`impl Rem<i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i64) -> BigInt`

[src]

`fn rem(self, other: i64) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for isize`

[src]

`impl Rem<BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a u64> for BigInt`

[src]

`impl<'a> Rem<&'a u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u64) -> BigInt`

[src]

`fn rem(self, other: &u64) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for i16`

[src]

`impl<'a> Rem<&'a BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a i16`

[src]

`impl<'a> Rem<BigInt> for &'a i16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<u8> for &'a BigInt`

[src]

`impl<'a> Rem<u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u8) -> BigInt`

[src]

`fn rem(self, other: u8) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for i64`

[src]

`impl Rem<BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b u32> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u32) -> BigInt`

[src]

`fn rem(self, other: &u32) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for usize`

[src]

`impl<'a> Rem<&'a BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<i16> for BigInt`

[src]

`impl Rem<i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i16) -> BigInt`

[src]

`fn rem(self, other: i16) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a u16> for BigInt`

[src]

`impl<'a> Rem<&'a u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u16) -> BigInt`

[src]

`fn rem(self, other: &u16) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a usize`

[src]

`impl<'a> Rem<BigInt> for &'a usize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for u32`

[src]

`impl Rem<BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<u8> for BigInt`

[src]

`impl Rem<u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u8) -> BigInt`

[src]

`fn rem(self, other: u8) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a u32`

[src]

`impl<'a> Rem<BigInt> for &'a u32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a u8> for BigInt`

[src]

`impl<'a> Rem<&'a u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u8) -> BigInt`

[src]

`fn rem(self, other: &u8) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<i64> for &'a BigInt`

[src]

`impl<'a> Rem<i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i64) -> BigInt`

[src]

`fn rem(self, other: i64) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<i8> for &'a BigInt`

[src]

`impl<'a> Rem<i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i8) -> BigInt`

[src]

`fn rem(self, other: i8) -> BigInt`

Performs the `%`

operation.

`impl Rem<i8> for BigInt`

[src]

`impl Rem<i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i8) -> BigInt`

[src]

`fn rem(self, other: i8) -> BigInt`

Performs the `%`

operation.

`impl Rem<u16> for BigInt`

[src]

`impl Rem<u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u16) -> BigInt`

[src]

`fn rem(self, other: u16) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b u64> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u64) -> BigInt`

[src]

`fn rem(self, other: &u64) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for u16`

[src]

`impl Rem<BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for isize`

[src]

`impl<'a> Rem<&'a BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for u8`

[src]

`impl Rem<BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a BigInt`

[src]

`impl<'a> Rem<BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b i64`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b i64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a u32> for BigInt`

[src]

`impl<'a> Rem<&'a u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u32) -> BigInt`

[src]

`fn rem(self, other: &u32) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<usize> for &'a BigInt`

[src]

`impl<'a> Rem<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: usize) -> BigInt`

[src]

`fn rem(self, other: usize) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a i32> for BigInt`

[src]

`impl<'a> Rem<&'a i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i32) -> BigInt`

[src]

`fn rem(self, other: &i32) -> BigInt`

Performs the `%`

operation.

`impl Rem<u32> for BigInt`

[src]

`impl Rem<u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u32) -> BigInt`

[src]

`fn rem(self, other: u32) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a isize> for BigInt`

[src]

`impl<'a> Rem<&'a isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &isize) -> BigInt`

[src]

`fn rem(self, other: &isize) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<i32> for &'a BigInt`

[src]

`impl<'a> Rem<i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i32) -> BigInt`

[src]

`fn rem(self, other: i32) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b usize`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b usize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for i64`

[src]

`impl<'a> Rem<&'a BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a i64> for BigInt`

[src]

`impl<'a> Rem<&'a i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i64) -> BigInt`

[src]

`fn rem(self, other: &i64) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a i32`

[src]

`impl<'a> Rem<BigInt> for &'a i32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for i32`

[src]

`impl Rem<BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b i16`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b i16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b i8> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i8) -> BigInt`

[src]

`fn rem(self, other: &i8) -> BigInt`

Performs the `%`

operation.

`impl Rem<isize> for BigInt`

[src]

`impl Rem<isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: isize) -> BigInt`

[src]

`fn rem(self, other: isize) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b usize> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &usize) -> BigInt`

[src]

`fn rem(self, other: &usize) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a u16`

[src]

`impl<'a> Rem<BigInt> for &'a u16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for i16`

[src]

`impl Rem<BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a isize`

[src]

`impl<'a> Rem<BigInt> for &'a isize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for u16`

[src]

`impl<'a> Rem<&'a BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a i8`

[src]

`impl<'a> Rem<BigInt> for &'a i8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for u64`

[src]

`impl Rem<BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for u64`

[src]

`impl<'a> Rem<&'a BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for u32`

[src]

`impl<'a> Rem<&'a BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a i8> for BigInt`

[src]

`impl<'a> Rem<&'a i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i8) -> BigInt`

[src]

`fn rem(self, other: &i8) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<u32> for &'a BigInt`

[src]

`impl<'a> Rem<u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u32) -> BigInt`

[src]

`fn rem(self, other: u32) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b u64`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b u64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<u64> for &'a BigInt`

[src]

`impl<'a> Rem<u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u64) -> BigInt`

[src]

`fn rem(self, other: u64) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<isize> for &'a BigInt`

[src]

`impl<'a> Rem<isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: isize) -> BigInt`

[src]

`fn rem(self, other: isize) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a usize> for BigInt`

[src]

`impl<'a> Rem<&'a usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &usize) -> BigInt`

[src]

`fn rem(self, other: &usize) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for u8`

[src]

`impl<'a> Rem<&'a BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b i16> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i16) -> BigInt`

[src]

`fn rem(self, other: &i16) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<i16> for &'a BigInt`

[src]

`impl<'a> Rem<i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: i16) -> BigInt`

[src]

`fn rem(self, other: i16) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b isize`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b isize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<u16> for &'a BigInt`

[src]

`impl<'a> Rem<u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: u16) -> BigInt`

[src]

`fn rem(self, other: u16) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b i32`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b i32`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a i16> for BigInt`

[src]

`impl<'a> Rem<&'a i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &i16) -> BigInt`

[src]

`fn rem(self, other: &i16) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b u8> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u8) -> BigInt`

[src]

`fn rem(self, other: &u8) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<BigInt> for &'a u64`

[src]

`impl<'a> Rem<BigInt> for &'a u64`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b u8`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b u8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for BigInt`

[src]

`impl<'a> Rem<&'a BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b i8`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b i8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b BigInt> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl Rem<usize> for BigInt`

[src]

`impl Rem<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: usize) -> BigInt`

[src]

`fn rem(self, other: usize) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for i8`

[src]

`impl Rem<BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'b u16> for &'a BigInt`

[src]

`impl<'a, 'b> Rem<&'b u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &u16) -> BigInt`

[src]

`fn rem(self, other: &u16) -> BigInt`

Performs the `%`

operation.

`impl Rem<BigInt> for usize`

[src]

`impl Rem<BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: BigInt) -> BigInt`

[src]

`fn rem(self, other: BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a> Rem<&'a BigInt> for i8`

[src]

`impl<'a> Rem<&'a BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl<'a, 'b> Rem<&'a BigInt> for &'b u16`

[src]

`impl<'a, 'b> Rem<&'a BigInt> for &'b u16`

`type Output = BigInt`

The resulting type after applying the `%`

operator.

`fn rem(self, other: &BigInt) -> BigInt`

[src]

`fn rem(self, other: &BigInt) -> BigInt`

Performs the `%`

operation.

`impl FromPrimitive for BigInt`

[src]

`impl FromPrimitive for BigInt`

`fn from_i64(n: i64) -> Option<BigInt>`

[src]

`fn from_i64(n: i64) -> Option<BigInt>`

Convert an `i64`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_u64(n: u64) -> Option<BigInt>`

[src]

`fn from_u64(n: u64) -> Option<BigInt>`

Convert an `u64`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_f64(n: f64) -> Option<BigInt>`

[src]

`fn from_f64(n: f64) -> Option<BigInt>`

Convert a `f64`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_isize(n: isize) -> Option<Self>`

[src]

`fn from_isize(n: isize) -> Option<Self>`

Convert an `isize`

to return an optional value of this type. If the value cannot be represented by this value, then `None`

is returned. Read more

`fn from_i8(n: i8) -> Option<Self>`

[src]

`fn from_i8(n: i8) -> Option<Self>`

Convert an `i8`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_i16(n: i16) -> Option<Self>`

[src]

`fn from_i16(n: i16) -> Option<Self>`

Convert an `i16`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_i32(n: i32) -> Option<Self>`

[src]

`fn from_i32(n: i32) -> Option<Self>`

Convert an `i32`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_i128(n: i128) -> Option<Self>`

[src]

`fn from_i128(n: i128) -> Option<Self>`

Convert an `i128`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_usize(n: usize) -> Option<Self>`

[src]

`fn from_usize(n: usize) -> Option<Self>`

Convert a `usize`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_u8(n: u8) -> Option<Self>`

[src]

`fn from_u8(n: u8) -> Option<Self>`

Convert an `u8`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_u16(n: u16) -> Option<Self>`

[src]

`fn from_u16(n: u16) -> Option<Self>`

Convert an `u16`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_u32(n: u32) -> Option<Self>`

[src]

`fn from_u32(n: u32) -> Option<Self>`

Convert an `u32`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_u128(n: u128) -> Option<Self>`

[src]

`fn from_u128(n: u128) -> Option<Self>`

Convert an `u128`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`fn from_f32(n: f32) -> Option<Self>`

[src]

`fn from_f32(n: f32) -> Option<Self>`

Convert a `f32`

to return an optional value of this type. If the type cannot be represented by this value, then `None`

is returned. Read more

`impl FromStr for BigInt`

[src]

`impl FromStr for BigInt`

`type Err = ParseBigIntError`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<BigInt, ParseBigIntError>`

[src]

`fn from_str(s: &str) -> Result<BigInt, ParseBigIntError>`

Parses a string `s`

to return a value of this type. Read more

`impl Hash for BigInt`

[src]

`impl Hash for BigInt`

`fn hash<__H>(&self, __arg_0: &mut __H) where`

__H: Hasher,

[src]

`fn hash<__H>(&self, __arg_0: &mut __H) where`

__H: Hasher,

Feeds this value into the given [`Hasher`

]. Read more

`fn hash_slice<H>(data: &[Self], state: &mut H) where`

H: Hasher,

1.3.0[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where`

H: Hasher,

Feeds a slice of this type into the given [`Hasher`

]. Read more

`impl Eq for BigInt`

[src]

`impl Eq for BigInt`

`impl Signed for BigInt`

[src]

`impl Signed for BigInt`

`fn abs(&self) -> BigInt`

[src]

`fn abs(&self) -> BigInt`

Computes the absolute value. Read more

`fn abs_sub(&self, other: &BigInt) -> BigInt`

[src]

`fn abs_sub(&self, other: &BigInt) -> BigInt`

The positive difference of two numbers. Read more

`fn signum(&self) -> BigInt`

[src]

`fn signum(&self) -> BigInt`

Returns the sign of the number. Read more

`fn is_positive(&self) -> bool`

[src]

`fn is_positive(&self) -> bool`

Returns true if the number is positive and false if the number is zero or negative.

`fn is_negative(&self) -> bool`

[src]

`fn is_negative(&self) -> bool`

Returns true if the number is negative and false if the number is zero or positive.

`impl ToPrimitive for BigInt`

[src]

`impl ToPrimitive for BigInt`

`fn to_i64(&self) -> Option<i64>`

[src]

`fn to_i64(&self) -> Option<i64>`

Converts the value of `self`

to an `i64`

.

`fn to_u64(&self) -> Option<u64>`

[src]

`fn to_u64(&self) -> Option<u64>`

Converts the value of `self`

to an `u64`

.

`fn to_f32(&self) -> Option<f32>`

[src]

`fn to_f32(&self) -> Option<f32>`

Converts the value of `self`

to an `f32`

.

`fn to_f64(&self) -> Option<f64>`

[src]

`fn to_f64(&self) -> Option<f64>`

Converts the value of `self`

to an `f64`

.

`fn to_isize(&self) -> Option<isize>`

[src]

`fn to_isize(&self) -> Option<isize>`

Converts the value of `self`

to an `isize`

.

`fn to_i8(&self) -> Option<i8>`

[src]

`fn to_i8(&self) -> Option<i8>`

Converts the value of `self`

to an `i8`

.

`fn to_i16(&self) -> Option<i16>`

[src]

`fn to_i16(&self) -> Option<i16>`

Converts the value of `self`

to an `i16`

.

`fn to_i32(&self) -> Option<i32>`

[src]

`fn to_i32(&self) -> Option<i32>`

Converts the value of `self`

to an `i32`

.

`fn to_i128(&self) -> Option<i128>`

[src]

`fn to_i128(&self) -> Option<i128>`

Converts the value of `self`

to an `i128`

. Read more

`fn to_usize(&self) -> Option<usize>`

[src]

`fn to_usize(&self) -> Option<usize>`

Converts the value of `self`

to a `usize`

.

`fn to_u8(&self) -> Option<u8>`

[src]

`fn to_u8(&self) -> Option<u8>`

Converts the value of `self`

to an `u8`

.

`fn to_u16(&self) -> Option<u16>`

[src]

`fn to_u16(&self) -> Option<u16>`

Converts the value of `self`

to an `u16`

.

`fn to_u32(&self) -> Option<u32>`

[src]

`fn to_u32(&self) -> Option<u32>`

Converts the value of `self`

to an `u32`

.

`fn to_u128(&self) -> Option<u128>`

[src]

`fn to_u128(&self) -> Option<u128>`

Converts the value of `self`

to an `u128`

. Read more

`impl Num for BigInt`

[src]

`impl Num for BigInt`

`type FromStrRadixErr = ParseBigIntError`

`fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>`

[src]

`fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>`

Creates and initializes a BigInt.

`impl Mul<BigInt> for i8`

[src]

`impl Mul<BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a isize`

[src]

`impl<'a> Mul<BigInt> for &'a isize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b u8> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u8) -> BigInt`

[src]

`fn mul(self, other: &u8) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b u32> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u32) -> BigInt`

[src]

`fn mul(self, other: &u32) -> BigInt`

Performs the `*`

operation.

`impl Mul<u64> for BigInt`

[src]

`impl Mul<u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u64) -> BigInt`

[src]

`fn mul(self, other: u64) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b i32`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b i32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for u8`

[src]

`impl<'a> Mul<&'a BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a usize> for BigInt`

[src]

`impl<'a> Mul<&'a usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &usize) -> BigInt`

[src]

`fn mul(self, other: &usize) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a u64`

[src]

`impl<'a> Mul<BigInt> for &'a u64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b u16`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b u16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<isize> for BigInt`

[src]

`impl Mul<isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: isize) -> BigInt`

[src]

`fn mul(self, other: isize) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for u8`

[src]

`impl Mul<BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a u32> for BigInt`

[src]

`impl<'a> Mul<&'a u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u32) -> BigInt`

[src]

`fn mul(self, other: &u32) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for u16`

[src]

`impl<'a> Mul<&'a BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b i64`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b i64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for i8`

[src]

`impl<'a> Mul<&'a BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for BigInt`

[src]

`impl Mul<BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for u32`

[src]

`impl Mul<BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for u64`

[src]

`impl<'a> Mul<&'a BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a i8`

[src]

`impl<'a> Mul<BigInt> for &'a i8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<usize> for BigInt`

[src]

`impl Mul<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: usize) -> BigInt`

[src]

`fn mul(self, other: usize) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b u16> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u16) -> BigInt`

[src]

`fn mul(self, other: &u16) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<usize> for &'a BigInt`

[src]

`impl<'a> Mul<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: usize) -> BigInt`

[src]

`fn mul(self, other: usize) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<isize> for &'a BigInt`

[src]

`impl<'a> Mul<isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: isize) -> BigInt`

[src]

`fn mul(self, other: isize) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for i64`

[src]

`impl Mul<BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b i8> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i8) -> BigInt`

[src]

`fn mul(self, other: &i8) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a i64`

[src]

`impl<'a> Mul<BigInt> for &'a i64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a u16`

[src]

`impl<'a> Mul<BigInt> for &'a u16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for i16`

[src]

`impl Mul<BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b u64`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b u64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<u64> for &'a BigInt`

[src]

`impl<'a> Mul<u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u64) -> BigInt`

[src]

`fn mul(self, other: u64) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b i64> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i64) -> BigInt`

[src]

`fn mul(self, other: &i64) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a i8> for BigInt`

[src]

`impl<'a> Mul<&'a i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i8) -> BigInt`

[src]

`fn mul(self, other: &i8) -> BigInt`

Performs the `*`

operation.

`impl Mul<i8> for BigInt`

[src]

`impl Mul<i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i8) -> BigInt`

[src]

`fn mul(self, other: i8) -> BigInt`

Performs the `*`

operation.

`impl Mul<u8> for BigInt`

[src]

`impl Mul<u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u8) -> BigInt`

[src]

`fn mul(self, other: u8) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for BigInt`

[src]

`impl<'a> Mul<&'a BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<u8> for &'a BigInt`

[src]

`impl<'a> Mul<u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u8) -> BigInt`

[src]

`fn mul(self, other: u8) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b usize> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &usize) -> BigInt`

[src]

`fn mul(self, other: &usize) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b u64> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u64) -> BigInt`

[src]

`fn mul(self, other: &u64) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for i64`

[src]

`impl<'a> Mul<&'a BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b usize`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b usize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<u16> for &'a BigInt`

[src]

`impl<'a> Mul<u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u16) -> BigInt`

[src]

`fn mul(self, other: u16) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b i32> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i32) -> BigInt`

[src]

`fn mul(self, other: &i32) -> BigInt`

Performs the `*`

operation.

`impl Mul<u32> for BigInt`

[src]

`impl Mul<u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u32) -> BigInt`

[src]

`fn mul(self, other: u32) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<i32> for &'a BigInt`

[src]

`impl<'a> Mul<i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i32) -> BigInt`

[src]

`fn mul(self, other: i32) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for isize`

[src]

`impl<'a> Mul<&'a BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a u8`

[src]

`impl<'a> Mul<BigInt> for &'a u8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b u32`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b u32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b i8`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b i8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a u64> for BigInt`

[src]

`impl<'a> Mul<&'a u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u64) -> BigInt`

[src]

`fn mul(self, other: &u64) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for isize`

[src]

`impl Mul<BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b isize> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &isize) -> BigInt`

[src]

`fn mul(self, other: &isize) -> BigInt`

Performs the `*`

operation.

`impl Mul<u16> for BigInt`

[src]

`impl Mul<u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u16) -> BigInt`

[src]

`fn mul(self, other: u16) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b i16> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i16) -> BigInt`

[src]

`fn mul(self, other: &i16) -> BigInt`

Performs the `*`

operation.

`impl Mul<i16> for BigInt`

[src]

`impl Mul<i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i16) -> BigInt`

[src]

`fn mul(self, other: i16) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a i16`

[src]

`impl<'a> Mul<BigInt> for &'a i16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a i16> for BigInt`

[src]

`impl<'a> Mul<&'a i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i16) -> BigInt`

[src]

`fn mul(self, other: &i16) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt`

[src]

`impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a i64> for BigInt`

[src]

`impl<'a> Mul<&'a i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i64) -> BigInt`

[src]

`fn mul(self, other: &i64) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<i8> for &'a BigInt`

[src]

`impl<'a> Mul<i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i8) -> BigInt`

[src]

`fn mul(self, other: i8) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for usize`

[src]

`impl<'a> Mul<&'a BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for u32`

[src]

`impl<'a> Mul<&'a BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a u32`

[src]

`impl<'a> Mul<BigInt> for &'a u32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<i16> for &'a BigInt`

[src]

`impl<'a> Mul<i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i16) -> BigInt`

[src]

`fn mul(self, other: i16) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for usize`

[src]

`impl Mul<BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a i32> for BigInt`

[src]

`impl<'a> Mul<&'a i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &i32) -> BigInt`

[src]

`fn mul(self, other: &i32) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b u8`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b u8`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<i64> for BigInt`

[src]

`impl Mul<i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i64) -> BigInt`

[src]

`fn mul(self, other: i64) -> BigInt`

Performs the `*`

operation.

`impl Mul<i32> for BigInt`

[src]

`impl Mul<i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i32) -> BigInt`

[src]

`fn mul(self, other: i32) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b isize`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b isize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for i32`

[src]

`impl Mul<BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a isize> for BigInt`

[src]

`impl<'a> Mul<&'a isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &isize) -> BigInt`

[src]

`fn mul(self, other: &isize) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<i64> for &'a BigInt`

[src]

`impl<'a> Mul<i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: i64) -> BigInt`

[src]

`fn mul(self, other: i64) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a i32`

[src]

`impl<'a> Mul<BigInt> for &'a i32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a, 'b> Mul<&'a BigInt> for &'b i16`

[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b i16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<u32> for &'a BigInt`

[src]

`impl<'a> Mul<u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: u32) -> BigInt`

[src]

`fn mul(self, other: u32) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for u16`

[src]

`impl Mul<BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for i32`

[src]

`impl<'a> Mul<&'a BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a BigInt> for i16`

[src]

`impl<'a> Mul<&'a BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &BigInt) -> BigInt`

[src]

`fn mul(self, other: &BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a usize`

[src]

`impl<'a> Mul<BigInt> for &'a usize`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<BigInt> for &'a BigInt`

[src]

`impl<'a> Mul<BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a u8> for BigInt`

[src]

`impl<'a> Mul<&'a u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u8) -> BigInt`

[src]

`fn mul(self, other: &u8) -> BigInt`

Performs the `*`

operation.

`impl<'a> Mul<&'a u16> for BigInt`

[src]

`impl<'a> Mul<&'a u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: &u16) -> BigInt`

[src]

`fn mul(self, other: &u16) -> BigInt`

Performs the `*`

operation.

`impl Mul<BigInt> for u64`

[src]

`impl Mul<BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `*`

operator.

`fn mul(self, other: BigInt) -> BigInt`

[src]

`fn mul(self, other: BigInt) -> BigInt`

Performs the `*`

operation.

`impl CheckedDiv for BigInt`

[src]

`impl CheckedDiv for BigInt`

`fn checked_div(&self, v: &BigInt) -> Option<BigInt>`

[src]

`fn checked_div(&self, v: &BigInt) -> Option<BigInt>`

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, `None`

is returned. Read more

`impl Debug for BigInt`

[src]

`impl Debug for BigInt`

`fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>`

[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter. Read more

`impl Zero for BigInt`

[src]

`impl Zero for BigInt`

`fn zero() -> BigInt`

[src]

`fn zero() -> BigInt`

Returns the additive identity element of `Self`

, `0`

. Read more

`fn is_zero(&self) -> bool`

[src]

`fn is_zero(&self) -> bool`

Returns `true`

if `self`

is equal to the additive identity.

`impl Binary for BigInt`

[src]

`impl Binary for BigInt`

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

[src]

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

Formats the value using the given formatter.

`impl Decodable for BigInt`

[src]

`impl Decodable for BigInt`

`fn decode<__D>(__arg_0: &mut __D) -> Result<BigInt, <__D as Decoder>::Error> where`

__D: Decoder,

[src]

`fn decode<__D>(__arg_0: &mut __D) -> Result<BigInt, <__D as Decoder>::Error> where`

__D: Decoder,

Deserialize a value using a `Decoder`

.

`impl<'a, 'b> Div<&'a BigInt> for &'b i32`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b i32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<u64> for &'a BigInt`

[src]

`impl<'a> Div<u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u64) -> BigInt`

[src]

`fn div(self, other: u64) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a usize> for BigInt`

[src]

`impl<'a> Div<&'a usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &usize) -> BigInt`

[src]

`fn div(self, other: &usize) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for usize`

[src]

`impl Div<BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a u64`

[src]

`impl<'a> Div<BigInt> for &'a u64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a u32`

[src]

`impl<'a> Div<BigInt> for &'a u32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b usize`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b usize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a i8`

[src]

`impl<'a> Div<BigInt> for &'a i8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a u8> for BigInt`

[src]

`impl<'a> Div<&'a u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u8) -> BigInt`

[src]

`fn div(self, other: &u8) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b u64> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u64) -> BigInt`

[src]

`fn div(self, other: &u64) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b i8`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b i8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<i16> for BigInt`

[src]

`impl Div<i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i16) -> BigInt`

[src]

`fn div(self, other: i16) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<u16> for &'a BigInt`

[src]

`impl<'a> Div<u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u16) -> BigInt`

[src]

`fn div(self, other: u16) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b i16`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b i16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for u32`

[src]

`impl<'a> Div<&'a BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a isize> for BigInt`

[src]

`impl<'a> Div<&'a isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &isize) -> BigInt`

[src]

`fn div(self, other: &isize) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a usize`

[src]

`impl<'a> Div<BigInt> for &'a usize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b u8> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u8) -> BigInt`

[src]

`fn div(self, other: &u8) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for i16`

[src]

`impl Div<BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for u16`

[src]

`impl Div<BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a u64> for BigInt`

[src]

`impl<'a> Div<&'a u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u64) -> BigInt`

[src]

`fn div(self, other: &u64) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b u16`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b u16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a u16> for BigInt`

[src]

`impl<'a> Div<&'a u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u16) -> BigInt`

[src]

`fn div(self, other: &u16) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for isize`

[src]

`impl Div<BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for BigInt`

[src]

`impl Div<BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b isize`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b isize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b u32> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u32) -> BigInt`

[src]

`fn div(self, other: &u32) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for u8`

[src]

`impl Div<BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a i8> for BigInt`

[src]

`impl<'a> Div<&'a i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i8) -> BigInt`

[src]

`fn div(self, other: &i8) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<i32> for &'a BigInt`

[src]

`impl<'a> Div<i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i32) -> BigInt`

[src]

`fn div(self, other: i32) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b isize> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &isize) -> BigInt`

[src]

`fn div(self, other: &isize) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a i16`

[src]

`impl<'a> Div<BigInt> for &'a i16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<i32> for BigInt`

[src]

`impl Div<i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i32) -> BigInt`

[src]

`fn div(self, other: i32) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b u32`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b u32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<u8> for &'a BigInt`

[src]

`impl<'a> Div<u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u8) -> BigInt`

[src]

`fn div(self, other: u8) -> BigInt`

Performs the `/`

operation.

`impl Div<u32> for BigInt`

[src]

`impl Div<u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u32) -> BigInt`

[src]

`fn div(self, other: u32) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b BigInt> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b u64`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b u64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<usize> for BigInt`

[src]

`impl Div<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: usize) -> BigInt`

[src]

`fn div(self, other: usize) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for i64`

[src]

`impl<'a> Div<&'a BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a i64> for BigInt`

[src]

`impl<'a> Div<&'a i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i64) -> BigInt`

[src]

`fn div(self, other: &i64) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b i64> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i64) -> BigInt`

[src]

`fn div(self, other: &i64) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for u8`

[src]

`impl<'a> Div<&'a BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b i16> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i16) -> BigInt`

[src]

`fn div(self, other: &i16) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a i16> for BigInt`

[src]

`impl<'a> Div<&'a i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i16) -> BigInt`

[src]

`fn div(self, other: &i16) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a u16`

[src]

`impl<'a> Div<BigInt> for &'a u16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a u32> for BigInt`

[src]

`impl<'a> Div<&'a u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u32) -> BigInt`

[src]

`fn div(self, other: &u32) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b i64`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b i64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<isize> for BigInt`

[src]

`impl Div<isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: isize) -> BigInt`

[src]

`fn div(self, other: isize) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a i32> for BigInt`

[src]

`impl<'a> Div<&'a i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i32) -> BigInt`

[src]

`fn div(self, other: &i32) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for i32`

[src]

`impl Div<BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for i8`

[src]

`impl Div<BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for i32`

[src]

`impl<'a> Div<&'a BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for u64`

[src]

`impl Div<BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b u16> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &u16) -> BigInt`

[src]

`fn div(self, other: &u16) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<isize> for &'a BigInt`

[src]

`impl<'a> Div<isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: isize) -> BigInt`

[src]

`fn div(self, other: isize) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'a BigInt> for &'b u8`

[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b u8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<i64> for &'a BigInt`

[src]

`impl<'a> Div<i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i64) -> BigInt`

[src]

`fn div(self, other: i64) -> BigInt`

Performs the `/`

operation.

`impl Div<i64> for BigInt`

[src]

`impl Div<i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i64) -> BigInt`

[src]

`fn div(self, other: i64) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<u32> for &'a BigInt`

[src]

`impl<'a> Div<u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u32) -> BigInt`

[src]

`fn div(self, other: u32) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<usize> for &'a BigInt`

[src]

`impl<'a> Div<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: usize) -> BigInt`

[src]

`fn div(self, other: usize) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a i64`

[src]

`impl<'a> Div<BigInt> for &'a i64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for i64`

[src]

`impl Div<BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<i8> for BigInt`

[src]

`impl Div<i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i8) -> BigInt`

[src]

`fn div(self, other: i8) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<i16> for &'a BigInt`

[src]

`impl<'a> Div<i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i16) -> BigInt`

[src]

`fn div(self, other: i16) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for i8`

[src]

`impl<'a> Div<&'a BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for BigInt`

[src]

`impl<'a> Div<&'a BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for isize`

[src]

`impl<'a> Div<&'a BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<u8> for BigInt`

[src]

`impl Div<u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u8) -> BigInt`

[src]

`fn div(self, other: u8) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a u8`

[src]

`impl<'a> Div<BigInt> for &'a u8`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for usize`

[src]

`impl<'a> Div<&'a BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<u64> for BigInt`

[src]

`impl Div<u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u64) -> BigInt`

[src]

`fn div(self, other: u64) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b usize> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &usize) -> BigInt`

[src]

`fn div(self, other: &usize) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b i8> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i8) -> BigInt`

[src]

`fn div(self, other: &i8) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for u16`

[src]

`impl<'a> Div<&'a BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<i8> for &'a BigInt`

[src]

`impl<'a> Div<i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: i8) -> BigInt`

[src]

`fn div(self, other: i8) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for u64`

[src]

`impl<'a> Div<&'a BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a isize`

[src]

`impl<'a> Div<BigInt> for &'a isize`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl Div<BigInt> for u32`

[src]

`impl Div<BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a BigInt`

[src]

`impl<'a> Div<BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<BigInt> for &'a i32`

[src]

`impl<'a> Div<BigInt> for &'a i32`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: BigInt) -> BigInt`

[src]

`fn div(self, other: BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a> Div<&'a BigInt> for i16`

[src]

`impl<'a> Div<&'a BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &BigInt) -> BigInt`

[src]

`fn div(self, other: &BigInt) -> BigInt`

Performs the `/`

operation.

`impl<'a, 'b> Div<&'b i32> for &'a BigInt`

[src]

`impl<'a, 'b> Div<&'b i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: &i32) -> BigInt`

[src]

`fn div(self, other: &i32) -> BigInt`

Performs the `/`

operation.

`impl Div<u16> for BigInt`

[src]

`impl Div<u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `/`

operator.

`fn div(self, other: u16) -> BigInt`

[src]

`fn div(self, other: u16) -> BigInt`

Performs the `/`

operation.

`impl Encodable for BigInt`

[src]

`impl Encodable for BigInt`

`fn encode<__S>(&self, __arg_0: &mut __S) -> Result<(), <__S as Encoder>::Error> where`

__S: Encoder,

[src]

`fn encode<__S>(&self, __arg_0: &mut __S) -> Result<(), <__S as Encoder>::Error> where`

__S: Encoder,

Serialize a value using an `Encoder`

.

`impl PartialOrd<BigInt> for BigInt`

[src]

`impl PartialOrd<BigInt> for BigInt`

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

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

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

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

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

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

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

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

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

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

`impl Octal for BigInt`

[src]

`impl Octal for BigInt`

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

[src]

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

Formats the value using the given formatter.

`impl One for BigInt`

[src]

`impl One for BigInt`

`fn one() -> BigInt`

[src]

`fn one() -> BigInt`

Returns the multiplicative identity element of `Self`

, `1`

. Read more

`fn is_one(&self) -> bool where`

Self: PartialEq<Self>,

[src]

`fn is_one(&self) -> bool where`

Self: PartialEq<Self>,

Returns `true`

if `self`

is equal to the multiplicative identity. Read more

`impl UpperHex for BigInt`

[src]

`impl UpperHex for BigInt`

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

[src]

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

Formats the value using the given formatter.

`impl ToBigUint for BigInt`

[src]

`impl ToBigUint for BigInt`

`fn to_biguint(&self) -> Option<BigUint>`

[src]

`fn to_biguint(&self) -> Option<BigUint>`

Converts the value of `self`

to a `BigUint`

.

`impl Add<i8> for BigInt`

[src]

`impl Add<i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i8) -> BigInt`

[src]

`fn add(self, other: i8) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for u32`

[src]

`impl Add<BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for BigInt`

[src]

`impl Add<BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for u64`

[src]

`impl<'a> Add<&'a BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b u32`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b u32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b i32> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i32) -> BigInt`

[src]

`fn add(self, other: &i32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<isize> for &'a BigInt`

[src]

`impl<'a> Add<isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: isize) -> BigInt`

[src]

`fn add(self, other: isize) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a u64`

[src]

`impl<'a> Add<BigInt> for &'a u64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b i64`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b i64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<i8> for &'a BigInt`

[src]

`impl<'a> Add<i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i8) -> BigInt`

[src]

`fn add(self, other: i8) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for i32`

[src]

`impl<'a> Add<&'a BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<u32> for BigInt`

[src]

`impl Add<u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u32) -> BigInt`

[src]

`fn add(self, other: u32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a u64> for BigInt`

[src]

`impl<'a> Add<&'a u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u64) -> BigInt`

[src]

`fn add(self, other: &u64) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for u16`

[src]

`impl Add<BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a u8> for BigInt`

[src]

`impl<'a> Add<&'a u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u8) -> BigInt`

[src]

`fn add(self, other: &u8) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b u8> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u8) -> BigInt`

[src]

`fn add(self, other: &u8) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for BigInt`

[src]

`impl<'a> Add<&'a BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b isize> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &isize) -> BigInt`

[src]

`fn add(self, other: &isize) -> BigInt`

Performs the `+`

operation.

`impl Add<u16> for BigInt`

[src]

`impl Add<u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u16) -> BigInt`

[src]

`fn add(self, other: u16) -> BigInt`

Performs the `+`

operation.

`impl Add<i32> for BigInt`

[src]

`impl Add<i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i32) -> BigInt`

[src]

`fn add(self, other: i32) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b i32`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b i32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<u64> for BigInt`

[src]

`impl Add<u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u64) -> BigInt`

[src]

`fn add(self, other: u64) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b u32> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u32) -> BigInt`

[src]

`fn add(self, other: &u32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<u32> for &'a BigInt`

[src]

`impl<'a> Add<u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u32) -> BigInt`

[src]

`fn add(self, other: u32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a u32> for BigInt`

[src]

`impl<'a> Add<&'a u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u32) -> BigInt`

[src]

`fn add(self, other: &u32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a i32`

[src]

`impl<'a> Add<BigInt> for &'a i32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<u64> for &'a BigInt`

[src]

`impl<'a> Add<u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u64) -> BigInt`

[src]

`fn add(self, other: u64) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for i16`

[src]

`impl<'a> Add<&'a BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b i64> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i64) -> BigInt`

[src]

`fn add(self, other: &i64) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b usize> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &usize) -> BigInt`

[src]

`fn add(self, other: &usize) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a u16`

[src]

`impl<'a> Add<BigInt> for &'a u16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a i64`

[src]

`impl<'a> Add<BigInt> for &'a i64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for isize`

[src]

`impl<'a> Add<&'a BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for u8`

[src]

`impl Add<BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b BigInt> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for i8`

[src]

`impl<'a> Add<&'a BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a i8> for BigInt`

[src]

`impl<'a> Add<&'a i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i8) -> BigInt`

[src]

`fn add(self, other: &i8) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for i64`

[src]

`impl<'a> Add<&'a BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for i32`

[src]

`impl Add<BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<isize> for BigInt`

[src]

`impl Add<isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: isize) -> BigInt`

[src]

`fn add(self, other: isize) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<i64> for &'a BigInt`

[src]

`impl<'a> Add<i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i64) -> BigInt`

[src]

`fn add(self, other: i64) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for usize`

[src]

`impl<'a> Add<&'a BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for u32`

[src]

`impl<'a> Add<&'a BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b u8`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b u8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a u8`

[src]

`impl<'a> Add<BigInt> for &'a u8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a BigInt`

[src]

`impl<'a> Add<BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a u32`

[src]

`impl<'a> Add<BigInt> for &'a u32`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a isize> for BigInt`

[src]

`impl<'a> Add<&'a isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &isize) -> BigInt`

[src]

`fn add(self, other: &isize) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<i32> for &'a BigInt`

[src]

`impl<'a> Add<i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i32) -> BigInt`

[src]

`fn add(self, other: i32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<u16> for &'a BigInt`

[src]

`impl<'a> Add<u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u16) -> BigInt`

[src]

`fn add(self, other: u16) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b u16> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u16) -> BigInt`

[src]

`fn add(self, other: &u16) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a i64> for BigInt`

[src]

`impl<'a> Add<&'a i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i64) -> BigInt`

[src]

`fn add(self, other: &i64) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b u16`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b u16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for i16`

[src]

`impl Add<BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for u16`

[src]

`impl<'a> Add<&'a BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a i32> for BigInt`

[src]

`impl<'a> Add<&'a i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i32) -> BigInt`

[src]

`fn add(self, other: &i32) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a i16> for BigInt`

[src]

`impl<'a> Add<&'a i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i16) -> BigInt`

[src]

`fn add(self, other: &i16) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a BigInt> for u8`

[src]

`impl<'a> Add<&'a BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for u64`

[src]

`impl Add<BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for i64`

[src]

`impl Add<BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b isize`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b isize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b usize`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b usize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a i16`

[src]

`impl<'a> Add<BigInt> for &'a i16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for usize`

[src]

`impl Add<BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<i16> for &'a BigInt`

[src]

`impl<'a> Add<i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i16) -> BigInt`

[src]

`fn add(self, other: i16) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a usize`

[src]

`impl<'a> Add<BigInt> for &'a usize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a i8`

[src]

`impl<'a> Add<BigInt> for &'a i8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<u8> for &'a BigInt`

[src]

`impl<'a> Add<u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u8) -> BigInt`

[src]

`fn add(self, other: u8) -> BigInt`

Performs the `+`

operation.

`impl Add<i64> for BigInt`

[src]

`impl Add<i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i64) -> BigInt`

[src]

`fn add(self, other: i64) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b i8`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b i8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<u8> for BigInt`

[src]

`impl Add<u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: u8) -> BigInt`

[src]

`fn add(self, other: u8) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b u64`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b u64`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a usize> for BigInt`

[src]

`impl<'a> Add<&'a usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &usize) -> BigInt`

[src]

`fn add(self, other: &usize) -> BigInt`

Performs the `+`

operation.

`impl Add<i16> for BigInt`

[src]

`impl Add<i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: i16) -> BigInt`

[src]

`fn add(self, other: i16) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b i16> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i16) -> BigInt`

[src]

`fn add(self, other: &i16) -> BigInt`

Performs the `+`

operation.

`impl Add<usize> for BigInt`

[src]

`impl Add<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: usize) -> BigInt`

[src]

`fn add(self, other: usize) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b i8> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &i8) -> BigInt`

[src]

`fn add(self, other: &i8) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for i8`

[src]

`impl Add<BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl Add<BigInt> for isize`

[src]

`impl Add<BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<&'a u16> for BigInt`

[src]

`impl<'a> Add<&'a u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u16) -> BigInt`

[src]

`fn add(self, other: &u16) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'a BigInt> for &'b i16`

[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b i16`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &BigInt) -> BigInt`

[src]

`fn add(self, other: &BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<BigInt> for &'a isize`

[src]

`impl<'a> Add<BigInt> for &'a isize`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: BigInt) -> BigInt`

[src]

`fn add(self, other: BigInt) -> BigInt`

Performs the `+`

operation.

`impl<'a, 'b> Add<&'b u64> for &'a BigInt`

[src]

`impl<'a, 'b> Add<&'b u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: &u64) -> BigInt`

[src]

`fn add(self, other: &u64) -> BigInt`

Performs the `+`

operation.

`impl<'a> Add<usize> for &'a BigInt`

[src]

`impl<'a> Add<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `+`

operator.

`fn add(self, other: usize) -> BigInt`

[src]

`fn add(self, other: usize) -> BigInt`

Performs the `+`

operation.

`impl From<i16> for BigInt`

[src]

`impl From<i16> for BigInt`

`impl From<isize> for BigInt`

[src]

`impl From<isize> for BigInt`

`impl From<u32> for BigInt`

[src]

`impl From<u32> for BigInt`

`impl From<u64> for BigInt`

[src]

`impl From<u64> for BigInt`

`impl From<i32> for BigInt`

[src]

`impl From<i32> for BigInt`

`impl From<u8> for BigInt`

[src]

`impl From<u8> for BigInt`

`impl From<usize> for BigInt`

[src]

`impl From<usize> for BigInt`

`impl From<BigUint> for BigInt`

[src]

`impl From<BigUint> for BigInt`

`impl From<i64> for BigInt`

[src]

`impl From<i64> for BigInt`

`impl From<i8> for BigInt`

[src]

`impl From<i8> for BigInt`

`impl From<u16> for BigInt`

[src]

`impl From<u16> for BigInt`

`impl<'a> Shr<usize> for &'a BigInt`

[src]

`impl<'a> Shr<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: usize) -> BigInt`

[src]

`fn shr(self, rhs: usize) -> BigInt`

Performs the `>>`

operation.

`impl Shr<usize> for BigInt`

[src]

`impl Shr<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: usize) -> BigInt`

[src]

`fn shr(self, rhs: usize) -> BigInt`

Performs the `>>`

operation.

`impl Ord for BigInt`

[src]

`impl Ord for BigInt`

`fn cmp(&self, other: &BigInt) -> Ordering`

[src]

`fn cmp(&self, other: &BigInt) -> Ordering`

This method returns an `Ordering`

between `self`

and `other`

. Read more

`fn max(self, other: Self) -> Self`

1.21.0[src]

`fn max(self, other: Self) -> Self`

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`

1.21.0[src]

`fn min(self, other: Self) -> Self`

Compares and returns the minimum of two values. Read more

`impl<'a, 'b> Sub<&'a BigInt> for &'b i64`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b i64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for i16`

[src]

`impl Sub<BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<u16> for BigInt`

[src]

`impl Sub<u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u16) -> BigInt`

[src]

`fn sub(self, other: u16) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b i32`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b i32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a u16`

[src]

`impl<'a> Sub<BigInt> for &'a u16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for u64`

[src]

`impl Sub<BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<i64> for &'a BigInt`

[src]

`impl<'a> Sub<i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i64) -> BigInt`

[src]

`fn sub(self, other: i64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a isize`

[src]

`impl<'a> Sub<BigInt> for &'a isize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a i32> for BigInt`

[src]

`impl<'a> Sub<&'a i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i32) -> BigInt`

[src]

`fn sub(self, other: &i32) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b isize> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &isize) -> BigInt`

[src]

`fn sub(self, other: &isize) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for i32`

[src]

`impl Sub<BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<u8> for BigInt`

[src]

`impl Sub<u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u8) -> BigInt`

[src]

`fn sub(self, other: u8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<u32> for &'a BigInt`

[src]

`impl<'a> Sub<u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u32) -> BigInt`

[src]

`fn sub(self, other: u32) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b isize`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b isize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a u8> for BigInt`

[src]

`impl<'a> Sub<&'a u8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u8) -> BigInt`

[src]

`fn sub(self, other: &u8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a i32`

[src]

`impl<'a> Sub<BigInt> for &'a i32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for i16`

[src]

`impl<'a> Sub<&'a BigInt> for i16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<i8> for BigInt`

[src]

`impl Sub<i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i8) -> BigInt`

[src]

`fn sub(self, other: i8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for i32`

[src]

`impl<'a> Sub<&'a BigInt> for i32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for u32`

[src]

`impl Sub<BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a i64> for BigInt`

[src]

`impl<'a> Sub<&'a i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i64) -> BigInt`

[src]

`fn sub(self, other: &i64) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b usize> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &usize) -> BigInt`

[src]

`fn sub(self, other: &usize) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<usize> for &'a BigInt`

[src]

`impl<'a> Sub<usize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: usize) -> BigInt`

[src]

`fn sub(self, other: usize) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for u64`

[src]

`impl<'a> Sub<&'a BigInt> for u64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<i16> for BigInt`

[src]

`impl Sub<i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i16) -> BigInt`

[src]

`fn sub(self, other: i16) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<u64> for &'a BigInt`

[src]

`impl<'a> Sub<u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u64) -> BigInt`

[src]

`fn sub(self, other: u64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<isize> for &'a BigInt`

[src]

`impl<'a> Sub<isize> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: isize) -> BigInt`

[src]

`fn sub(self, other: isize) -> BigInt`

Performs the `-`

operation.

`impl Sub<i64> for BigInt`

[src]

`impl Sub<i64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i64) -> BigInt`

[src]

`fn sub(self, other: i64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a i16`

[src]

`impl<'a> Sub<BigInt> for &'a i16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b usize`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b usize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a i8> for BigInt`

[src]

`impl<'a> Sub<&'a i8> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i8) -> BigInt`

[src]

`fn sub(self, other: &i8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for BigInt`

[src]

`impl<'a> Sub<&'a BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a BigInt`

[src]

`impl<'a> Sub<BigInt> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for BigInt`

[src]

`impl Sub<BigInt> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<u32> for BigInt`

[src]

`impl Sub<u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u32) -> BigInt`

[src]

`fn sub(self, other: u32) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b u64`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b u64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for isize`

[src]

`impl<'a> Sub<&'a BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<i32> for BigInt`

[src]

`impl Sub<i32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i32) -> BigInt`

[src]

`fn sub(self, other: i32) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b i16`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b i16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<u16> for &'a BigInt`

[src]

`impl<'a> Sub<u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u16) -> BigInt`

[src]

`fn sub(self, other: u16) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b i16> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i16) -> BigInt`

[src]

`fn sub(self, other: &i16) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for usize`

[src]

`impl Sub<BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b u32`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b u32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b i8`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b i8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b i8> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i8) -> BigInt`

[src]

`fn sub(self, other: &i8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for i8`

[src]

`impl<'a> Sub<&'a BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for i8`

[src]

`impl Sub<BigInt> for i8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a i64`

[src]

`impl<'a> Sub<BigInt> for &'a i64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<i16> for &'a BigInt`

[src]

`impl<'a> Sub<i16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i16) -> BigInt`

[src]

`fn sub(self, other: i16) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a u32> for BigInt`

[src]

`impl<'a> Sub<&'a u32> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u32) -> BigInt`

[src]

`fn sub(self, other: &u32) -> BigInt`

Performs the `-`

operation.

`impl Sub<isize> for BigInt`

[src]

`impl Sub<isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: isize) -> BigInt`

[src]

`fn sub(self, other: isize) -> BigInt`

Performs the `-`

operation.

`impl Sub<u64> for BigInt`

[src]

`impl Sub<u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u64) -> BigInt`

[src]

`fn sub(self, other: u64) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for u16`

[src]

`impl Sub<BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a u32`

[src]

`impl<'a> Sub<BigInt> for &'a u32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a usize> for BigInt`

[src]

`impl<'a> Sub<&'a usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &usize) -> BigInt`

[src]

`fn sub(self, other: &usize) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b u8`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b u8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for u8`

[src]

`impl Sub<BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for u32`

[src]

`impl<'a> Sub<&'a BigInt> for u32`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for u16`

[src]

`impl<'a> Sub<&'a BigInt> for u16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'a BigInt> for &'b u16`

[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b u16`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for u8`

[src]

`impl<'a> Sub<&'a BigInt> for u8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b u16> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b u16> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u16) -> BigInt`

[src]

`fn sub(self, other: &u16) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a u64`

[src]

`impl<'a> Sub<BigInt> for &'a u64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl Sub<usize> for BigInt`

[src]

`impl Sub<usize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: usize) -> BigInt`

[src]

`fn sub(self, other: usize) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a i8`

[src]

`impl<'a> Sub<BigInt> for &'a i8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<i8> for &'a BigInt`

[src]

`impl<'a> Sub<i8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i8) -> BigInt`

[src]

`fn sub(self, other: i8) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<i32> for &'a BigInt`

[src]

`impl<'a> Sub<i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: i32) -> BigInt`

[src]

`fn sub(self, other: i32) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b u8> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u8) -> BigInt`

[src]

`fn sub(self, other: &u8) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b i64> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b i64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i64) -> BigInt`

[src]

`fn sub(self, other: &i64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a usize`

[src]

`impl<'a> Sub<BigInt> for &'a usize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for i64`

[src]

`impl<'a> Sub<&'a BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b u64> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b u64> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u64) -> BigInt`

[src]

`fn sub(self, other: &u64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a i16> for BigInt`

[src]

`impl<'a> Sub<&'a i16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i16) -> BigInt`

[src]

`fn sub(self, other: &i16) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for isize`

[src]

`impl Sub<BigInt> for isize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b i32> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b i32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &i32) -> BigInt`

[src]

`fn sub(self, other: &i32) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a BigInt> for usize`

[src]

`impl<'a> Sub<&'a BigInt> for usize`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &BigInt) -> BigInt`

[src]

`fn sub(self, other: &BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a u64> for BigInt`

[src]

`impl<'a> Sub<&'a u64> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u64) -> BigInt`

[src]

`fn sub(self, other: &u64) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<u8> for &'a BigInt`

[src]

`impl<'a> Sub<u8> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: u8) -> BigInt`

[src]

`fn sub(self, other: u8) -> BigInt`

Performs the `-`

operation.

`impl<'a, 'b> Sub<&'b u32> for &'a BigInt`

[src]

`impl<'a, 'b> Sub<&'b u32> for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u32) -> BigInt`

[src]

`fn sub(self, other: &u32) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a u16> for BigInt`

[src]

`impl<'a> Sub<&'a u16> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &u16) -> BigInt`

[src]

`fn sub(self, other: &u16) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<BigInt> for &'a u8`

[src]

`impl<'a> Sub<BigInt> for &'a u8`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl<'a> Sub<&'a isize> for BigInt`

[src]

`impl<'a> Sub<&'a isize> for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: &isize) -> BigInt`

[src]

`fn sub(self, other: &isize) -> BigInt`

Performs the `-`

operation.

`impl Sub<BigInt> for i64`

[src]

`impl Sub<BigInt> for i64`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn sub(self, other: BigInt) -> BigInt`

[src]

`fn sub(self, other: BigInt) -> BigInt`

Performs the `-`

operation.

`impl PartialEq<BigInt> for BigInt`

[src]

`impl PartialEq<BigInt> for BigInt`

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

[src]

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

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

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

This method tests for `!=`

.

`impl Display for BigInt`

[src]

`impl Display for BigInt`

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

[src]

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

Formats the value using the given formatter. Read more

`impl Default for BigInt`

[src]

`impl Default for BigInt`

`impl Neg for BigInt`

[src]

`impl Neg for BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn neg(self) -> BigInt`

[src]

`fn neg(self) -> BigInt`

Performs the unary `-`

operation.

`impl<'a> Neg for &'a BigInt`

[src]

`impl<'a> Neg for &'a BigInt`

`type Output = BigInt`

The resulting type after applying the `-`

operator.

`fn neg(self) -> BigInt`

[src]

`fn neg(self) -> BigInt`

Performs the unary `-`

operation.

`impl Integer for BigInt`

[src]

`impl Integer for BigInt`

`fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt)`

[src]

`fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt)`

Simultaneous truncated integer division and modulus. Returns `(quotient, remainder)`

. Read more

`fn div_floor(&self, other: &BigInt) -> BigInt`

[src]

`fn div_floor(&self, other: &BigInt) -> BigInt`

Floored integer division. Read more

`fn mod_floor(&self, other: &BigInt) -> BigInt`

[src]

`fn mod_floor(&self, other: &BigInt) -> BigInt`

Floored integer modulo, satisfying: Read more

`fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt)`

[src]

`fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt)`

Simultaneous floored integer division and modulus. Returns `(quotient, remainder)`

. Read more

`fn gcd(&self, other: &BigInt) -> BigInt`

[src]

`fn gcd(&self, other: &BigInt) -> BigInt`

Calculates the Greatest Common Divisor (GCD) of the number and `other`

.

The result is always positive.

`fn lcm(&self, other: &BigInt) -> BigInt`

[src]

`fn lcm(&self, other: &BigInt) -> BigInt`

Calculates the Lowest Common Multiple (LCM) of the number and `other`

.

`fn divides(&self, other: &BigInt) -> bool`

[src]

`fn divides(&self, other: &BigInt) -> bool`

Deprecated, use `is_multiple_of`

instead.

`fn is_multiple_of(&self, other: &BigInt) -> bool`

[src]

`fn is_multiple_of(&self, other: &BigInt) -> bool`

Returns `true`

if the number is a multiple of `other`

.

`fn is_even(&self) -> bool`

[src]

`fn is_even(&self) -> bool`

Returns `true`

if the number is divisible by `2`

.

`fn is_odd(&self) -> bool`

[src]

`fn is_odd(&self) -> bool`

Returns `true`

if the number is not divisible by `2`

.

`impl CheckedSub for BigInt`

[src]

`impl CheckedSub for BigInt`