Type Alias mpf_s

pub type mpf_s = __mpf_struct;

mpf_s

Aliased Type

#[repr(C)]
pub struct mpf_s {
    pub _mp_prec: i32,
    pub _mp_size: i32,
    pub _mp_exp: i64,
    pub _mp_d: *mut u64,
}

Fields

_mp_prec: i32

_mp_prec

_mp_size: i32

_mp_size

_mp_exp: i64

_mp_exp

_mp_d: *mut u64

_mp_d

Trait Implementations

impl<'a, 'b> Add<&'b __mpf_struct> for &'a mpf_s

impl Add for mpf_r

fn add(self, rhs: &'b mpf_s) -> <mpf_s as Add<mpf_s>>::Output

add mpf_r + mpf_r

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn add(self, rhs: &'b mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<&'a __mpf_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn add(self, rhs: &'a mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b mut __mpf_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn add(self, rhs: &'b mut mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn add(self, rhs: &'b mut mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn add(self, rhs: &'a mut mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b mut u64> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn add(self, rhs: &'b mut ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn add(self, rhs: &'b mut ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a> Add<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn add(self, rhs: &'a mut ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b u64> for &'a mpf_s

impl Add for mpf_r

fn add(self, rhs: &'b ui_t) -> <mpf_s as Add<ui_t>>::Output

add mpf_r + &ui_t

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn add(self, rhs: &'b ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a> Add<&'a u64> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn add(self, rhs: &'a ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a> Add<__mpf_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn add(self, rhs: mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn add(self, rhs: mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<u64> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn add(self, rhs: ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl<'a> Add<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn add(self, rhs: ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Add<u64>>::Output

The resulting type after applying the + operator.

impl Add<u64> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn add(self, rhs: ui_t) -> <mpf_s as Add<ui_t>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the + operator.

impl Add for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn add(self, rhs: mpf_s) -> <mpf_s as Add<mpf_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the + operator.

impl<'a, 'b> AddAssign<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: &'b mpf_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> AddAssign<&'a __mpf_struct> for mpf_s

impl AddAssign for mpf_s

fn add_assign(&mut self, rhs: &'a Self)

add_assign mpf_s += mpf_r

impl<'a, 'b> AddAssign<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: &'b mut mpf_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> AddAssign<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn add_assign(&mut self, rhs: &'a mut mpf_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> AddAssign<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: &'b mut ui_t)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> AddAssign<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn add_assign(&mut self, rhs: &'a mut ui_t)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> AddAssign<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: &'b ui_t)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> AddAssign<&'a u64> for mpf_s

impl AddAssign for mpf_s

fn add_assign(&mut self, rhs: &'a ui_t)

addassign mpf_s += &ui_t

impl<'a> AddAssign<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: mpf_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl<'a> AddAssign<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn add_assign(&mut self, rhs: ui_t)

‘$imp’ &mut ‘$t’ ‘$u’

impl AddAssign<u64> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn add_assign(&mut self, rhs: ui_t)

‘$imp’ ‘$t’ ‘$u’

impl AddAssign for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn add_assign(&mut self, rhs: mpf_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a, 'b> Div<&'b __mpf_struct> for &'a mpf_s

impl Div for mpf_r

fn div(self, rhs: &'b mpf_s) -> <mpf_s as Div<mpf_s>>::Output

div mpf_r / mpf_r

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a __mpf_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn div(self, rhs: &'a mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b __mpq_struct> for &'a mpf_s

impl Div for mpf_r

fn div(self, rhs: &'b mpq_s) -> <mpf_s as Div<mpq_s>>::Output

div mpf_r / mpq_r

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a __mpq_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn div(self, rhs: &'a mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b __mpz_struct> for &'a mpf_s

impl Div for mpf_r

fn div(self, rhs: &'b mpz_s) -> <mpf_s as Div<mpz_s>>::Output

div mpf_r / mpz_r

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a __mpz_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn div(self, rhs: &'a mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpf_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn div(self, rhs: &'b mut mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mut mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn div(self, rhs: &'a mut mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpq_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn div(self, rhs: &'b mut mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mut mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a mut __mpq_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn div(self, rhs: &'a mut mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpz_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn div(self, rhs: &'b mut mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mut mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a mut __mpz_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn div(self, rhs: &'a mut mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut u64> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn div(self, rhs: &'b mut ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b mut ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn div(self, rhs: &'a mut ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b u64> for &'a mpf_s

impl Div for mpf_r

fn div(self, rhs: &'b ui_t) -> <mpf_s as Div<ui_t>>::Output

div mpf_r / &ui_t

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn div(self, rhs: &'b ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a> Div<&'a u64> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn div(self, rhs: &'a ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a> Div<__mpf_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn div(self, rhs: mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a> Div<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn div(self, rhs: mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Div>::Output

The resulting type after applying the / operator.

impl<'a> Div<__mpq_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn div(self, rhs: mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<__mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn div(self, rhs: mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Div<__mpq_struct>>::Output

The resulting type after applying the / operator.

impl Div<__mpq_struct> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn div(self, rhs: mpq_s) -> <mpf_s as Div<mpq_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the / operator.

impl<'a> Div<__mpz_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn div(self, rhs: mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl<'a> Div<__mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn div(self, rhs: mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Div<__mpz_struct>>::Output

The resulting type after applying the / operator.

impl Div<__mpz_struct> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn div(self, rhs: mpz_s) -> <mpf_s as Div<mpz_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the / operator.

impl<'a> Div<u64> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn div(self, rhs: ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl<'a> Div<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn div(self, rhs: ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Div<u64>>::Output

The resulting type after applying the / operator.

impl Div<u64> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn div(self, rhs: ui_t) -> <mpf_s as Div<ui_t>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the / operator.

impl Div for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn div(self, rhs: mpf_s) -> <mpf_s as Div<mpf_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the / operator.

impl<'a, 'b> DivAssign<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mpf_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> DivAssign<&'a __mpf_struct> for mpf_s

impl DivAssign for mpf_s

fn div_assign(&mut self, rhs: &'a Self)

div_assign mpf_s /= mpf_r

impl<'a, 'b> DivAssign<&'b __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mpq_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> DivAssign<&'a __mpq_struct> for mpf_s

impl DivAssign for mpf_s

fn div_assign(&mut self, rhs: &'a mpq_s)

div_assign mpf_s /= mpq_r

impl<'a, 'b> DivAssign<&'b __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mpz_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> DivAssign<&'a __mpz_struct> for mpf_s

impl DivAssign for mpf_s

fn div_assign(&mut self, rhs: &'a mpz_s)

div_assign mpf_s /= mpz_r

impl<'a, 'b> DivAssign<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mut mpf_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> DivAssign<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn div_assign(&mut self, rhs: &'a mut mpf_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> DivAssign<&'b mut __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mut mpq_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> DivAssign<&'a mut __mpq_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn div_assign(&mut self, rhs: &'a mut mpq_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> DivAssign<&'b mut __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mut mpz_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> DivAssign<&'a mut __mpz_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn div_assign(&mut self, rhs: &'a mut mpz_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> DivAssign<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b mut ui_t)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> DivAssign<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn div_assign(&mut self, rhs: &'a mut ui_t)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> DivAssign<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: &'b ui_t)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> DivAssign<&'a u64> for mpf_s

impl DivAssign for mpf_s

fn div_assign(&mut self, rhs: &'a ui_t)

div_assign mpf_s /= &ui_t

impl<'a> DivAssign<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: mpf_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl<'a> DivAssign<__mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: mpq_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl DivAssign<__mpq_struct> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn div_assign(&mut self, rhs: mpq_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> DivAssign<__mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: mpz_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl DivAssign<__mpz_struct> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn div_assign(&mut self, rhs: mpz_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> DivAssign<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn div_assign(&mut self, rhs: ui_t)

‘$imp’ &mut ‘$t’ ‘$u’

impl DivAssign<u64> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn div_assign(&mut self, rhs: ui_t)

‘$imp’ ‘$t’ ‘$u’

impl DivAssign for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn div_assign(&mut self, rhs: mpf_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> From<&'a __mpf_struct> for mpf_s

mpf_s from mpf_r

fn from(f: &'a mpf_s) -> Self

mpf_s from mpf_r

impl<'a> From<&'a __mpq_struct> for mpf_s

mpf_s from mpq_r

fn from(q: &'a mpq_s) -> Self

mpf_s from mpq_r

impl<'a> From<&'a __mpz_struct> for mpf_s

mpf_s from mpz_r

fn from(a: &'a mpz_s) -> Self

mpf_s from mpz_r

impl<'a> From<&'a mut __mpf_struct> for mpf_s

impl ‘$imp<&mut $u>’ for ‘$t’

fn from(rhs: &'a mut mpf_s) -> Self

‘$t’ from ‘& mut $u’

impl<'a> From<&'a mut __mpq_struct> for mpf_s

impl ‘$imp<&mut $u>’ for ‘$t’

fn from(rhs: &'a mut mpq_s) -> Self

‘$t’ from ‘& mut $u’

impl<'a> From<&'a mut __mpz_struct> for mpf_s

impl ‘$imp<&mut $u>’ for ‘$t’

fn from(rhs: &'a mut mpz_s) -> Self

‘$t’ from ‘& mut $u’

impl<'a> From<&'a str> for mpf_s

mpf_s from &str

fn from(s: &'a str) -> Self

mpf_s from &str

impl From<__mpq_struct> for mpf_s

impl ‘$imp<$u>’ for ‘$t’

fn from(rhs: mpq_s) -> Self

‘$t’ from ‘$u’

impl From<__mpz_struct> for mpf_s

impl ‘$imp<$u>’ for ‘$t’

fn from(rhs: mpz_s) -> Self

‘$t’ from ‘$u’

impl From<f64> for mpf_s

mpf_s from double_t

fn from(d: double_t) -> Self

mpf_s from double_t

impl From<i64> for mpf_s

mpf_s from si_t

fn from(s: si_t) -> Self

mpf_s from si_t

impl From<u64> for mpf_s

mpf_s from ui_t

fn from(u: ui_t) -> Self

mpf_s from ui_t

impl<'a, 'b> Mul<&'b __mpf_struct> for &'a mpf_s

impl Mul for mpf_r

fn mul(self, rhs: &'b mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

mul mpf_r * mpf_r

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a __mpf_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn mul(self, rhs: &'a mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b __mpq_struct> for &'a mpf_s

impl Mul for mpf_r

fn mul(self, rhs: &'b mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

mul mpf_r * mpq_r

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a __mpq_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn mul(self, rhs: &'a mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b __mpz_struct> for &'a mpf_s

impl Mul for mpf_r

fn mul(self, rhs: &'b mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

mul mpf_r * mpz_r

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a __mpz_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn mul(self, rhs: &'a mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpf_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn mul(self, rhs: &'b mut mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mut mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn mul(self, rhs: &'a mut mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpq_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn mul(self, rhs: &'b mut mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mut mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a mut __mpq_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn mul(self, rhs: &'a mut mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpz_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn mul(self, rhs: &'b mut mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mut mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a mut __mpz_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn mul(self, rhs: &'a mut mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut u64> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn mul(self, rhs: &'b mut ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b mut ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn mul(self, rhs: &'a mut ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b u64> for &'a mpf_s

impl Mul for mpf_r

fn mul(self, rhs: &'b ui_t) -> <mpf_s as Mul<ui_t>>::Output

mul mpf_r * &ui_t

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn mul(self, rhs: &'b ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<&'a u64> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn mul(self, rhs: &'a ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<__mpf_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn mul(self, rhs: mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a> Mul<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn mul(self, rhs: mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Mul>::Output

The resulting type after applying the * operator.

impl<'a> Mul<__mpq_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn mul(self, rhs: mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<__mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn mul(self, rhs: mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Mul<__mpq_struct>>::Output

The resulting type after applying the * operator.

impl Mul<__mpq_struct> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn mul(self, rhs: mpq_s) -> <mpf_s as Mul<mpq_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the * operator.

impl<'a> Mul<__mpz_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn mul(self, rhs: mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<__mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn mul(self, rhs: mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Mul<__mpz_struct>>::Output

The resulting type after applying the * operator.

impl Mul<__mpz_struct> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn mul(self, rhs: mpz_s) -> <mpf_s as Mul<mpz_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the * operator.

impl<'a> Mul<u64> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn mul(self, rhs: ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl<'a> Mul<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn mul(self, rhs: ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Mul<u64>>::Output

The resulting type after applying the * operator.

impl Mul<u64> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn mul(self, rhs: ui_t) -> <mpf_s as Mul<ui_t>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the * operator.

impl Mul for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn mul(self, rhs: mpf_s) -> <mpf_s as Mul<mpf_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the * operator.

impl<'a, 'b> MulAssign<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mpf_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> MulAssign<&'a __mpf_struct> for mpf_s

impl MulAssign for mpf_s

fn mul_assign(&mut self, rhs: &'a Self)

mul_assign mpf_s *= mpf_r

impl<'a, 'b> MulAssign<&'b __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mpq_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> MulAssign<&'a __mpq_struct> for mpf_s

impl MulAssign for mpf_s

fn mul_assign(&mut self, rhs: &'a mpq_s)

mul_assign mpf_s *= mpq_r

impl<'a, 'b> MulAssign<&'b __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mpz_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> MulAssign<&'a __mpz_struct> for mpf_s

impl MulAssign for mpf_s

fn mul_assign(&mut self, rhs: &'a mpz_s)

mul_assign mpf_s *= mpz_r

impl<'a, 'b> MulAssign<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mut mpf_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> MulAssign<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn mul_assign(&mut self, rhs: &'a mut mpf_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> MulAssign<&'b mut __mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mut mpq_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> MulAssign<&'a mut __mpq_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn mul_assign(&mut self, rhs: &'a mut mpq_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> MulAssign<&'b mut __mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mut mpz_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> MulAssign<&'a mut __mpz_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn mul_assign(&mut self, rhs: &'a mut mpz_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> MulAssign<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b mut ui_t)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> MulAssign<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn mul_assign(&mut self, rhs: &'a mut ui_t)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> MulAssign<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: &'b ui_t)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> MulAssign<&'a u64> for mpf_s

impl MulAssign for mpf_s

fn mul_assign(&mut self, rhs: &'a ui_t)

mul_assign mpf_s *= &ui_t

impl<'a> MulAssign<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: mpf_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl<'a> MulAssign<__mpq_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: mpq_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl MulAssign<__mpq_struct> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn mul_assign(&mut self, rhs: mpq_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> MulAssign<__mpz_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: mpz_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl MulAssign<__mpz_struct> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn mul_assign(&mut self, rhs: mpz_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> MulAssign<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn mul_assign(&mut self, rhs: ui_t)

‘$imp’ &mut ‘$t’ ‘$u’

impl MulAssign<u64> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn mul_assign(&mut self, rhs: ui_t)

‘$imp’ ‘$t’ ‘$u’

impl MulAssign for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn mul_assign(&mut self, rhs: mpf_s)

‘$imp’ ‘$t’ ‘$u’

impl<'a> Neg for &'a mpf_s

impl Neg for mpf_r

fn neg(self) -> <mpf_s as Neg>::Output

neg mpf_r

type Output = <__mpf_struct as Neg>::Output

The resulting type after applying the - operator.

impl<'a> Neg for &'a mut mpf_s

impl ‘$imp’ for ‘&mut $t’

fn neg(self) -> <mpf_s as Neg>::Output

‘$imp’ ‘&mut $t’

type Output = <__mpf_struct as Neg>::Output

The resulting type after applying the - operator.

impl Neg for mpf_s

impl ‘$imp’ for ‘$t’

fn neg(self) -> Self

‘$imp’ ‘$t’

type Output = __mpf_struct

The resulting type after applying the - operator.

impl<'a> PartialEq<&__mpz_struct> for &'a mpf_s

impl $imp<$u> for &$t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_r<'_>) -> bool

eq &$t == $u

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

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

impl<'a> PartialEq<&__mpz_struct> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_r<'_>) -> bool

eq &mut $t == $u

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

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

impl PartialEq<&__mpz_struct> for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_r<'_>) -> bool

eq $t == $u

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

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

impl<'a> PartialEq<&mut __mpz_struct> for &'a mpf_s

impl $imp<$u> for &$t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_t<'_>) -> bool

eq &$t == $u

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

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

impl<'a> PartialEq<&mut __mpz_struct> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_t<'_>) -> bool

eq &mut $t == $u

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

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

impl PartialEq<&mut __mpz_struct> for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpz_t<'_>) -> bool

eq $t == $u

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

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

impl<'a> PartialEq<__mpf_struct> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpf_s) -> bool

eq &mut $t == $u

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

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

impl<'a> PartialEq<f64> for &'a mpf_s

impl $imp<$u> for &$t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &double_t) -> bool

eq &$t == $u

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

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

impl<'a> PartialEq<f64> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &double_t) -> bool

eq &mut $t == $u

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

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

impl PartialEq<f64> for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &double_t) -> bool

eq $t == $u

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

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

impl<'a> PartialEq<i64> for &'a mpf_s

impl $imp<$u> for &$t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &si_t) -> bool

eq &$t == $u

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

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

impl<'a> PartialEq<i64> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &si_t) -> bool

eq &mut $t == $u

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

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

impl PartialEq<i64> for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &si_t) -> bool

eq $t == $u

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

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

impl<'a> PartialEq<u64> for &'a mpf_s

impl $imp<$u> for &$t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &ui_t) -> bool

eq &$t == $u

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

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

impl<'a> PartialEq<u64> for &'a mut mpf_s

impl $imp<$u> for &mut $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &ui_t) -> bool

eq &mut $t == $u

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

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

impl PartialEq<u64> for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &ui_t) -> bool

eq $t == $u

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

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

impl PartialEq for mpf_s

impl $imp<$u> for $t

• expect $imp as PartialEq or Eq

fn eq(&self, rhs: &mpf_s) -> bool

eq $t == $u

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

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

impl<'a> PartialOrd<&__mpz_struct> for &'a mpf_s

impl $imo<$u> for &$t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_r<'_>) -> Option<Ordering>

partial_cmp &$t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<&__mpz_struct> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_r<'_>) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<&__mpz_struct> for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_r<'_>) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<&mut __mpz_struct> for &'a mpf_s

impl $imo<$u> for &$t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_t<'_>) -> Option<Ordering>

partial_cmp &$t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<&mut __mpz_struct> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_t<'_>) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<&mut __mpz_struct> for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpz_t<'_>) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<__mpf_struct> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpf_s) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<f64> for &'a mpf_s

impl $imo<$u> for &$t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &double_t) -> Option<Ordering>

partial_cmp &$t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<f64> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &double_t) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<f64> for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &double_t) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<i64> for &'a mpf_s

impl $imo<$u> for &$t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &si_t) -> Option<Ordering>

partial_cmp &$t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<i64> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &si_t) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i64> for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &si_t) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<u64> for &'a mpf_s

impl $imo<$u> for &$t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &ui_t) -> Option<Ordering>

partial_cmp &$t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> PartialOrd<u64> for &'a mut mpf_s

impl $imo<$u> for &mut $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &ui_t) -> Option<Ordering>

partial_cmp &mut $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u64> for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &ui_t) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd for mpf_s

impl $imo<$u> for $t

• expect $imo as PartialOrd

fn partial_cmp(&self, rhs: &mpf_s) -> Option<Ordering>

partial_cmp $t - $u

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a, 'b> Sub<&'b __mpf_struct> for &'a mpf_s

impl Sub for mpf_r

fn sub(self, rhs: &'b mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

sub mpf_r - mpf_r

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn sub(self, rhs: &'b mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<&'a __mpf_struct> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn sub(self, rhs: &'a mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b mut __mpf_struct> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn sub(self, rhs: &'b mut mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn sub(self, rhs: &'b mut mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn sub(self, rhs: &'a mut mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b mut u64> for &'a mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&$t’

fn sub(self, rhs: &'b mut ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘&$t’ ‘&mut $u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘&mut $t’

fn sub(self, rhs: &'b mut ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&mut $u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a> Sub<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’$gt; for ‘$t’

fn sub(self, rhs: &'a mut ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘$t’ ‘&mut $u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b u64> for &'a mpf_s

impl Sub for mpf_r

fn sub(self, rhs: &'b ui_t) -> <mpf_s as Sub<ui_t>>::Output

sub mpf_r - &ui_t

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘&mut $t’

fn sub(self, rhs: &'b ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘&$u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a> Sub<&'a u64> for mpf_s

impl ‘$imp’<‘&$u’$gt; for ‘$t’

fn sub(self, rhs: &'a ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘$t’ ‘&$u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a> Sub<__mpf_struct> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn sub(self, rhs: mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn sub(self, rhs: mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<u64> for &'a mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&$t’

fn sub(self, rhs: ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘&$t’ ‘$u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl<'a> Sub<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’$gt; for ‘&mut $t’

fn sub(self, rhs: ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘&mut $t’ ‘$u’

type Output = <__mpf_struct as Sub<u64>>::Output

The resulting type after applying the - operator.

impl Sub<u64> for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn sub(self, rhs: ui_t) -> <mpf_s as Sub<ui_t>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the - operator.

impl Sub for mpf_s

impl ‘$imp’<‘$u’$gt; for ‘$t’

fn sub(self, rhs: mpf_s) -> <mpf_s as Sub<mpf_s>>::Output

‘$imp’ ‘$t’ ‘$u’

type Output = __mpf_struct

The resulting type after applying the - operator.

impl<'a, 'b> SubAssign<&'b __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: &'b mpf_s)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> SubAssign<&'a __mpf_struct> for mpf_s

impl SubAssign for mpf_s

fn sub_assign(&mut self, rhs: &'a Self)

sub_assign mpf_s -= mpf_r

impl<'a, 'b> SubAssign<&'b mut __mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: &'b mut mpf_s)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> SubAssign<&'a mut __mpf_struct> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn sub_assign(&mut self, rhs: &'a mut mpf_s)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> SubAssign<&'b mut u64> for &'a mut mpf_s

impl ‘$imp’<‘&mut $u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: &'b mut ui_t)

‘$imp’ &mut ‘$t’ ‘&mut $u’

impl<'a> SubAssign<&'a mut u64> for mpf_s

impl ‘$imp’<‘&mut $u’> for ‘$t’

fn sub_assign(&mut self, rhs: &'a mut ui_t)

‘$imp’ ‘$t’ ‘&mut $u’

impl<'a, 'b> SubAssign<&'b u64> for &'a mut mpf_s

impl ‘$imp’<‘&$u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: &'b ui_t)

‘$imp’ &mut ‘$t’ ‘&$u’

impl<'a> SubAssign<&'a u64> for mpf_s

impl SubAssign for mpf_s

fn sub_assign(&mut self, rhs: &'a ui_t)

sub_assign mpf_s -= &ui_t

impl<'a> SubAssign<__mpf_struct> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: mpf_s)

‘$imp’ &mut ‘$t’ ‘$u’

impl<'a> SubAssign<u64> for &'a mut mpf_s

impl ‘$imp’<‘$u’> for &mut ‘$t’

fn sub_assign(&mut self, rhs: ui_t)

‘$imp’ &mut ‘$t’ ‘$u’

impl SubAssign<u64> for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn sub_assign(&mut self, rhs: ui_t)

‘$imp’ ‘$t’ ‘$u’

impl SubAssign for mpf_s

impl ‘$imp’<‘$u’> for ‘$t’

fn sub_assign(&mut self, rhs: mpf_s)

‘$imp’ ‘$t’ ‘$u’