mpir 0.4.5

partial Rust porting of mpir multiple precision library based on gmp mpfr
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

//! mpz
//!

pub mod sub;
pub mod add;
pub mod mul;
pub mod div;
pub mod rem;
pub mod cmp;

use std::ops::{Neg, Not};
use crate::ops::onforward_ref_unop;
use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
use std::ops::{Shl, ShlAssign, Shr, ShrAssign};
use crate::ops::{onforward_ref_binop, onforward_ref_op_assign};
// use std::ops::{Index, IndexMut};
use crate::prim::{typ::*, mpz::*};

onforward_ref_unop!{impl Neg, neg for mpz_s}

/// impl Neg for mpz_r
impl<'a> Neg for &'a mpz_s {
  type Output = <mpz_s as Neg>::Output;

  /// neg mpz_r
  #[inline]
  fn neg(self) -> <mpz_s as Neg>::Output {
    let mut t = mpz_s::init();
    mpz_neg(&mut t, self);
    t
  }
}

onforward_ref_unop!{impl Not, not for mpz_s}

/// impl Not for mpz_r
impl<'a> Not for &'a mpz_s {
  type Output = <mpz_s as Not>::Output;

  /// not mpz_r
  #[inline]
  fn not(self) -> <mpz_s as Not>::Output {
    let mut t = mpz_s::init();
    mpz_com(&mut t, self);
    t
  }
}

onforward_ref_binop!{impl BitAnd, bitand for mpz_s, mpz_s, mpz_s}

/// impl BitAnd for mpz_r
impl<'a, 'b> BitAnd<&'b mpz_s> for &'a mpz_s {
  type Output = <mpz_s as BitAnd<mpz_s>>::Output;

  /// bitand mpz_r &amp; mpz_r
  #[inline]
  fn bitand(self, rhs: &'b mpz_s) -> <mpz_s as BitAnd<mpz_s>>::Output {
    let mut t = mpz_s::init();
    mpz_and(&mut t, self, rhs);
    t
  }
}

onforward_ref_op_assign!{impl BitAndAssign, bitand_assign for mpz_s, mpz_s}

/// impl BitAndAssign for mpz_s
impl<'a> BitAndAssign<&'a Self> for mpz_s {
  /// bitand_assign mpz_s &amp;= mpz_r
  #[inline]
  fn bitand_assign(&mut self, rhs: &'a Self) -> () {
    self.set(&self.and(rhs));
  }
}

onforward_ref_binop!{impl BitOr, bitor for mpz_s, mpz_s, mpz_s}

/// impl BitOr for mpz_r
impl<'a, 'b> BitOr<&'b mpz_s> for &'a mpz_s {
  type Output = <mpz_s as BitOr<mpz_s>>::Output;

  /// bitor mpz_r | mpz_r
  #[inline]
  fn bitor(self, rhs: &'b mpz_s) -> <mpz_s as BitOr<mpz_s>>::Output {
    let mut t = mpz_s::init();
    mpz_ior(&mut t, self, rhs);
    t
  }
}

onforward_ref_op_assign!{impl BitOrAssign, bitor_assign for mpz_s, mpz_s}

/// impl BitOrAssign for mpz_s
impl<'a> BitOrAssign<&'a Self> for mpz_s {
  /// bitor_assign mpz_s |= mpz_r
  #[inline]
  fn bitor_assign(&mut self, rhs: &'a Self) -> () {
    self.set(&self.ior(rhs));
  }
}

onforward_ref_binop!{impl BitXor, bitxor for mpz_s, mpz_s, mpz_s}

/// impl BitXor for mpz_r
impl<'a, 'b> BitXor<&'b mpz_s> for &'a mpz_s {
  type Output = <mpz_s as BitXor<mpz_s>>::Output;

  /// bitxor mpz_r &amp; mpz_r
  #[inline]
  fn bitxor(self, rhs: &'b mpz_s) -> <mpz_s as BitXor<mpz_s>>::Output {
    let mut t = mpz_s::init();
    mpz_xor(&mut t, self, rhs);
    t
  }
}

onforward_ref_op_assign!{impl BitXorAssign, bitxor_assign for mpz_s, mpz_s}

/// impl BitXorAssign for mpz_s
impl<'a> BitXorAssign<&'a Self> for mpz_s {
  /// bitxor_assign mpz_s &amp;= mpz_r
  #[inline]
  fn bitxor_assign(&mut self, rhs: &'a Self) -> () {
    self.set(&self.xor(rhs));
  }
}

onforward_ref_binop!{impl Shl, shl for mpz_s, mp_bitcnt_t, mpz_s}

/// impl Shl for mpz_r
impl<'a, 'b> Shl<&'b mp_bitcnt_t> for &'a mpz_s {
  type Output = <mpz_s as Shl<mp_bitcnt_t>>::Output;

  /// shl mpz_r << mp_bitcnt_t
  #[inline]
  fn shl(self, rhs: &'b mp_bitcnt_t) -> <mpz_s as Shl<mp_bitcnt_t>>::Output {
    let mut t = mpz_s::init();
    mpz_mul_2exp(&mut t, self, *rhs);
    t
  }
}

onforward_ref_op_assign!{impl ShlAssign, shl_assign for mpz_s, mp_bitcnt_t}

/// impl ShlAssign for mpz_s
impl<'a> ShlAssign<&'a mp_bitcnt_t> for mpz_s {
  /// shl_assign mpz_s <<= mp_bitcnt_t
  #[inline]
  fn shl_assign(&mut self, rhs: &'a mp_bitcnt_t) -> () {
    self.mul_2exp(*rhs);
  }
}

onforward_ref_binop!{impl Shr, shr for mpz_s, mp_bitcnt_t, mpz_s}

/// impl Shr for mpz_r
impl<'a, 'b> Shr<&'b mp_bitcnt_t> for &'a mpz_s {
  type Output = <mpz_s as Shr<mp_bitcnt_t>>::Output;

  /// shr mpz_r >> mp_bitcnt_t
  #[inline]
  fn shr(self, rhs: &'b mp_bitcnt_t) -> <mpz_s as Shr<mp_bitcnt_t>>::Output {
    let mut t = mpz_s::init();
    mpz_tdiv_q_2exp(&mut t, self, *rhs);
    t
  }
}

onforward_ref_op_assign!{impl ShrAssign, shr_assign for mpz_s, mp_bitcnt_t}

/// impl ShrAssign for mpz_s
impl<'a> ShrAssign<&'a mp_bitcnt_t> for mpz_s {
  /// shr_assign mpz_s >>= mp_bitcnt_t
  #[inline]
  fn shr_assign(&mut self, rhs: &'a mp_bitcnt_t) -> () {
    self.set(&self.tdiv_q_2exp(*rhs));
  }
}