Struct __mpq_struct

#[repr(C)]
pub struct __mpq_struct {
    pub _mp_num: __mpz_struct,
    pub _mp_den: __mpz_struct,
}

__mpq_struct

Fields

_mp_num: __mpz_struct

_mp_num

_mp_den: __mpz_struct

_mp_den

Implementations

impl __mpq_struct

impl mpq_s

pub fn clear(&mut self)

clear

pub fn init() -> Self

init create new instance

pub fn set(&mut self, q: mpq_r<'_>) -> &mut Self

set self = q

pub fn set_ui(&mut self, u: ui_t, f: ui_t) -> &mut Self

set_ui self = u

pub fn set_si(&mut self, s: si_t, f: ui_t) -> &mut Self

set_si self = s

pub fn set_d(&mut self, d: double_t) -> &mut Self

set_d self = d

pub fn set_z(&mut self, a: mpz_r<'_>) -> &mut Self

set_z self = a

pub fn set_f(&mut self, f: mpf_r<'_>) -> &mut Self

set_f self = f

pub fn set_num(&mut self, num: mpz_r<'_>) -> &mut Self

set_num

pub fn set_den(&mut self, den: mpz_r<'_>) -> &mut Self

set_den

pub fn set_str(&mut self, s: &str, b: int_t) -> &mut Self

set_str self from str

pub fn fmtstr(&self, b: int_t) -> String

fmtstr

pub fn get_d(&self) -> double_t

get_d (loss of digits)

pub fn get_num(&self) -> mpz_s

get_num create new instance of mpz_s

pub fn get_den(&self) -> mpz_s

get_den create new instance of mpz_s

pub fn numref(&self) -> mpz_r<'_>

numref

pub fn denref(&self) -> mpz_r<'_>

denref

pub fn swap(&mut self, r: mpq_t<'_>) -> &mut Self

swap

pub fn cmp(&self, r: mpq_r<'_>) -> int_t

cmp

pub fn cmp_z(&self, a: mpz_r<'_>) -> int_t

cmp_z

pub fn cmp_ui(&self, u: ui_t) -> int_t

cmp_ui

pub fn cmp_si(&self, s: si_t) -> int_t

cmp_si

pub fn equal(&self, r: mpq_r<'_>) -> bool

equal

pub fn sgn(&self) -> int_t

sgn

pub fn inv(&self) -> Self

inv q**-1 create new instance

pub fn abs(&self) -> Self

abs create new instance

pub fn neg(&self) -> Self

neg create new instance

pub fn sub(&mut self, r: mpq_r<'_>) -> &mut Self

sub self -= r

pub fn add(&mut self, r: mpq_r<'_>) -> &mut Self

add self += r

pub fn mul(&mut self, r: mpq_r<'_>) -> &mut Self

mul self *= r

pub fn mul_2exp(&mut self, n: mp_bitcnt_t) -> &mut Self

mul_2exp self *= 2**n

pub fn div(&mut self, r: mpq_r<'_>) -> &mut Self

div self /= r

pub fn div_2exp(&mut self, n: mp_bitcnt_t) -> &mut Self

div_2exp self /= 2**n

Trait Implementations

impl<'a, 'b> Add<&'b __mpq_struct> for &'a mpq_s

impl Add for mpq_r

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

add mpq_r + mpq_r

type Output = <__mpq_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<&'a __mpq_struct> for mpq_s

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

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

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

type Output = <__mpq_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'b mut __mpq_struct> for &'a mut mpq_s

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

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

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

type Output = <__mpq_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> Add<__mpq_struct> for &'a mpq_s

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

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

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

type Output = <__mpq_struct as Add>::Output

The resulting type after applying the + operator.

impl<'a> AddAssign<&'a __mpq_struct> for mpq_s

impl AddAssign for mpq_s

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

add_assign mpq_s += mpq_r

impl<'a> AddAssign<__mpq_struct> for &'a mut mpq_s

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

fn add_assign(&mut self, rhs: mpq_s)

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

impl Debug for __mpq_struct

impl Debug

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

fmt

impl Display for __mpq_struct

impl Display

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

fmt

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

impl Div for mpq_r

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

div mpq_r / mpq_r

type Output = <__mpq_struct as Div>::Output

The resulting type after applying the / operator.

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

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

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

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

type Output = <__mpq_struct as Div>::Output

The resulting type after applying the / operator.

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

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

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

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

type Output = <__mpq_struct as Div>::Output

The resulting type after applying the / operator.

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

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

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

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

type Output = <__mpq_struct as Div>::Output

The resulting type after applying the / operator.

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

impl DivAssign for mpq_s

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

div_assign mpq_s /= mpq_r

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

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

fn div_assign(&mut self, rhs: mpq_s)

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

impl Drop for __mpq_struct

impl Drop

fn drop(&mut self)

Executes the destructor for this type.

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

impl Mul for mpq_r

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

mul mpq_r * mpq_r

type Output = <__mpq_struct as Mul>::Output

The resulting type after applying the * operator.

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

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

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

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

type Output = <__mpq_struct as Mul>::Output

The resulting type after applying the * operator.

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

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

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

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

type Output = <__mpq_struct as Mul>::Output

The resulting type after applying the * operator.

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

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

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

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

type Output = <__mpq_struct as Mul>::Output

The resulting type after applying the * operator.

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

impl MulAssign for mpq_s

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

mul_assign mpq_s *= mpq_r

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

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

fn mul_assign(&mut self, rhs: mpq_s)

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

impl SNew for __mpq_struct

impl SNew

fn new() -> Self

new

fn as_ptr(&self) -> mp_r

as_ptr

fn as_ptr_mut(&mut self) -> mp_t

as_ptr_mut

impl<'a, 'b> Sub<&'b __mpq_struct> for &'a mpq_s

impl Sub for mpq_r

fn sub(self, rhs: &'b mpq_s) -> <mpq_s as Sub<mpq_s>>::Output

sub mpq_r - mpq_r

type Output = <__mpq_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<&'a __mpq_struct> for mpq_s

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

fn sub(self, rhs: &'a mpq_s) -> <mpq_s as Sub<mpq_s>>::Output

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

type Output = <__mpq_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'b mut __mpq_struct> for &'a mut mpq_s

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

fn sub(self, rhs: &'b mut mpq_s) -> <mpq_s as Sub<mpq_s>>::Output

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

type Output = <__mpq_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> Sub<__mpq_struct> for &'a mpq_s

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

fn sub(self, rhs: mpq_s) -> <mpq_s as Sub<mpq_s>>::Output

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

type Output = <__mpq_struct as Sub>::Output

The resulting type after applying the - operator.

impl<'a> SubAssign<&'a __mpq_struct> for mpq_s

impl SubAssign for mpq_s

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

sub_assign mpq_s -= mpq_r

impl<'a> SubAssign<__mpq_struct> for &'a mut mpq_s

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

fn sub_assign(&mut self, rhs: mpq_s)

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