Adding large folders

This commit is contained in:
2026-02-26 12:00:21 -05:00
parent 5400d82acd
commit 49701c85ad
47332 changed files with 1942573 additions and 0 deletions
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,240 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/addition.rs`."><title>addition.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>addition.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::CheckedUnsignedAbs::{Negative, Positive};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::{Minus, NoSign, Plus};
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use super</span>::{BigInt, UnsignedAbs};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use crate</span>::{IsizePromotion, UsizePromotion};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::iter::Sum;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::mem;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>core::ops::{Add, AddAssign};
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span>num_traits::CheckedAdd;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="comment">// We want to forward to BigUint::add, but it's not clear how that will go until
<a href=#14 id=14 data-nosnippet>14</a>// we compare both sign and magnitude. So we duplicate this body for every
<a href=#15 id=15 data-nosnippet>15</a>// val/ref combination, deferring that decision to BigUint's own forwarding.
<a href=#16 id=16 data-nosnippet>16</a></span><span class="macro">macro_rules!</span> bigint_add {
<a href=#17 id=17 data-nosnippet>17</a> (<span class="macro-nonterminal">$a</span>:expr, <span class="macro-nonterminal">$a_owned</span>:expr, <span class="macro-nonterminal">$a_data</span>:expr, <span class="macro-nonterminal">$b</span>:expr, <span class="macro-nonterminal">$b_owned</span>:expr, <span class="macro-nonterminal">$b_data</span>:expr) =&gt; {
<a href=#18 id=18 data-nosnippet>18</a> <span class="kw">match </span>(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$b</span>.sign) {
<a href=#19 id=19 data-nosnippet>19</a> (<span class="kw">_</span>, NoSign) =&gt; <span class="macro-nonterminal">$a_owned</span>,
<a href=#20 id=20 data-nosnippet>20</a> (NoSign, <span class="kw">_</span>) =&gt; <span class="macro-nonterminal">$b_owned</span>,
<a href=#21 id=21 data-nosnippet>21</a> <span class="comment">// same sign =&gt; keep the sign with the sum of magnitudes
<a href=#22 id=22 data-nosnippet>22</a> </span>(Plus, Plus) | (Minus, Minus) =&gt; BigInt::from_biguint(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$a_data </span>+ <span class="macro-nonterminal">$b_data</span>),
<a href=#23 id=23 data-nosnippet>23</a> <span class="comment">// opposite signs =&gt; keep the sign of the larger with the difference of magnitudes
<a href=#24 id=24 data-nosnippet>24</a> </span>(Plus, Minus) | (Minus, Plus) =&gt; <span class="kw">match </span><span class="macro-nonterminal">$a</span>.data.cmp(<span class="kw-2">&amp;</span><span class="macro-nonterminal">$b</span>.data) {
<a href=#25 id=25 data-nosnippet>25</a> Less =&gt; BigInt::from_biguint(<span class="macro-nonterminal">$b</span>.sign, <span class="macro-nonterminal">$b_data </span>- <span class="macro-nonterminal">$a_data</span>),
<a href=#26 id=26 data-nosnippet>26</a> Greater =&gt; BigInt::from_biguint(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$a_data </span>- <span class="macro-nonterminal">$b_data</span>),
<a href=#27 id=27 data-nosnippet>27</a> Equal =&gt; BigInt::ZERO,
<a href=#28 id=28 data-nosnippet>28</a> },
<a href=#29 id=29 data-nosnippet>29</a> }
<a href=#30 id=30 data-nosnippet>30</a> };
<a href=#31 id=31 data-nosnippet>31</a>}
<a href=#32 id=32 data-nosnippet>32</a>
<a href=#33 id=33 data-nosnippet>33</a><span class="kw">impl </span>Add&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#34 id=34 data-nosnippet>34</a> <span class="kw">type </span>Output = BigInt;
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a> <span class="attr">#[inline]
<a href=#37 id=37 data-nosnippet>37</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#38 id=38 data-nosnippet>38</a> <span class="macro">bigint_add!</span>(
<a href=#39 id=39 data-nosnippet>39</a> <span class="self">self</span>,
<a href=#40 id=40 data-nosnippet>40</a> <span class="self">self</span>.clone(),
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw-2">&amp;</span><span class="self">self</span>.data,
<a href=#42 id=42 data-nosnippet>42</a> other,
<a href=#43 id=43 data-nosnippet>43</a> other.clone(),
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw-2">&amp;</span>other.data
<a href=#45 id=45 data-nosnippet>45</a> )
<a href=#46 id=46 data-nosnippet>46</a> }
<a href=#47 id=47 data-nosnippet>47</a>}
<a href=#48 id=48 data-nosnippet>48</a>
<a href=#49 id=49 data-nosnippet>49</a><span class="kw">impl </span>Add&lt;BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">type </span>Output = BigInt;
<a href=#51 id=51 data-nosnippet>51</a>
<a href=#52 id=52 data-nosnippet>52</a> <span class="attr">#[inline]
<a href=#53 id=53 data-nosnippet>53</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#54 id=54 data-nosnippet>54</a> <span class="macro">bigint_add!</span>(<span class="self">self</span>, <span class="self">self</span>.clone(), <span class="kw-2">&amp;</span><span class="self">self</span>.data, other, other, other.data)
<a href=#55 id=55 data-nosnippet>55</a> }
<a href=#56 id=56 data-nosnippet>56</a>}
<a href=#57 id=57 data-nosnippet>57</a>
<a href=#58 id=58 data-nosnippet>58</a><span class="kw">impl </span>Add&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#59 id=59 data-nosnippet>59</a> <span class="kw">type </span>Output = BigInt;
<a href=#60 id=60 data-nosnippet>60</a>
<a href=#61 id=61 data-nosnippet>61</a> <span class="attr">#[inline]
<a href=#62 id=62 data-nosnippet>62</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#63 id=63 data-nosnippet>63</a> <span class="macro">bigint_add!</span>(<span class="self">self</span>, <span class="self">self</span>, <span class="self">self</span>.data, other, other.clone(), <span class="kw-2">&amp;</span>other.data)
<a href=#64 id=64 data-nosnippet>64</a> }
<a href=#65 id=65 data-nosnippet>65</a>}
<a href=#66 id=66 data-nosnippet>66</a>
<a href=#67 id=67 data-nosnippet>67</a><span class="kw">impl </span>Add&lt;BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">type </span>Output = BigInt;
<a href=#69 id=69 data-nosnippet>69</a>
<a href=#70 id=70 data-nosnippet>70</a> <span class="attr">#[inline]
<a href=#71 id=71 data-nosnippet>71</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#72 id=72 data-nosnippet>72</a> <span class="macro">bigint_add!</span>(<span class="self">self</span>, <span class="self">self</span>, <span class="self">self</span>.data, other, other, other.data)
<a href=#73 id=73 data-nosnippet>73</a> }
<a href=#74 id=74 data-nosnippet>74</a>}
<a href=#75 id=75 data-nosnippet>75</a>
<a href=#76 id=76 data-nosnippet>76</a><span class="kw">impl </span>AddAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#77 id=77 data-nosnippet>77</a> <span class="attr">#[inline]
<a href=#78 id=78 data-nosnippet>78</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#80 id=80 data-nosnippet>80</a> <span class="kw-2">*</span><span class="self">self </span>= n + other;
<a href=#81 id=81 data-nosnippet>81</a> }
<a href=#82 id=82 data-nosnippet>82</a>}
<a href=#83 id=83 data-nosnippet>83</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>AddAssign <span class="kw">for </span>BigInt, add_assign);
<a href=#84 id=84 data-nosnippet>84</a>
<a href=#85 id=85 data-nosnippet>85</a><span class="macro">promote_all_scalars!</span>(<span class="kw">impl </span>Add <span class="kw">for </span>BigInt, add);
<a href=#86 id=86 data-nosnippet>86</a><span class="macro">promote_all_scalars_assign!</span>(<span class="kw">impl </span>AddAssign <span class="kw">for </span>BigInt, add_assign);
<a href=#87 id=87 data-nosnippet>87</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u32&gt; <span class="kw">for </span>BigInt, add);
<a href=#88 id=88 data-nosnippet>88</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u64&gt; <span class="kw">for </span>BigInt, add);
<a href=#89 id=89 data-nosnippet>89</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u128&gt; <span class="kw">for </span>BigInt, add);
<a href=#90 id=90 data-nosnippet>90</a>
<a href=#91 id=91 data-nosnippet>91</a><span class="kw">impl </span>Add&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">type </span>Output = BigInt;
<a href=#93 id=93 data-nosnippet>93</a>
<a href=#94 id=94 data-nosnippet>94</a> <span class="attr">#[inline]
<a href=#95 id=95 data-nosnippet>95</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: u32) -&gt; BigInt {
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#97 id=97 data-nosnippet>97</a> NoSign =&gt; From::from(other),
<a href=#98 id=98 data-nosnippet>98</a> Plus =&gt; BigInt::from(<span class="self">self</span>.data + other),
<a href=#99 id=99 data-nosnippet>99</a> Minus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#100 id=100 data-nosnippet>100</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#101 id=101 data-nosnippet>101</a> Less =&gt; BigInt::from(other - <span class="self">self</span>.data),
<a href=#102 id=102 data-nosnippet>102</a> Greater =&gt; -BigInt::from(<span class="self">self</span>.data - other),
<a href=#103 id=103 data-nosnippet>103</a> },
<a href=#104 id=104 data-nosnippet>104</a> }
<a href=#105 id=105 data-nosnippet>105</a> }
<a href=#106 id=106 data-nosnippet>106</a>}
<a href=#107 id=107 data-nosnippet>107</a>
<a href=#108 id=108 data-nosnippet>108</a><span class="kw">impl </span>AddAssign&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#109 id=109 data-nosnippet>109</a> <span class="attr">#[inline]
<a href=#110 id=110 data-nosnippet>110</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw-2">*</span><span class="self">self </span>= n + other;
<a href=#113 id=113 data-nosnippet>113</a> }
<a href=#114 id=114 data-nosnippet>114</a>}
<a href=#115 id=115 data-nosnippet>115</a>
<a href=#116 id=116 data-nosnippet>116</a><span class="kw">impl </span>Add&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#117 id=117 data-nosnippet>117</a> <span class="kw">type </span>Output = BigInt;
<a href=#118 id=118 data-nosnippet>118</a>
<a href=#119 id=119 data-nosnippet>119</a> <span class="attr">#[inline]
<a href=#120 id=120 data-nosnippet>120</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: u64) -&gt; BigInt {
<a href=#121 id=121 data-nosnippet>121</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#122 id=122 data-nosnippet>122</a> NoSign =&gt; From::from(other),
<a href=#123 id=123 data-nosnippet>123</a> Plus =&gt; BigInt::from(<span class="self">self</span>.data + other),
<a href=#124 id=124 data-nosnippet>124</a> Minus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#125 id=125 data-nosnippet>125</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#126 id=126 data-nosnippet>126</a> Less =&gt; BigInt::from(other - <span class="self">self</span>.data),
<a href=#127 id=127 data-nosnippet>127</a> Greater =&gt; -BigInt::from(<span class="self">self</span>.data - other),
<a href=#128 id=128 data-nosnippet>128</a> },
<a href=#129 id=129 data-nosnippet>129</a> }
<a href=#130 id=130 data-nosnippet>130</a> }
<a href=#131 id=131 data-nosnippet>131</a>}
<a href=#132 id=132 data-nosnippet>132</a>
<a href=#133 id=133 data-nosnippet>133</a><span class="kw">impl </span>AddAssign&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#134 id=134 data-nosnippet>134</a> <span class="attr">#[inline]
<a href=#135 id=135 data-nosnippet>135</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#137 id=137 data-nosnippet>137</a> <span class="kw-2">*</span><span class="self">self </span>= n + other;
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a>}
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a><span class="kw">impl </span>Add&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">type </span>Output = BigInt;
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a> <span class="attr">#[inline]
<a href=#145 id=145 data-nosnippet>145</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: u128) -&gt; BigInt {
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#147 id=147 data-nosnippet>147</a> NoSign =&gt; BigInt::from(other),
<a href=#148 id=148 data-nosnippet>148</a> Plus =&gt; BigInt::from(<span class="self">self</span>.data + other),
<a href=#149 id=149 data-nosnippet>149</a> Minus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#150 id=150 data-nosnippet>150</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#151 id=151 data-nosnippet>151</a> Less =&gt; BigInt::from(other - <span class="self">self</span>.data),
<a href=#152 id=152 data-nosnippet>152</a> Greater =&gt; -BigInt::from(<span class="self">self</span>.data - other),
<a href=#153 id=153 data-nosnippet>153</a> },
<a href=#154 id=154 data-nosnippet>154</a> }
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a>}
<a href=#157 id=157 data-nosnippet>157</a><span class="kw">impl </span>AddAssign&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#158 id=158 data-nosnippet>158</a> <span class="attr">#[inline]
<a href=#159 id=159 data-nosnippet>159</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#160 id=160 data-nosnippet>160</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw-2">*</span><span class="self">self </span>= n + other;
<a href=#162 id=162 data-nosnippet>162</a> }
<a href=#163 id=163 data-nosnippet>163</a>}
<a href=#164 id=164 data-nosnippet>164</a>
<a href=#165 id=165 data-nosnippet>165</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;i32&gt; <span class="kw">for </span>BigInt, add);
<a href=#166 id=166 data-nosnippet>166</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;i64&gt; <span class="kw">for </span>BigInt, add);
<a href=#167 id=167 data-nosnippet>167</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;i128&gt; <span class="kw">for </span>BigInt, add);
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a><span class="kw">impl </span>Add&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#170 id=170 data-nosnippet>170</a> <span class="kw">type </span>Output = BigInt;
<a href=#171 id=171 data-nosnippet>171</a>
<a href=#172 id=172 data-nosnippet>172</a> <span class="attr">#[inline]
<a href=#173 id=173 data-nosnippet>173</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: i32) -&gt; BigInt {
<a href=#174 id=174 data-nosnippet>174</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#175 id=175 data-nosnippet>175</a> Positive(u) =&gt; <span class="self">self </span>+ u,
<a href=#176 id=176 data-nosnippet>176</a> Negative(u) =&gt; <span class="self">self </span>- u,
<a href=#177 id=177 data-nosnippet>177</a> }
<a href=#178 id=178 data-nosnippet>178</a> }
<a href=#179 id=179 data-nosnippet>179</a>}
<a href=#180 id=180 data-nosnippet>180</a><span class="kw">impl </span>AddAssign&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#181 id=181 data-nosnippet>181</a> <span class="attr">#[inline]
<a href=#182 id=182 data-nosnippet>182</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i32) {
<a href=#183 id=183 data-nosnippet>183</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#184 id=184 data-nosnippet>184</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#185 id=185 data-nosnippet>185</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#186 id=186 data-nosnippet>186</a> }
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a>}
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a><span class="kw">impl </span>Add&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#191 id=191 data-nosnippet>191</a> <span class="kw">type </span>Output = BigInt;
<a href=#192 id=192 data-nosnippet>192</a>
<a href=#193 id=193 data-nosnippet>193</a> <span class="attr">#[inline]
<a href=#194 id=194 data-nosnippet>194</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: i64) -&gt; BigInt {
<a href=#195 id=195 data-nosnippet>195</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#196 id=196 data-nosnippet>196</a> Positive(u) =&gt; <span class="self">self </span>+ u,
<a href=#197 id=197 data-nosnippet>197</a> Negative(u) =&gt; <span class="self">self </span>- u,
<a href=#198 id=198 data-nosnippet>198</a> }
<a href=#199 id=199 data-nosnippet>199</a> }
<a href=#200 id=200 data-nosnippet>200</a>}
<a href=#201 id=201 data-nosnippet>201</a><span class="kw">impl </span>AddAssign&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#202 id=202 data-nosnippet>202</a> <span class="attr">#[inline]
<a href=#203 id=203 data-nosnippet>203</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i64) {
<a href=#204 id=204 data-nosnippet>204</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#205 id=205 data-nosnippet>205</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#206 id=206 data-nosnippet>206</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#207 id=207 data-nosnippet>207</a> }
<a href=#208 id=208 data-nosnippet>208</a> }
<a href=#209 id=209 data-nosnippet>209</a>}
<a href=#210 id=210 data-nosnippet>210</a>
<a href=#211 id=211 data-nosnippet>211</a><span class="kw">impl </span>Add&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#212 id=212 data-nosnippet>212</a> <span class="kw">type </span>Output = BigInt;
<a href=#213 id=213 data-nosnippet>213</a>
<a href=#214 id=214 data-nosnippet>214</a> <span class="attr">#[inline]
<a href=#215 id=215 data-nosnippet>215</a> </span><span class="kw">fn </span>add(<span class="self">self</span>, other: i128) -&gt; BigInt {
<a href=#216 id=216 data-nosnippet>216</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#217 id=217 data-nosnippet>217</a> Positive(u) =&gt; <span class="self">self </span>+ u,
<a href=#218 id=218 data-nosnippet>218</a> Negative(u) =&gt; <span class="self">self </span>- u,
<a href=#219 id=219 data-nosnippet>219</a> }
<a href=#220 id=220 data-nosnippet>220</a> }
<a href=#221 id=221 data-nosnippet>221</a>}
<a href=#222 id=222 data-nosnippet>222</a><span class="kw">impl </span>AddAssign&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#223 id=223 data-nosnippet>223</a> <span class="attr">#[inline]
<a href=#224 id=224 data-nosnippet>224</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i128) {
<a href=#225 id=225 data-nosnippet>225</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#226 id=226 data-nosnippet>226</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#227 id=227 data-nosnippet>227</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a> }
<a href=#230 id=230 data-nosnippet>230</a>}
<a href=#231 id=231 data-nosnippet>231</a>
<a href=#232 id=232 data-nosnippet>232</a><span class="kw">impl </span>CheckedAdd <span class="kw">for </span>BigInt {
<a href=#233 id=233 data-nosnippet>233</a> <span class="attr">#[inline]
<a href=#234 id=234 data-nosnippet>234</a> </span><span class="kw">fn </span>checked_add(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#235 id=235 data-nosnippet>235</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.add(v))
<a href=#236 id=236 data-nosnippet>236</a> }
<a href=#237 id=237 data-nosnippet>237</a>}
<a href=#238 id=238 data-nosnippet>238</a>
<a href=#239 id=239 data-nosnippet>239</a><span class="macro">impl_sum_iter_type!</span>(BigInt);
</code></pre></div></section></main></body></html>
@@ -0,0 +1,532 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/bits.rs`."><title>bits.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>bits.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::BigInt;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::{Minus, NoSign, Plus};
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit, DoubleBigDigit};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::biguint::IntDigits;
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>alloc::vec::Vec;
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>num_traits::{ToPrimitive, Zero};
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a><span class="comment">// Negation in two's complement.
<a href=#13 id=13 data-nosnippet>13</a>// acc must be initialized as 1 for least-significant digit.
<a href=#14 id=14 data-nosnippet>14</a>//
<a href=#15 id=15 data-nosnippet>15</a>// When negating, a carry (acc == 1) means that all the digits
<a href=#16 id=16 data-nosnippet>16</a>// considered to this point were zero. This means that if all the
<a href=#17 id=17 data-nosnippet>17</a>// digits of a negative BigInt have been considered, carry must be
<a href=#18 id=18 data-nosnippet>18</a>// zero as we cannot have negative zero.
<a href=#19 id=19 data-nosnippet>19</a>//
<a href=#20 id=20 data-nosnippet>20</a>// 01 -&gt; ...f ff
<a href=#21 id=21 data-nosnippet>21</a>// ff -&gt; ...f 01
<a href=#22 id=22 data-nosnippet>22</a>// 01 00 -&gt; ...f ff 00
<a href=#23 id=23 data-nosnippet>23</a>// 01 01 -&gt; ...f fe ff
<a href=#24 id=24 data-nosnippet>24</a>// 01 ff -&gt; ...f fe 01
<a href=#25 id=25 data-nosnippet>25</a>// ff 00 -&gt; ...f 01 00
<a href=#26 id=26 data-nosnippet>26</a>// ff 01 -&gt; ...f 00 ff
<a href=#27 id=27 data-nosnippet>27</a>// ff ff -&gt; ...f 00 01
<a href=#28 id=28 data-nosnippet>28</a></span><span class="attr">#[inline]
<a href=#29 id=29 data-nosnippet>29</a></span><span class="kw">fn </span>negate_carry(a: BigDigit, acc: <span class="kw-2">&amp;mut </span>DoubleBigDigit) -&gt; BigDigit {
<a href=#30 id=30 data-nosnippet>30</a> <span class="kw-2">*</span>acc += DoubleBigDigit::from(!a);
<a href=#31 id=31 data-nosnippet>31</a> <span class="kw">let </span>lo = <span class="kw-2">*</span>acc <span class="kw">as </span>BigDigit;
<a href=#32 id=32 data-nosnippet>32</a> <span class="kw-2">*</span>acc &gt;&gt;= big_digit::BITS;
<a href=#33 id=33 data-nosnippet>33</a> lo
<a href=#34 id=34 data-nosnippet>34</a>}
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a><span class="comment">// + 1 &amp; -ff = ...0 01 &amp; ...f 01 = ...0 01 = + 1
<a href=#37 id=37 data-nosnippet>37</a>// +ff &amp; - 1 = ...0 ff &amp; ...f ff = ...0 ff = +ff
<a href=#38 id=38 data-nosnippet>38</a>// answer is pos, has length of a
<a href=#39 id=39 data-nosnippet>39</a></span><span class="kw">fn </span>bitand_pos_neg(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw-2">*</span>ai &amp;= twos_b;
<a href=#44 id=44 data-nosnippet>44</a> }
<a href=#45 id=45 data-nosnippet>45</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#46 id=46 data-nosnippet>46</a>}
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a><span class="comment">// - 1 &amp; +ff = ...f ff &amp; ...0 ff = ...0 ff = +ff
<a href=#49 id=49 data-nosnippet>49</a>// -ff &amp; + 1 = ...f 01 &amp; ...0 01 = ...0 01 = + 1
<a href=#50 id=50 data-nosnippet>50</a>// answer is pos, has length of b
<a href=#51 id=51 data-nosnippet>51</a></span><span class="kw">fn </span>bitand_neg_pos(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#53 id=53 data-nosnippet>53</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#54 id=54 data-nosnippet>54</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#55 id=55 data-nosnippet>55</a> <span class="kw-2">*</span>ai = twos_a &amp; bi;
<a href=#56 id=56 data-nosnippet>56</a> }
<a href=#57 id=57 data-nosnippet>57</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#59 id=59 data-nosnippet>59</a> Greater =&gt; a.truncate(b.len()),
<a href=#60 id=60 data-nosnippet>60</a> Equal =&gt; {}
<a href=#61 id=61 data-nosnippet>61</a> Less =&gt; {
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#63 id=63 data-nosnippet>63</a> a.extend(extra.iter().cloned());
<a href=#64 id=64 data-nosnippet>64</a> }
<a href=#65 id=65 data-nosnippet>65</a> }
<a href=#66 id=66 data-nosnippet>66</a>}
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a><span class="comment">// - 1 &amp; -ff = ...f ff &amp; ...f 01 = ...f 01 = - ff
<a href=#69 id=69 data-nosnippet>69</a>// -ff &amp; - 1 = ...f 01 &amp; ...f ff = ...f 01 = - ff
<a href=#70 id=70 data-nosnippet>70</a>// -ff &amp; -fe = ...f 01 &amp; ...f 02 = ...f 00 = -100
<a href=#71 id=71 data-nosnippet>71</a>// answer is neg, has length of longest with a possible carry
<a href=#72 id=72 data-nosnippet>72</a></span><span class="kw">fn </span>bitand_neg_neg(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#75 id=75 data-nosnippet>75</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_and = <span class="number">1</span>;
<a href=#76 id=76 data-nosnippet>76</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#77 id=77 data-nosnippet>77</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw-2">*</span>ai = negate_carry(twos_a &amp; twos_b, <span class="kw-2">&amp;mut </span>carry_and);
<a href=#80 id=80 data-nosnippet>80</a> }
<a href=#81 id=81 data-nosnippet>81</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#82 id=82 data-nosnippet>82</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#84 id=84 data-nosnippet>84</a> Greater =&gt; {
<a href=#85 id=85 data-nosnippet>85</a> <span class="kw">for </span>ai <span class="kw">in </span>a[b.len()..].iter_mut() {
<a href=#86 id=86 data-nosnippet>86</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw-2">*</span>ai = negate_carry(twos_a, <span class="kw-2">&amp;mut </span>carry_and);
<a href=#88 id=88 data-nosnippet>88</a> }
<a href=#89 id=89 data-nosnippet>89</a> <span class="macro">debug_assert!</span>(carry_a == <span class="number">0</span>);
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> Equal =&gt; {}
<a href=#92 id=92 data-nosnippet>92</a> Less =&gt; {
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#94 id=94 data-nosnippet>94</a> a.extend(extra.iter().map(|<span class="kw-2">&amp;</span>bi| {
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#96 id=96 data-nosnippet>96</a> negate_carry(twos_b, <span class="kw-2">&amp;mut </span>carry_and)
<a href=#97 id=97 data-nosnippet>97</a> }));
<a href=#98 id=98 data-nosnippet>98</a> <span class="macro">debug_assert!</span>(carry_b == <span class="number">0</span>);
<a href=#99 id=99 data-nosnippet>99</a> }
<a href=#100 id=100 data-nosnippet>100</a> }
<a href=#101 id=101 data-nosnippet>101</a> <span class="kw">if </span><span class="macro">carry_and !</span>= <span class="number">0 </span>{
<a href=#102 id=102 data-nosnippet>102</a> a.push(<span class="number">1</span>);
<a href=#103 id=103 data-nosnippet>103</a> }
<a href=#104 id=104 data-nosnippet>104</a>}
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a><span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span>BitAnd <span class="kw">for </span>BigInt, bitand);
<a href=#107 id=107 data-nosnippet>107</a><span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span>BitAnd <span class="kw">for </span>BigInt, bitand);
<a href=#108 id=108 data-nosnippet>108</a>
<a href=#109 id=109 data-nosnippet>109</a><span class="comment">// do not use forward_ref_ref_binop_commutative! for bitand so that we can
<a href=#110 id=110 data-nosnippet>110</a>// clone as needed, avoiding over-allocation
<a href=#111 id=111 data-nosnippet>111</a></span><span class="kw">impl </span>BitAnd&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">type </span>Output = BigInt;
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a> <span class="attr">#[inline]
<a href=#115 id=115 data-nosnippet>115</a> </span><span class="kw">fn </span>bitand(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#116 id=116 data-nosnippet>116</a> <span class="kw">match </span>(<span class="self">self</span>.sign, other.sign) {
<a href=#117 id=117 data-nosnippet>117</a> (NoSign, <span class="kw">_</span>) | (<span class="kw">_</span>, NoSign) =&gt; BigInt::ZERO,
<a href=#118 id=118 data-nosnippet>118</a> (Plus, Plus) =&gt; BigInt::from(<span class="kw-2">&amp;</span><span class="self">self</span>.data &amp; <span class="kw-2">&amp;</span>other.data),
<a href=#119 id=119 data-nosnippet>119</a> (Plus, Minus) =&gt; <span class="self">self</span>.clone() &amp; other,
<a href=#120 id=120 data-nosnippet>120</a> (Minus, Plus) =&gt; other.clone() &amp; <span class="self">self</span>,
<a href=#121 id=121 data-nosnippet>121</a> (Minus, Minus) =&gt; {
<a href=#122 id=122 data-nosnippet>122</a> <span class="comment">// forward to val-ref, choosing the larger to clone
<a href=#123 id=123 data-nosnippet>123</a> </span><span class="kw">if </span><span class="self">self</span>.len() &gt;= other.len() {
<a href=#124 id=124 data-nosnippet>124</a> <span class="self">self</span>.clone() &amp; other
<a href=#125 id=125 data-nosnippet>125</a> } <span class="kw">else </span>{
<a href=#126 id=126 data-nosnippet>126</a> other.clone() &amp; <span class="self">self
<a href=#127 id=127 data-nosnippet>127</a> </span>}
<a href=#128 id=128 data-nosnippet>128</a> }
<a href=#129 id=129 data-nosnippet>129</a> }
<a href=#130 id=130 data-nosnippet>130</a> }
<a href=#131 id=131 data-nosnippet>131</a>}
<a href=#132 id=132 data-nosnippet>132</a>
<a href=#133 id=133 data-nosnippet>133</a><span class="kw">impl </span>BitAnd&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#134 id=134 data-nosnippet>134</a> <span class="kw">type </span>Output = BigInt;
<a href=#135 id=135 data-nosnippet>135</a>
<a href=#136 id=136 data-nosnippet>136</a> <span class="attr">#[inline]
<a href=#137 id=137 data-nosnippet>137</a> </span><span class="kw">fn </span>bitand(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#138 id=138 data-nosnippet>138</a> <span class="self">self </span>&amp;= other;
<a href=#139 id=139 data-nosnippet>139</a> <span class="self">self
<a href=#140 id=140 data-nosnippet>140</a> </span>}
<a href=#141 id=141 data-nosnippet>141</a>}
<a href=#142 id=142 data-nosnippet>142</a>
<a href=#143 id=143 data-nosnippet>143</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitAndAssign <span class="kw">for </span>BigInt, bitand_assign);
<a href=#144 id=144 data-nosnippet>144</a>
<a href=#145 id=145 data-nosnippet>145</a><span class="kw">impl </span>BitAndAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">fn </span>bitand_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#147 id=147 data-nosnippet>147</a> <span class="kw">match </span>(<span class="self">self</span>.sign, other.sign) {
<a href=#148 id=148 data-nosnippet>148</a> (NoSign, <span class="kw">_</span>) =&gt; {}
<a href=#149 id=149 data-nosnippet>149</a> (<span class="kw">_</span>, NoSign) =&gt; <span class="self">self</span>.set_zero(),
<a href=#150 id=150 data-nosnippet>150</a> (Plus, Plus) =&gt; {
<a href=#151 id=151 data-nosnippet>151</a> <span class="self">self</span>.data &amp;= <span class="kw-2">&amp;</span>other.data;
<a href=#152 id=152 data-nosnippet>152</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#153 id=153 data-nosnippet>153</a> <span class="self">self</span>.sign = NoSign;
<a href=#154 id=154 data-nosnippet>154</a> }
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a> (Plus, Minus) =&gt; {
<a href=#157 id=157 data-nosnippet>157</a> bitand_pos_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#158 id=158 data-nosnippet>158</a> <span class="self">self</span>.normalize();
<a href=#159 id=159 data-nosnippet>159</a> }
<a href=#160 id=160 data-nosnippet>160</a> (Minus, Plus) =&gt; {
<a href=#161 id=161 data-nosnippet>161</a> bitand_neg_pos(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#162 id=162 data-nosnippet>162</a> <span class="self">self</span>.sign = Plus;
<a href=#163 id=163 data-nosnippet>163</a> <span class="self">self</span>.normalize();
<a href=#164 id=164 data-nosnippet>164</a> }
<a href=#165 id=165 data-nosnippet>165</a> (Minus, Minus) =&gt; {
<a href=#166 id=166 data-nosnippet>166</a> bitand_neg_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#167 id=167 data-nosnippet>167</a> <span class="self">self</span>.normalize();
<a href=#168 id=168 data-nosnippet>168</a> }
<a href=#169 id=169 data-nosnippet>169</a> }
<a href=#170 id=170 data-nosnippet>170</a> }
<a href=#171 id=171 data-nosnippet>171</a>}
<a href=#172 id=172 data-nosnippet>172</a>
<a href=#173 id=173 data-nosnippet>173</a><span class="comment">// + 1 | -ff = ...0 01 | ...f 01 = ...f 01 = -ff
<a href=#174 id=174 data-nosnippet>174</a>// +ff | - 1 = ...0 ff | ...f ff = ...f ff = - 1
<a href=#175 id=175 data-nosnippet>175</a>// answer is neg, has length of b
<a href=#176 id=176 data-nosnippet>176</a></span><span class="kw">fn </span>bitor_pos_neg(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#178 id=178 data-nosnippet>178</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_or = <span class="number">1</span>;
<a href=#179 id=179 data-nosnippet>179</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#180 id=180 data-nosnippet>180</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#181 id=181 data-nosnippet>181</a> <span class="kw-2">*</span>ai = negate_carry(<span class="kw-2">*</span>ai | twos_b, <span class="kw-2">&amp;mut </span>carry_or);
<a href=#182 id=182 data-nosnippet>182</a> }
<a href=#183 id=183 data-nosnippet>183</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#184 id=184 data-nosnippet>184</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#185 id=185 data-nosnippet>185</a> Greater =&gt; {
<a href=#186 id=186 data-nosnippet>186</a> a.truncate(b.len());
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a> Equal =&gt; {}
<a href=#189 id=189 data-nosnippet>189</a> Less =&gt; {
<a href=#190 id=190 data-nosnippet>190</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#191 id=191 data-nosnippet>191</a> a.extend(extra.iter().map(|<span class="kw-2">&amp;</span>bi| {
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#193 id=193 data-nosnippet>193</a> negate_carry(twos_b, <span class="kw-2">&amp;mut </span>carry_or)
<a href=#194 id=194 data-nosnippet>194</a> }));
<a href=#195 id=195 data-nosnippet>195</a> <span class="macro">debug_assert!</span>(carry_b == <span class="number">0</span>);
<a href=#196 id=196 data-nosnippet>196</a> }
<a href=#197 id=197 data-nosnippet>197</a> }
<a href=#198 id=198 data-nosnippet>198</a> <span class="comment">// for carry_or to be non-zero, we would need twos_b == 0
<a href=#199 id=199 data-nosnippet>199</a> </span><span class="macro">debug_assert!</span>(carry_or == <span class="number">0</span>);
<a href=#200 id=200 data-nosnippet>200</a>}
<a href=#201 id=201 data-nosnippet>201</a>
<a href=#202 id=202 data-nosnippet>202</a><span class="comment">// - 1 | +ff = ...f ff | ...0 ff = ...f ff = - 1
<a href=#203 id=203 data-nosnippet>203</a>// -ff | + 1 = ...f 01 | ...0 01 = ...f 01 = -ff
<a href=#204 id=204 data-nosnippet>204</a>// answer is neg, has length of a
<a href=#205 id=205 data-nosnippet>205</a></span><span class="kw">fn </span>bitor_neg_pos(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#206 id=206 data-nosnippet>206</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#207 id=207 data-nosnippet>207</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_or = <span class="number">1</span>;
<a href=#208 id=208 data-nosnippet>208</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#210 id=210 data-nosnippet>210</a> <span class="kw-2">*</span>ai = negate_carry(twos_a | bi, <span class="kw-2">&amp;mut </span>carry_or);
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#213 id=213 data-nosnippet>213</a> <span class="kw">if </span>a.len() &gt; b.len() {
<a href=#214 id=214 data-nosnippet>214</a> <span class="kw">for </span>ai <span class="kw">in </span>a[b.len()..].iter_mut() {
<a href=#215 id=215 data-nosnippet>215</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#216 id=216 data-nosnippet>216</a> <span class="kw-2">*</span>ai = negate_carry(twos_a, <span class="kw-2">&amp;mut </span>carry_or);
<a href=#217 id=217 data-nosnippet>217</a> }
<a href=#218 id=218 data-nosnippet>218</a> <span class="macro">debug_assert!</span>(carry_a == <span class="number">0</span>);
<a href=#219 id=219 data-nosnippet>219</a> }
<a href=#220 id=220 data-nosnippet>220</a> <span class="comment">// for carry_or to be non-zero, we would need twos_a == 0
<a href=#221 id=221 data-nosnippet>221</a> </span><span class="macro">debug_assert!</span>(carry_or == <span class="number">0</span>);
<a href=#222 id=222 data-nosnippet>222</a>}
<a href=#223 id=223 data-nosnippet>223</a>
<a href=#224 id=224 data-nosnippet>224</a><span class="comment">// - 1 | -ff = ...f ff | ...f 01 = ...f ff = -1
<a href=#225 id=225 data-nosnippet>225</a>// -ff | - 1 = ...f 01 | ...f ff = ...f ff = -1
<a href=#226 id=226 data-nosnippet>226</a>// answer is neg, has length of shortest
<a href=#227 id=227 data-nosnippet>227</a></span><span class="kw">fn </span>bitor_neg_neg(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#228 id=228 data-nosnippet>228</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#229 id=229 data-nosnippet>229</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_or = <span class="number">1</span>;
<a href=#231 id=231 data-nosnippet>231</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#232 id=232 data-nosnippet>232</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw-2">*</span>ai = negate_carry(twos_a | twos_b, <span class="kw-2">&amp;mut </span>carry_or);
<a href=#235 id=235 data-nosnippet>235</a> }
<a href=#236 id=236 data-nosnippet>236</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#237 id=237 data-nosnippet>237</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">if </span>a.len() &gt; b.len() {
<a href=#239 id=239 data-nosnippet>239</a> a.truncate(b.len());
<a href=#240 id=240 data-nosnippet>240</a> }
<a href=#241 id=241 data-nosnippet>241</a> <span class="comment">// for carry_or to be non-zero, we would need twos_a == 0 or twos_b == 0
<a href=#242 id=242 data-nosnippet>242</a> </span><span class="macro">debug_assert!</span>(carry_or == <span class="number">0</span>);
<a href=#243 id=243 data-nosnippet>243</a>}
<a href=#244 id=244 data-nosnippet>244</a>
<a href=#245 id=245 data-nosnippet>245</a><span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span>BitOr <span class="kw">for </span>BigInt, bitor);
<a href=#246 id=246 data-nosnippet>246</a><span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span>BitOr <span class="kw">for </span>BigInt, bitor);
<a href=#247 id=247 data-nosnippet>247</a>
<a href=#248 id=248 data-nosnippet>248</a><span class="comment">// do not use forward_ref_ref_binop_commutative! for bitor so that we can
<a href=#249 id=249 data-nosnippet>249</a>// clone as needed, avoiding over-allocation
<a href=#250 id=250 data-nosnippet>250</a></span><span class="kw">impl </span>BitOr&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#251 id=251 data-nosnippet>251</a> <span class="kw">type </span>Output = BigInt;
<a href=#252 id=252 data-nosnippet>252</a>
<a href=#253 id=253 data-nosnippet>253</a> <span class="attr">#[inline]
<a href=#254 id=254 data-nosnippet>254</a> </span><span class="kw">fn </span>bitor(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#255 id=255 data-nosnippet>255</a> <span class="kw">match </span>(<span class="self">self</span>.sign, other.sign) {
<a href=#256 id=256 data-nosnippet>256</a> (NoSign, <span class="kw">_</span>) =&gt; other.clone(),
<a href=#257 id=257 data-nosnippet>257</a> (<span class="kw">_</span>, NoSign) =&gt; <span class="self">self</span>.clone(),
<a href=#258 id=258 data-nosnippet>258</a> (Plus, Plus) =&gt; BigInt::from(<span class="kw-2">&amp;</span><span class="self">self</span>.data | <span class="kw-2">&amp;</span>other.data),
<a href=#259 id=259 data-nosnippet>259</a> (Plus, Minus) =&gt; other.clone() | <span class="self">self</span>,
<a href=#260 id=260 data-nosnippet>260</a> (Minus, Plus) =&gt; <span class="self">self</span>.clone() | other,
<a href=#261 id=261 data-nosnippet>261</a> (Minus, Minus) =&gt; {
<a href=#262 id=262 data-nosnippet>262</a> <span class="comment">// forward to val-ref, choosing the smaller to clone
<a href=#263 id=263 data-nosnippet>263</a> </span><span class="kw">if </span><span class="self">self</span>.len() &lt;= other.len() {
<a href=#264 id=264 data-nosnippet>264</a> <span class="self">self</span>.clone() | other
<a href=#265 id=265 data-nosnippet>265</a> } <span class="kw">else </span>{
<a href=#266 id=266 data-nosnippet>266</a> other.clone() | <span class="self">self
<a href=#267 id=267 data-nosnippet>267</a> </span>}
<a href=#268 id=268 data-nosnippet>268</a> }
<a href=#269 id=269 data-nosnippet>269</a> }
<a href=#270 id=270 data-nosnippet>270</a> }
<a href=#271 id=271 data-nosnippet>271</a>}
<a href=#272 id=272 data-nosnippet>272</a>
<a href=#273 id=273 data-nosnippet>273</a><span class="kw">impl </span>BitOr&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#274 id=274 data-nosnippet>274</a> <span class="kw">type </span>Output = BigInt;
<a href=#275 id=275 data-nosnippet>275</a>
<a href=#276 id=276 data-nosnippet>276</a> <span class="attr">#[inline]
<a href=#277 id=277 data-nosnippet>277</a> </span><span class="kw">fn </span>bitor(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#278 id=278 data-nosnippet>278</a> <span class="self">self </span>|= other;
<a href=#279 id=279 data-nosnippet>279</a> <span class="self">self
<a href=#280 id=280 data-nosnippet>280</a> </span>}
<a href=#281 id=281 data-nosnippet>281</a>}
<a href=#282 id=282 data-nosnippet>282</a>
<a href=#283 id=283 data-nosnippet>283</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitOrAssign <span class="kw">for </span>BigInt, bitor_assign);
<a href=#284 id=284 data-nosnippet>284</a>
<a href=#285 id=285 data-nosnippet>285</a><span class="kw">impl </span>BitOrAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#286 id=286 data-nosnippet>286</a> <span class="kw">fn </span>bitor_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#287 id=287 data-nosnippet>287</a> <span class="kw">match </span>(<span class="self">self</span>.sign, other.sign) {
<a href=#288 id=288 data-nosnippet>288</a> (<span class="kw">_</span>, NoSign) =&gt; {}
<a href=#289 id=289 data-nosnippet>289</a> (NoSign, <span class="kw">_</span>) =&gt; <span class="self">self</span>.clone_from(other),
<a href=#290 id=290 data-nosnippet>290</a> (Plus, Plus) =&gt; <span class="self">self</span>.data |= <span class="kw-2">&amp;</span>other.data,
<a href=#291 id=291 data-nosnippet>291</a> (Plus, Minus) =&gt; {
<a href=#292 id=292 data-nosnippet>292</a> bitor_pos_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#293 id=293 data-nosnippet>293</a> <span class="self">self</span>.sign = Minus;
<a href=#294 id=294 data-nosnippet>294</a> <span class="self">self</span>.normalize();
<a href=#295 id=295 data-nosnippet>295</a> }
<a href=#296 id=296 data-nosnippet>296</a> (Minus, Plus) =&gt; {
<a href=#297 id=297 data-nosnippet>297</a> bitor_neg_pos(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#298 id=298 data-nosnippet>298</a> <span class="self">self</span>.normalize();
<a href=#299 id=299 data-nosnippet>299</a> }
<a href=#300 id=300 data-nosnippet>300</a> (Minus, Minus) =&gt; {
<a href=#301 id=301 data-nosnippet>301</a> bitor_neg_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#302 id=302 data-nosnippet>302</a> <span class="self">self</span>.normalize();
<a href=#303 id=303 data-nosnippet>303</a> }
<a href=#304 id=304 data-nosnippet>304</a> }
<a href=#305 id=305 data-nosnippet>305</a> }
<a href=#306 id=306 data-nosnippet>306</a>}
<a href=#307 id=307 data-nosnippet>307</a>
<a href=#308 id=308 data-nosnippet>308</a><span class="comment">// + 1 ^ -ff = ...0 01 ^ ...f 01 = ...f 00 = -100
<a href=#309 id=309 data-nosnippet>309</a>// +ff ^ - 1 = ...0 ff ^ ...f ff = ...f 00 = -100
<a href=#310 id=310 data-nosnippet>310</a>// answer is neg, has length of longest with a possible carry
<a href=#311 id=311 data-nosnippet>311</a></span><span class="kw">fn </span>bitxor_pos_neg(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#312 id=312 data-nosnippet>312</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#313 id=313 data-nosnippet>313</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_xor = <span class="number">1</span>;
<a href=#314 id=314 data-nosnippet>314</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#315 id=315 data-nosnippet>315</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#316 id=316 data-nosnippet>316</a> <span class="kw-2">*</span>ai = negate_carry(<span class="kw-2">*</span>ai ^ twos_b, <span class="kw-2">&amp;mut </span>carry_xor);
<a href=#317 id=317 data-nosnippet>317</a> }
<a href=#318 id=318 data-nosnippet>318</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#319 id=319 data-nosnippet>319</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#320 id=320 data-nosnippet>320</a> Greater =&gt; {
<a href=#321 id=321 data-nosnippet>321</a> <span class="kw">for </span>ai <span class="kw">in </span>a[b.len()..].iter_mut() {
<a href=#322 id=322 data-nosnippet>322</a> <span class="kw">let </span>twos_b = !<span class="number">0</span>;
<a href=#323 id=323 data-nosnippet>323</a> <span class="kw-2">*</span>ai = negate_carry(<span class="kw-2">*</span>ai ^ twos_b, <span class="kw-2">&amp;mut </span>carry_xor);
<a href=#324 id=324 data-nosnippet>324</a> }
<a href=#325 id=325 data-nosnippet>325</a> }
<a href=#326 id=326 data-nosnippet>326</a> Equal =&gt; {}
<a href=#327 id=327 data-nosnippet>327</a> Less =&gt; {
<a href=#328 id=328 data-nosnippet>328</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#329 id=329 data-nosnippet>329</a> a.extend(extra.iter().map(|<span class="kw-2">&amp;</span>bi| {
<a href=#330 id=330 data-nosnippet>330</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#331 id=331 data-nosnippet>331</a> negate_carry(twos_b, <span class="kw-2">&amp;mut </span>carry_xor)
<a href=#332 id=332 data-nosnippet>332</a> }));
<a href=#333 id=333 data-nosnippet>333</a> <span class="macro">debug_assert!</span>(carry_b == <span class="number">0</span>);
<a href=#334 id=334 data-nosnippet>334</a> }
<a href=#335 id=335 data-nosnippet>335</a> }
<a href=#336 id=336 data-nosnippet>336</a> <span class="kw">if </span><span class="macro">carry_xor !</span>= <span class="number">0 </span>{
<a href=#337 id=337 data-nosnippet>337</a> a.push(<span class="number">1</span>);
<a href=#338 id=338 data-nosnippet>338</a> }
<a href=#339 id=339 data-nosnippet>339</a>}
<a href=#340 id=340 data-nosnippet>340</a>
<a href=#341 id=341 data-nosnippet>341</a><span class="comment">// - 1 ^ +ff = ...f ff ^ ...0 ff = ...f 00 = -100
<a href=#342 id=342 data-nosnippet>342</a>// -ff ^ + 1 = ...f 01 ^ ...0 01 = ...f 00 = -100
<a href=#343 id=343 data-nosnippet>343</a>// answer is neg, has length of longest with a possible carry
<a href=#344 id=344 data-nosnippet>344</a></span><span class="kw">fn </span>bitxor_neg_pos(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#345 id=345 data-nosnippet>345</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#346 id=346 data-nosnippet>346</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_xor = <span class="number">1</span>;
<a href=#347 id=347 data-nosnippet>347</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#348 id=348 data-nosnippet>348</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#349 id=349 data-nosnippet>349</a> <span class="kw-2">*</span>ai = negate_carry(twos_a ^ bi, <span class="kw-2">&amp;mut </span>carry_xor);
<a href=#350 id=350 data-nosnippet>350</a> }
<a href=#351 id=351 data-nosnippet>351</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#352 id=352 data-nosnippet>352</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#353 id=353 data-nosnippet>353</a> Greater =&gt; {
<a href=#354 id=354 data-nosnippet>354</a> <span class="kw">for </span>ai <span class="kw">in </span>a[b.len()..].iter_mut() {
<a href=#355 id=355 data-nosnippet>355</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#356 id=356 data-nosnippet>356</a> <span class="kw-2">*</span>ai = negate_carry(twos_a, <span class="kw-2">&amp;mut </span>carry_xor);
<a href=#357 id=357 data-nosnippet>357</a> }
<a href=#358 id=358 data-nosnippet>358</a> <span class="macro">debug_assert!</span>(carry_a == <span class="number">0</span>);
<a href=#359 id=359 data-nosnippet>359</a> }
<a href=#360 id=360 data-nosnippet>360</a> Equal =&gt; {}
<a href=#361 id=361 data-nosnippet>361</a> Less =&gt; {
<a href=#362 id=362 data-nosnippet>362</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#363 id=363 data-nosnippet>363</a> a.extend(extra.iter().map(|<span class="kw-2">&amp;</span>bi| {
<a href=#364 id=364 data-nosnippet>364</a> <span class="kw">let </span>twos_a = !<span class="number">0</span>;
<a href=#365 id=365 data-nosnippet>365</a> negate_carry(twos_a ^ bi, <span class="kw-2">&amp;mut </span>carry_xor)
<a href=#366 id=366 data-nosnippet>366</a> }));
<a href=#367 id=367 data-nosnippet>367</a> }
<a href=#368 id=368 data-nosnippet>368</a> }
<a href=#369 id=369 data-nosnippet>369</a> <span class="kw">if </span><span class="macro">carry_xor !</span>= <span class="number">0 </span>{
<a href=#370 id=370 data-nosnippet>370</a> a.push(<span class="number">1</span>);
<a href=#371 id=371 data-nosnippet>371</a> }
<a href=#372 id=372 data-nosnippet>372</a>}
<a href=#373 id=373 data-nosnippet>373</a>
<a href=#374 id=374 data-nosnippet>374</a><span class="comment">// - 1 ^ -ff = ...f ff ^ ...f 01 = ...0 fe = +fe
<a href=#375 id=375 data-nosnippet>375</a>// -ff &amp; - 1 = ...f 01 ^ ...f ff = ...0 fe = +fe
<a href=#376 id=376 data-nosnippet>376</a>// answer is pos, has length of longest
<a href=#377 id=377 data-nosnippet>377</a></span><span class="kw">fn </span>bitxor_neg_neg(a: <span class="kw-2">&amp;mut </span>Vec&lt;BigDigit&gt;, b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#378 id=378 data-nosnippet>378</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_a = <span class="number">1</span>;
<a href=#379 id=379 data-nosnippet>379</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_b = <span class="number">1</span>;
<a href=#380 id=380 data-nosnippet>380</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span>a.iter_mut().zip(b.iter()) {
<a href=#381 id=381 data-nosnippet>381</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#382 id=382 data-nosnippet>382</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#383 id=383 data-nosnippet>383</a> <span class="kw-2">*</span>ai = twos_a ^ twos_b;
<a href=#384 id=384 data-nosnippet>384</a> }
<a href=#385 id=385 data-nosnippet>385</a> <span class="macro">debug_assert!</span>(a.len() &gt; b.len() || carry_a == <span class="number">0</span>);
<a href=#386 id=386 data-nosnippet>386</a> <span class="macro">debug_assert!</span>(b.len() &gt; a.len() || carry_b == <span class="number">0</span>);
<a href=#387 id=387 data-nosnippet>387</a> <span class="kw">match </span>Ord::cmp(<span class="kw-2">&amp;</span>a.len(), <span class="kw-2">&amp;</span>b.len()) {
<a href=#388 id=388 data-nosnippet>388</a> Greater =&gt; {
<a href=#389 id=389 data-nosnippet>389</a> <span class="kw">for </span>ai <span class="kw">in </span>a[b.len()..].iter_mut() {
<a href=#390 id=390 data-nosnippet>390</a> <span class="kw">let </span>twos_a = negate_carry(<span class="kw-2">*</span>ai, <span class="kw-2">&amp;mut </span>carry_a);
<a href=#391 id=391 data-nosnippet>391</a> <span class="kw">let </span>twos_b = !<span class="number">0</span>;
<a href=#392 id=392 data-nosnippet>392</a> <span class="kw-2">*</span>ai = twos_a ^ twos_b;
<a href=#393 id=393 data-nosnippet>393</a> }
<a href=#394 id=394 data-nosnippet>394</a> <span class="macro">debug_assert!</span>(carry_a == <span class="number">0</span>);
<a href=#395 id=395 data-nosnippet>395</a> }
<a href=#396 id=396 data-nosnippet>396</a> Equal =&gt; {}
<a href=#397 id=397 data-nosnippet>397</a> Less =&gt; {
<a href=#398 id=398 data-nosnippet>398</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>b[a.len()..];
<a href=#399 id=399 data-nosnippet>399</a> a.extend(extra.iter().map(|<span class="kw-2">&amp;</span>bi| {
<a href=#400 id=400 data-nosnippet>400</a> <span class="kw">let </span>twos_a = !<span class="number">0</span>;
<a href=#401 id=401 data-nosnippet>401</a> <span class="kw">let </span>twos_b = negate_carry(bi, <span class="kw-2">&amp;mut </span>carry_b);
<a href=#402 id=402 data-nosnippet>402</a> twos_a ^ twos_b
<a href=#403 id=403 data-nosnippet>403</a> }));
<a href=#404 id=404 data-nosnippet>404</a> <span class="macro">debug_assert!</span>(carry_b == <span class="number">0</span>);
<a href=#405 id=405 data-nosnippet>405</a> }
<a href=#406 id=406 data-nosnippet>406</a> }
<a href=#407 id=407 data-nosnippet>407</a>}
<a href=#408 id=408 data-nosnippet>408</a>
<a href=#409 id=409 data-nosnippet>409</a><span class="macro">forward_all_binop_to_val_ref_commutative!</span>(<span class="kw">impl </span>BitXor <span class="kw">for </span>BigInt, bitxor);
<a href=#410 id=410 data-nosnippet>410</a>
<a href=#411 id=411 data-nosnippet>411</a><span class="kw">impl </span>BitXor&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#412 id=412 data-nosnippet>412</a> <span class="kw">type </span>Output = BigInt;
<a href=#413 id=413 data-nosnippet>413</a>
<a href=#414 id=414 data-nosnippet>414</a> <span class="attr">#[inline]
<a href=#415 id=415 data-nosnippet>415</a> </span><span class="kw">fn </span>bitxor(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#416 id=416 data-nosnippet>416</a> <span class="self">self </span>^= other;
<a href=#417 id=417 data-nosnippet>417</a> <span class="self">self
<a href=#418 id=418 data-nosnippet>418</a> </span>}
<a href=#419 id=419 data-nosnippet>419</a>}
<a href=#420 id=420 data-nosnippet>420</a>
<a href=#421 id=421 data-nosnippet>421</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitXorAssign <span class="kw">for </span>BigInt, bitxor_assign);
<a href=#422 id=422 data-nosnippet>422</a>
<a href=#423 id=423 data-nosnippet>423</a><span class="kw">impl </span>BitXorAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#424 id=424 data-nosnippet>424</a> <span class="kw">fn </span>bitxor_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#425 id=425 data-nosnippet>425</a> <span class="kw">match </span>(<span class="self">self</span>.sign, other.sign) {
<a href=#426 id=426 data-nosnippet>426</a> (<span class="kw">_</span>, NoSign) =&gt; {}
<a href=#427 id=427 data-nosnippet>427</a> (NoSign, <span class="kw">_</span>) =&gt; <span class="self">self</span>.clone_from(other),
<a href=#428 id=428 data-nosnippet>428</a> (Plus, Plus) =&gt; {
<a href=#429 id=429 data-nosnippet>429</a> <span class="self">self</span>.data ^= <span class="kw-2">&amp;</span>other.data;
<a href=#430 id=430 data-nosnippet>430</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#431 id=431 data-nosnippet>431</a> <span class="self">self</span>.sign = NoSign;
<a href=#432 id=432 data-nosnippet>432</a> }
<a href=#433 id=433 data-nosnippet>433</a> }
<a href=#434 id=434 data-nosnippet>434</a> (Plus, Minus) =&gt; {
<a href=#435 id=435 data-nosnippet>435</a> bitxor_pos_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#436 id=436 data-nosnippet>436</a> <span class="self">self</span>.sign = Minus;
<a href=#437 id=437 data-nosnippet>437</a> <span class="self">self</span>.normalize();
<a href=#438 id=438 data-nosnippet>438</a> }
<a href=#439 id=439 data-nosnippet>439</a> (Minus, Plus) =&gt; {
<a href=#440 id=440 data-nosnippet>440</a> bitxor_neg_pos(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#441 id=441 data-nosnippet>441</a> <span class="self">self</span>.normalize();
<a href=#442 id=442 data-nosnippet>442</a> }
<a href=#443 id=443 data-nosnippet>443</a> (Minus, Minus) =&gt; {
<a href=#444 id=444 data-nosnippet>444</a> bitxor_neg_neg(<span class="self">self</span>.digits_mut(), other.digits());
<a href=#445 id=445 data-nosnippet>445</a> <span class="self">self</span>.sign = Plus;
<a href=#446 id=446 data-nosnippet>446</a> <span class="self">self</span>.normalize();
<a href=#447 id=447 data-nosnippet>447</a> }
<a href=#448 id=448 data-nosnippet>448</a> }
<a href=#449 id=449 data-nosnippet>449</a> }
<a href=#450 id=450 data-nosnippet>450</a>}
<a href=#451 id=451 data-nosnippet>451</a>
<a href=#452 id=452 data-nosnippet>452</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>set_negative_bit(x: <span class="kw-2">&amp;mut </span>BigInt, bit: u64, value: bool) {
<a href=#453 id=453 data-nosnippet>453</a> <span class="macro">debug_assert_eq!</span>(x.sign, Minus);
<a href=#454 id=454 data-nosnippet>454</a> <span class="kw">let </span>data = <span class="kw-2">&amp;mut </span>x.data;
<a href=#455 id=455 data-nosnippet>455</a>
<a href=#456 id=456 data-nosnippet>456</a> <span class="kw">let </span>bits_per_digit = u64::from(big_digit::BITS);
<a href=#457 id=457 data-nosnippet>457</a> <span class="kw">if </span>bit &gt;= bits_per_digit * data.len() <span class="kw">as </span>u64 {
<a href=#458 id=458 data-nosnippet>458</a> <span class="kw">if </span>!value {
<a href=#459 id=459 data-nosnippet>459</a> data.set_bit(bit, <span class="bool-val">true</span>);
<a href=#460 id=460 data-nosnippet>460</a> }
<a href=#461 id=461 data-nosnippet>461</a> } <span class="kw">else </span>{
<a href=#462 id=462 data-nosnippet>462</a> <span class="comment">// If the Uint number is
<a href=#463 id=463 data-nosnippet>463</a> // ... 0 x 1 0 ... 0
<a href=#464 id=464 data-nosnippet>464</a> // then the two's complement is
<a href=#465 id=465 data-nosnippet>465</a> // ... 1 !x 1 0 ... 0
<a href=#466 id=466 data-nosnippet>466</a> // |-- bit at position 'trailing_zeros'
<a href=#467 id=467 data-nosnippet>467</a> // where !x is obtained from x by flipping each bit
<a href=#468 id=468 data-nosnippet>468</a> </span><span class="kw">let </span>trailing_zeros = data.trailing_zeros().unwrap();
<a href=#469 id=469 data-nosnippet>469</a> <span class="kw">if </span>bit &gt; trailing_zeros {
<a href=#470 id=470 data-nosnippet>470</a> data.set_bit(bit, !value);
<a href=#471 id=471 data-nosnippet>471</a> } <span class="kw">else if </span>bit == trailing_zeros &amp;&amp; !value {
<a href=#472 id=472 data-nosnippet>472</a> <span class="comment">// Clearing the bit at position `trailing_zeros` is dealt with by doing
<a href=#473 id=473 data-nosnippet>473</a> // similarly to what `bitand_neg_pos` does, except we start at digit
<a href=#474 id=474 data-nosnippet>474</a> // `bit_index`. All digits below `bit_index` are guaranteed to be zero,
<a href=#475 id=475 data-nosnippet>475</a> // so initially we have `carry_in` = `carry_out` = 1. Furthermore, we
<a href=#476 id=476 data-nosnippet>476</a> // stop traversing the digits when there are no more carries.
<a href=#477 id=477 data-nosnippet>477</a> </span><span class="kw">let </span>bit_index = (bit / bits_per_digit).to_usize().unwrap();
<a href=#478 id=478 data-nosnippet>478</a> <span class="kw">let </span>bit_mask = (<span class="number">1 </span><span class="kw">as </span>BigDigit) &lt;&lt; (bit % bits_per_digit);
<a href=#479 id=479 data-nosnippet>479</a> <span class="kw">let </span><span class="kw-2">mut </span>digit_iter = data.digits_mut().iter_mut().skip(bit_index);
<a href=#480 id=480 data-nosnippet>480</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_in = <span class="number">1</span>;
<a href=#481 id=481 data-nosnippet>481</a> <span class="kw">let </span><span class="kw-2">mut </span>carry_out = <span class="number">1</span>;
<a href=#482 id=482 data-nosnippet>482</a>
<a href=#483 id=483 data-nosnippet>483</a> <span class="kw">let </span>digit = digit_iter.next().unwrap();
<a href=#484 id=484 data-nosnippet>484</a> <span class="kw">let </span>twos_in = negate_carry(<span class="kw-2">*</span>digit, <span class="kw-2">&amp;mut </span>carry_in);
<a href=#485 id=485 data-nosnippet>485</a> <span class="kw">let </span>twos_out = twos_in &amp; !bit_mask;
<a href=#486 id=486 data-nosnippet>486</a> <span class="kw-2">*</span>digit = negate_carry(twos_out, <span class="kw-2">&amp;mut </span>carry_out);
<a href=#487 id=487 data-nosnippet>487</a>
<a href=#488 id=488 data-nosnippet>488</a> <span class="kw">for </span>digit <span class="kw">in </span>digit_iter {
<a href=#489 id=489 data-nosnippet>489</a> <span class="kw">if </span>carry_in == <span class="number">0 </span>&amp;&amp; carry_out == <span class="number">0 </span>{
<a href=#490 id=490 data-nosnippet>490</a> <span class="comment">// Exit the loop since no more digits can change
<a href=#491 id=491 data-nosnippet>491</a> </span><span class="kw">break</span>;
<a href=#492 id=492 data-nosnippet>492</a> }
<a href=#493 id=493 data-nosnippet>493</a> <span class="kw">let </span>twos = negate_carry(<span class="kw-2">*</span>digit, <span class="kw-2">&amp;mut </span>carry_in);
<a href=#494 id=494 data-nosnippet>494</a> <span class="kw-2">*</span>digit = negate_carry(twos, <span class="kw-2">&amp;mut </span>carry_out);
<a href=#495 id=495 data-nosnippet>495</a> }
<a href=#496 id=496 data-nosnippet>496</a>
<a href=#497 id=497 data-nosnippet>497</a> <span class="kw">if </span><span class="macro">carry_out !</span>= <span class="number">0 </span>{
<a href=#498 id=498 data-nosnippet>498</a> <span class="comment">// All digits have been traversed and there is a carry
<a href=#499 id=499 data-nosnippet>499</a> </span><span class="macro">debug_assert_eq!</span>(carry_in, <span class="number">0</span>);
<a href=#500 id=500 data-nosnippet>500</a> data.digits_mut().push(<span class="number">1</span>);
<a href=#501 id=501 data-nosnippet>501</a> }
<a href=#502 id=502 data-nosnippet>502</a> } <span class="kw">else if </span>bit &lt; trailing_zeros &amp;&amp; value {
<a href=#503 id=503 data-nosnippet>503</a> <span class="comment">// Flip each bit from position 'bit' to 'trailing_zeros', both inclusive
<a href=#504 id=504 data-nosnippet>504</a> // ... 1 !x 1 0 ... 0 ... 0
<a href=#505 id=505 data-nosnippet>505</a> // |-- bit at position 'bit'
<a href=#506 id=506 data-nosnippet>506</a> // |-- bit at position 'trailing_zeros'
<a href=#507 id=507 data-nosnippet>507</a> // bit_mask: 1 1 ... 1 0 .. 0
<a href=#508 id=508 data-nosnippet>508</a> // This is done by xor'ing with the bit_mask
<a href=#509 id=509 data-nosnippet>509</a> </span><span class="kw">let </span>index_lo = (bit / bits_per_digit).to_usize().unwrap();
<a href=#510 id=510 data-nosnippet>510</a> <span class="kw">let </span>index_hi = (trailing_zeros / bits_per_digit).to_usize().unwrap();
<a href=#511 id=511 data-nosnippet>511</a> <span class="kw">let </span>bit_mask_lo = big_digit::MAX &lt;&lt; (bit % bits_per_digit);
<a href=#512 id=512 data-nosnippet>512</a> <span class="kw">let </span>bit_mask_hi =
<a href=#513 id=513 data-nosnippet>513</a> big_digit::MAX &gt;&gt; (bits_per_digit - <span class="number">1 </span>- (trailing_zeros % bits_per_digit));
<a href=#514 id=514 data-nosnippet>514</a> <span class="kw">let </span>digits = data.digits_mut();
<a href=#515 id=515 data-nosnippet>515</a>
<a href=#516 id=516 data-nosnippet>516</a> <span class="kw">if </span>index_lo == index_hi {
<a href=#517 id=517 data-nosnippet>517</a> digits[index_lo] ^= bit_mask_lo &amp; bit_mask_hi;
<a href=#518 id=518 data-nosnippet>518</a> } <span class="kw">else </span>{
<a href=#519 id=519 data-nosnippet>519</a> digits[index_lo] = bit_mask_lo;
<a href=#520 id=520 data-nosnippet>520</a> <span class="kw">for </span>digit <span class="kw">in </span><span class="kw-2">&amp;mut </span>digits[index_lo + <span class="number">1</span>..index_hi] {
<a href=#521 id=521 data-nosnippet>521</a> <span class="kw-2">*</span>digit = big_digit::MAX;
<a href=#522 id=522 data-nosnippet>522</a> }
<a href=#523 id=523 data-nosnippet>523</a> digits[index_hi] ^= bit_mask_hi;
<a href=#524 id=524 data-nosnippet>524</a> }
<a href=#525 id=525 data-nosnippet>525</a> } <span class="kw">else </span>{
<a href=#526 id=526 data-nosnippet>526</a> <span class="comment">// We end up here in two cases:
<a href=#527 id=527 data-nosnippet>527</a> // bit == trailing_zeros &amp;&amp; value: Bit is already set
<a href=#528 id=528 data-nosnippet>528</a> // bit &lt; trailing_zeros &amp;&amp; !value: Bit is already cleared
<a href=#529 id=529 data-nosnippet>529</a> </span>}
<a href=#530 id=530 data-nosnippet>530</a> }
<a href=#531 id=531 data-nosnippet>531</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,473 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/convert.rs`."><title>convert.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>convert.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::Sign::{<span class="self">self</span>, Minus, NoSign, Plus};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use super</span>::{BigInt, ToBigInt};
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::TryFromBigIntError;
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use crate</span>::{BigUint, ParseBigIntError, ToBigUint};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>alloc::vec::Vec;
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::convert::TryFrom;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>core::str::{<span class="self">self</span>, FromStr};
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span>num_traits::{FromPrimitive, Num, One, ToPrimitive, Zero};
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="kw">impl </span>FromStr <span class="kw">for </span>BigInt {
<a href=#14 id=14 data-nosnippet>14</a> <span class="kw">type </span><span class="prelude-val">Err </span>= ParseBigIntError;
<a href=#15 id=15 data-nosnippet>15</a>
<a href=#16 id=16 data-nosnippet>16</a> <span class="attr">#[inline]
<a href=#17 id=17 data-nosnippet>17</a> </span><span class="kw">fn </span>from_str(s: <span class="kw-2">&amp;</span>str) -&gt; <span class="prelude-ty">Result</span>&lt;BigInt, ParseBigIntError&gt; {
<a href=#18 id=18 data-nosnippet>18</a> BigInt::from_str_radix(s, <span class="number">10</span>)
<a href=#19 id=19 data-nosnippet>19</a> }
<a href=#20 id=20 data-nosnippet>20</a>}
<a href=#21 id=21 data-nosnippet>21</a>
<a href=#22 id=22 data-nosnippet>22</a><span class="kw">impl </span>Num <span class="kw">for </span>BigInt {
<a href=#23 id=23 data-nosnippet>23</a> <span class="kw">type </span>FromStrRadixErr = ParseBigIntError;
<a href=#24 id=24 data-nosnippet>24</a>
<a href=#25 id=25 data-nosnippet>25</a> <span class="doccomment">/// Creates and initializes a [`BigInt`].
<a href=#26 id=26 data-nosnippet>26</a> </span><span class="attr">#[inline]
<a href=#27 id=27 data-nosnippet>27</a> </span><span class="kw">fn </span>from_str_radix(<span class="kw-2">mut </span>s: <span class="kw-2">&amp;</span>str, radix: u32) -&gt; <span class="prelude-ty">Result</span>&lt;BigInt, ParseBigIntError&gt; {
<a href=#28 id=28 data-nosnippet>28</a> <span class="kw">let </span>sign = <span class="kw">if let </span><span class="prelude-val">Some</span>(tail) = s.strip_prefix(<span class="string">'-'</span>) {
<a href=#29 id=29 data-nosnippet>29</a> <span class="kw">if </span>!tail.starts_with(<span class="string">'+'</span>) {
<a href=#30 id=30 data-nosnippet>30</a> s = tail
<a href=#31 id=31 data-nosnippet>31</a> }
<a href=#32 id=32 data-nosnippet>32</a> Minus
<a href=#33 id=33 data-nosnippet>33</a> } <span class="kw">else </span>{
<a href=#34 id=34 data-nosnippet>34</a> Plus
<a href=#35 id=35 data-nosnippet>35</a> };
<a href=#36 id=36 data-nosnippet>36</a> <span class="kw">let </span>bu = BigUint::from_str_radix(s, radix)<span class="question-mark">?</span>;
<a href=#37 id=37 data-nosnippet>37</a> <span class="prelude-val">Ok</span>(BigInt::from_biguint(sign, bu))
<a href=#38 id=38 data-nosnippet>38</a> }
<a href=#39 id=39 data-nosnippet>39</a>}
<a href=#40 id=40 data-nosnippet>40</a>
<a href=#41 id=41 data-nosnippet>41</a><span class="kw">impl </span>ToPrimitive <span class="kw">for </span>BigInt {
<a href=#42 id=42 data-nosnippet>42</a> <span class="attr">#[inline]
<a href=#43 id=43 data-nosnippet>43</a> </span><span class="kw">fn </span>to_i64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;i64&gt; {
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#45 id=45 data-nosnippet>45</a> Plus =&gt; <span class="self">self</span>.data.to_i64(),
<a href=#46 id=46 data-nosnippet>46</a> NoSign =&gt; <span class="prelude-val">Some</span>(<span class="number">0</span>),
<a href=#47 id=47 data-nosnippet>47</a> Minus =&gt; {
<a href=#48 id=48 data-nosnippet>48</a> <span class="kw">let </span>n = <span class="self">self</span>.data.to_u64()<span class="question-mark">?</span>;
<a href=#49 id=49 data-nosnippet>49</a> <span class="kw">let </span>m: u64 = <span class="number">1 </span>&lt;&lt; <span class="number">63</span>;
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">match </span>n.cmp(<span class="kw-2">&amp;</span>m) {
<a href=#51 id=51 data-nosnippet>51</a> Less =&gt; <span class="prelude-val">Some</span>(-(n <span class="kw">as </span>i64)),
<a href=#52 id=52 data-nosnippet>52</a> Equal =&gt; <span class="prelude-val">Some</span>(i64::MIN),
<a href=#53 id=53 data-nosnippet>53</a> Greater =&gt; <span class="prelude-val">None</span>,
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a> }
<a href=#56 id=56 data-nosnippet>56</a> }
<a href=#57 id=57 data-nosnippet>57</a> }
<a href=#58 id=58 data-nosnippet>58</a>
<a href=#59 id=59 data-nosnippet>59</a> <span class="attr">#[inline]
<a href=#60 id=60 data-nosnippet>60</a> </span><span class="kw">fn </span>to_i128(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;i128&gt; {
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#62 id=62 data-nosnippet>62</a> Plus =&gt; <span class="self">self</span>.data.to_i128(),
<a href=#63 id=63 data-nosnippet>63</a> NoSign =&gt; <span class="prelude-val">Some</span>(<span class="number">0</span>),
<a href=#64 id=64 data-nosnippet>64</a> Minus =&gt; {
<a href=#65 id=65 data-nosnippet>65</a> <span class="kw">let </span>n = <span class="self">self</span>.data.to_u128()<span class="question-mark">?</span>;
<a href=#66 id=66 data-nosnippet>66</a> <span class="kw">let </span>m: u128 = <span class="number">1 </span>&lt;&lt; <span class="number">127</span>;
<a href=#67 id=67 data-nosnippet>67</a> <span class="kw">match </span>n.cmp(<span class="kw-2">&amp;</span>m) {
<a href=#68 id=68 data-nosnippet>68</a> Less =&gt; <span class="prelude-val">Some</span>(-(n <span class="kw">as </span>i128)),
<a href=#69 id=69 data-nosnippet>69</a> Equal =&gt; <span class="prelude-val">Some</span>(i128::MIN),
<a href=#70 id=70 data-nosnippet>70</a> Greater =&gt; <span class="prelude-val">None</span>,
<a href=#71 id=71 data-nosnippet>71</a> }
<a href=#72 id=72 data-nosnippet>72</a> }
<a href=#73 id=73 data-nosnippet>73</a> }
<a href=#74 id=74 data-nosnippet>74</a> }
<a href=#75 id=75 data-nosnippet>75</a>
<a href=#76 id=76 data-nosnippet>76</a> <span class="attr">#[inline]
<a href=#77 id=77 data-nosnippet>77</a> </span><span class="kw">fn </span>to_u64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#79 id=79 data-nosnippet>79</a> Plus =&gt; <span class="self">self</span>.data.to_u64(),
<a href=#80 id=80 data-nosnippet>80</a> NoSign =&gt; <span class="prelude-val">Some</span>(<span class="number">0</span>),
<a href=#81 id=81 data-nosnippet>81</a> Minus =&gt; <span class="prelude-val">None</span>,
<a href=#82 id=82 data-nosnippet>82</a> }
<a href=#83 id=83 data-nosnippet>83</a> }
<a href=#84 id=84 data-nosnippet>84</a>
<a href=#85 id=85 data-nosnippet>85</a> <span class="attr">#[inline]
<a href=#86 id=86 data-nosnippet>86</a> </span><span class="kw">fn </span>to_u128(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u128&gt; {
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#88 id=88 data-nosnippet>88</a> Plus =&gt; <span class="self">self</span>.data.to_u128(),
<a href=#89 id=89 data-nosnippet>89</a> NoSign =&gt; <span class="prelude-val">Some</span>(<span class="number">0</span>),
<a href=#90 id=90 data-nosnippet>90</a> Minus =&gt; <span class="prelude-val">None</span>,
<a href=#91 id=91 data-nosnippet>91</a> }
<a href=#92 id=92 data-nosnippet>92</a> }
<a href=#93 id=93 data-nosnippet>93</a>
<a href=#94 id=94 data-nosnippet>94</a> <span class="attr">#[inline]
<a href=#95 id=95 data-nosnippet>95</a> </span><span class="kw">fn </span>to_f32(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;f32&gt; {
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">let </span>n = <span class="self">self</span>.data.to_f32()<span class="question-mark">?</span>;
<a href=#97 id=97 data-nosnippet>97</a> <span class="prelude-val">Some</span>(<span class="kw">if </span><span class="self">self</span>.sign == Minus { -n } <span class="kw">else </span>{ n })
<a href=#98 id=98 data-nosnippet>98</a> }
<a href=#99 id=99 data-nosnippet>99</a>
<a href=#100 id=100 data-nosnippet>100</a> <span class="attr">#[inline]
<a href=#101 id=101 data-nosnippet>101</a> </span><span class="kw">fn </span>to_f64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;f64&gt; {
<a href=#102 id=102 data-nosnippet>102</a> <span class="kw">let </span>n = <span class="self">self</span>.data.to_f64()<span class="question-mark">?</span>;
<a href=#103 id=103 data-nosnippet>103</a> <span class="prelude-val">Some</span>(<span class="kw">if </span><span class="self">self</span>.sign == Minus { -n } <span class="kw">else </span>{ n })
<a href=#104 id=104 data-nosnippet>104</a> }
<a href=#105 id=105 data-nosnippet>105</a>}
<a href=#106 id=106 data-nosnippet>106</a>
<a href=#107 id=107 data-nosnippet>107</a><span class="macro">macro_rules!</span> impl_try_from_bigint {
<a href=#108 id=108 data-nosnippet>108</a> (<span class="macro-nonterminal">$T</span>:ty, <span class="macro-nonterminal">$to_ty</span>:path) =&gt; {
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">impl </span>TryFrom&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#110 id=110 data-nosnippet>110</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;()&gt;;
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a> <span class="attr">#[inline]
<a href=#113 id=113 data-nosnippet>113</a> </span><span class="kw">fn </span>try_from(value: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Result</span>&lt;<span class="macro-nonterminal">$T</span>, TryFromBigIntError&lt;()&gt;&gt; {
<a href=#114 id=114 data-nosnippet>114</a> <span class="macro-nonterminal">$to_ty</span>(value).ok_or(TryFromBigIntError::new(()))
<a href=#115 id=115 data-nosnippet>115</a> }
<a href=#116 id=116 data-nosnippet>116</a> }
<a href=#117 id=117 data-nosnippet>117</a>
<a href=#118 id=118 data-nosnippet>118</a> <span class="kw">impl </span>TryFrom&lt;BigInt&gt; <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#119 id=119 data-nosnippet>119</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;BigInt&gt;;
<a href=#120 id=120 data-nosnippet>120</a>
<a href=#121 id=121 data-nosnippet>121</a> <span class="attr">#[inline]
<a href=#122 id=122 data-nosnippet>122</a> </span><span class="kw">fn </span>try_from(value: BigInt) -&gt; <span class="prelude-ty">Result</span>&lt;<span class="macro-nonterminal">$T</span>, TryFromBigIntError&lt;BigInt&gt;&gt; {
<a href=#123 id=123 data-nosnippet>123</a> &lt;<span class="macro-nonterminal">$T</span>&gt;::try_from(<span class="kw-2">&amp;</span>value).map_err(|<span class="kw">_</span>| TryFromBigIntError::new(value))
<a href=#124 id=124 data-nosnippet>124</a> }
<a href=#125 id=125 data-nosnippet>125</a> }
<a href=#126 id=126 data-nosnippet>126</a> };
<a href=#127 id=127 data-nosnippet>127</a>}
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a><span class="macro">impl_try_from_bigint!</span>(u8, ToPrimitive::to_u8);
<a href=#130 id=130 data-nosnippet>130</a><span class="macro">impl_try_from_bigint!</span>(u16, ToPrimitive::to_u16);
<a href=#131 id=131 data-nosnippet>131</a><span class="macro">impl_try_from_bigint!</span>(u32, ToPrimitive::to_u32);
<a href=#132 id=132 data-nosnippet>132</a><span class="macro">impl_try_from_bigint!</span>(u64, ToPrimitive::to_u64);
<a href=#133 id=133 data-nosnippet>133</a><span class="macro">impl_try_from_bigint!</span>(usize, ToPrimitive::to_usize);
<a href=#134 id=134 data-nosnippet>134</a><span class="macro">impl_try_from_bigint!</span>(u128, ToPrimitive::to_u128);
<a href=#135 id=135 data-nosnippet>135</a>
<a href=#136 id=136 data-nosnippet>136</a><span class="macro">impl_try_from_bigint!</span>(i8, ToPrimitive::to_i8);
<a href=#137 id=137 data-nosnippet>137</a><span class="macro">impl_try_from_bigint!</span>(i16, ToPrimitive::to_i16);
<a href=#138 id=138 data-nosnippet>138</a><span class="macro">impl_try_from_bigint!</span>(i32, ToPrimitive::to_i32);
<a href=#139 id=139 data-nosnippet>139</a><span class="macro">impl_try_from_bigint!</span>(i64, ToPrimitive::to_i64);
<a href=#140 id=140 data-nosnippet>140</a><span class="macro">impl_try_from_bigint!</span>(isize, ToPrimitive::to_isize);
<a href=#141 id=141 data-nosnippet>141</a><span class="macro">impl_try_from_bigint!</span>(i128, ToPrimitive::to_i128);
<a href=#142 id=142 data-nosnippet>142</a>
<a href=#143 id=143 data-nosnippet>143</a><span class="kw">impl </span>FromPrimitive <span class="kw">for </span>BigInt {
<a href=#144 id=144 data-nosnippet>144</a> <span class="attr">#[inline]
<a href=#145 id=145 data-nosnippet>145</a> </span><span class="kw">fn </span>from_i64(n: i64) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#146 id=146 data-nosnippet>146</a> <span class="prelude-val">Some</span>(BigInt::from(n))
<a href=#147 id=147 data-nosnippet>147</a> }
<a href=#148 id=148 data-nosnippet>148</a>
<a href=#149 id=149 data-nosnippet>149</a> <span class="attr">#[inline]
<a href=#150 id=150 data-nosnippet>150</a> </span><span class="kw">fn </span>from_i128(n: i128) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#151 id=151 data-nosnippet>151</a> <span class="prelude-val">Some</span>(BigInt::from(n))
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a>
<a href=#154 id=154 data-nosnippet>154</a> <span class="attr">#[inline]
<a href=#155 id=155 data-nosnippet>155</a> </span><span class="kw">fn </span>from_u64(n: u64) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#156 id=156 data-nosnippet>156</a> <span class="prelude-val">Some</span>(BigInt::from(n))
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a>
<a href=#159 id=159 data-nosnippet>159</a> <span class="attr">#[inline]
<a href=#160 id=160 data-nosnippet>160</a> </span><span class="kw">fn </span>from_u128(n: u128) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#161 id=161 data-nosnippet>161</a> <span class="prelude-val">Some</span>(BigInt::from(n))
<a href=#162 id=162 data-nosnippet>162</a> }
<a href=#163 id=163 data-nosnippet>163</a>
<a href=#164 id=164 data-nosnippet>164</a> <span class="attr">#[inline]
<a href=#165 id=165 data-nosnippet>165</a> </span><span class="kw">fn </span>from_f64(n: f64) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">if </span>n &gt;= <span class="number">0.0 </span>{
<a href=#167 id=167 data-nosnippet>167</a> BigUint::from_f64(n).map(BigInt::from)
<a href=#168 id=168 data-nosnippet>168</a> } <span class="kw">else </span>{
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">let </span>x = BigUint::from_f64(-n)<span class="question-mark">?</span>;
<a href=#170 id=170 data-nosnippet>170</a> <span class="prelude-val">Some</span>(-BigInt::from(x))
<a href=#171 id=171 data-nosnippet>171</a> }
<a href=#172 id=172 data-nosnippet>172</a> }
<a href=#173 id=173 data-nosnippet>173</a>}
<a href=#174 id=174 data-nosnippet>174</a>
<a href=#175 id=175 data-nosnippet>175</a><span class="kw">impl </span>From&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#176 id=176 data-nosnippet>176</a> <span class="attr">#[inline]
<a href=#177 id=177 data-nosnippet>177</a> </span><span class="kw">fn </span>from(n: i64) -&gt; <span class="self">Self </span>{
<a href=#178 id=178 data-nosnippet>178</a> <span class="kw">if </span>n &gt;= <span class="number">0 </span>{
<a href=#179 id=179 data-nosnippet>179</a> BigInt::from(n <span class="kw">as </span>u64)
<a href=#180 id=180 data-nosnippet>180</a> } <span class="kw">else </span>{
<a href=#181 id=181 data-nosnippet>181</a> <span class="kw">let </span>u = u64::MAX - (n <span class="kw">as </span>u64) + <span class="number">1</span>;
<a href=#182 id=182 data-nosnippet>182</a> BigInt {
<a href=#183 id=183 data-nosnippet>183</a> sign: Minus,
<a href=#184 id=184 data-nosnippet>184</a> data: BigUint::from(u),
<a href=#185 id=185 data-nosnippet>185</a> }
<a href=#186 id=186 data-nosnippet>186</a> }
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a>}
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a><span class="kw">impl </span>From&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#191 id=191 data-nosnippet>191</a> <span class="attr">#[inline]
<a href=#192 id=192 data-nosnippet>192</a> </span><span class="kw">fn </span>from(n: i128) -&gt; <span class="self">Self </span>{
<a href=#193 id=193 data-nosnippet>193</a> <span class="kw">if </span>n &gt;= <span class="number">0 </span>{
<a href=#194 id=194 data-nosnippet>194</a> BigInt::from(n <span class="kw">as </span>u128)
<a href=#195 id=195 data-nosnippet>195</a> } <span class="kw">else </span>{
<a href=#196 id=196 data-nosnippet>196</a> <span class="kw">let </span>u = u128::MAX - (n <span class="kw">as </span>u128) + <span class="number">1</span>;
<a href=#197 id=197 data-nosnippet>197</a> BigInt {
<a href=#198 id=198 data-nosnippet>198</a> sign: Minus,
<a href=#199 id=199 data-nosnippet>199</a> data: BigUint::from(u),
<a href=#200 id=200 data-nosnippet>200</a> }
<a href=#201 id=201 data-nosnippet>201</a> }
<a href=#202 id=202 data-nosnippet>202</a> }
<a href=#203 id=203 data-nosnippet>203</a>}
<a href=#204 id=204 data-nosnippet>204</a>
<a href=#205 id=205 data-nosnippet>205</a><span class="macro">macro_rules!</span> impl_bigint_from_int {
<a href=#206 id=206 data-nosnippet>206</a> (<span class="macro-nonterminal">$T</span>:ty) =&gt; {
<a href=#207 id=207 data-nosnippet>207</a> <span class="kw">impl </span>From&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigInt {
<a href=#208 id=208 data-nosnippet>208</a> <span class="attr">#[inline]
<a href=#209 id=209 data-nosnippet>209</a> </span><span class="kw">fn </span>from(n: <span class="macro-nonterminal">$T</span>) -&gt; <span class="self">Self </span>{
<a href=#210 id=210 data-nosnippet>210</a> BigInt::from(n <span class="kw">as </span>i64)
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a> }
<a href=#213 id=213 data-nosnippet>213</a> };
<a href=#214 id=214 data-nosnippet>214</a>}
<a href=#215 id=215 data-nosnippet>215</a>
<a href=#216 id=216 data-nosnippet>216</a><span class="macro">impl_bigint_from_int!</span>(i8);
<a href=#217 id=217 data-nosnippet>217</a><span class="macro">impl_bigint_from_int!</span>(i16);
<a href=#218 id=218 data-nosnippet>218</a><span class="macro">impl_bigint_from_int!</span>(i32);
<a href=#219 id=219 data-nosnippet>219</a><span class="macro">impl_bigint_from_int!</span>(isize);
<a href=#220 id=220 data-nosnippet>220</a>
<a href=#221 id=221 data-nosnippet>221</a><span class="kw">impl </span>From&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#222 id=222 data-nosnippet>222</a> <span class="attr">#[inline]
<a href=#223 id=223 data-nosnippet>223</a> </span><span class="kw">fn </span>from(n: u64) -&gt; <span class="self">Self </span>{
<a href=#224 id=224 data-nosnippet>224</a> <span class="kw">if </span>n &gt; <span class="number">0 </span>{
<a href=#225 id=225 data-nosnippet>225</a> BigInt {
<a href=#226 id=226 data-nosnippet>226</a> sign: Plus,
<a href=#227 id=227 data-nosnippet>227</a> data: BigUint::from(n),
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a> } <span class="kw">else </span>{
<a href=#230 id=230 data-nosnippet>230</a> <span class="self">Self</span>::ZERO
<a href=#231 id=231 data-nosnippet>231</a> }
<a href=#232 id=232 data-nosnippet>232</a> }
<a href=#233 id=233 data-nosnippet>233</a>}
<a href=#234 id=234 data-nosnippet>234</a>
<a href=#235 id=235 data-nosnippet>235</a><span class="kw">impl </span>From&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#236 id=236 data-nosnippet>236</a> <span class="attr">#[inline]
<a href=#237 id=237 data-nosnippet>237</a> </span><span class="kw">fn </span>from(n: u128) -&gt; <span class="self">Self </span>{
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">if </span>n &gt; <span class="number">0 </span>{
<a href=#239 id=239 data-nosnippet>239</a> BigInt {
<a href=#240 id=240 data-nosnippet>240</a> sign: Plus,
<a href=#241 id=241 data-nosnippet>241</a> data: BigUint::from(n),
<a href=#242 id=242 data-nosnippet>242</a> }
<a href=#243 id=243 data-nosnippet>243</a> } <span class="kw">else </span>{
<a href=#244 id=244 data-nosnippet>244</a> <span class="self">Self</span>::ZERO
<a href=#245 id=245 data-nosnippet>245</a> }
<a href=#246 id=246 data-nosnippet>246</a> }
<a href=#247 id=247 data-nosnippet>247</a>}
<a href=#248 id=248 data-nosnippet>248</a>
<a href=#249 id=249 data-nosnippet>249</a><span class="macro">macro_rules!</span> impl_bigint_from_uint {
<a href=#250 id=250 data-nosnippet>250</a> (<span class="macro-nonterminal">$T</span>:ty) =&gt; {
<a href=#251 id=251 data-nosnippet>251</a> <span class="kw">impl </span>From&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigInt {
<a href=#252 id=252 data-nosnippet>252</a> <span class="attr">#[inline]
<a href=#253 id=253 data-nosnippet>253</a> </span><span class="kw">fn </span>from(n: <span class="macro-nonterminal">$T</span>) -&gt; <span class="self">Self </span>{
<a href=#254 id=254 data-nosnippet>254</a> BigInt::from(n <span class="kw">as </span>u64)
<a href=#255 id=255 data-nosnippet>255</a> }
<a href=#256 id=256 data-nosnippet>256</a> }
<a href=#257 id=257 data-nosnippet>257</a> };
<a href=#258 id=258 data-nosnippet>258</a>}
<a href=#259 id=259 data-nosnippet>259</a>
<a href=#260 id=260 data-nosnippet>260</a><span class="macro">impl_bigint_from_uint!</span>(u8);
<a href=#261 id=261 data-nosnippet>261</a><span class="macro">impl_bigint_from_uint!</span>(u16);
<a href=#262 id=262 data-nosnippet>262</a><span class="macro">impl_bigint_from_uint!</span>(u32);
<a href=#263 id=263 data-nosnippet>263</a><span class="macro">impl_bigint_from_uint!</span>(usize);
<a href=#264 id=264 data-nosnippet>264</a>
<a href=#265 id=265 data-nosnippet>265</a><span class="kw">impl </span>From&lt;BigUint&gt; <span class="kw">for </span>BigInt {
<a href=#266 id=266 data-nosnippet>266</a> <span class="attr">#[inline]
<a href=#267 id=267 data-nosnippet>267</a> </span><span class="kw">fn </span>from(n: BigUint) -&gt; <span class="self">Self </span>{
<a href=#268 id=268 data-nosnippet>268</a> <span class="kw">if </span>n.is_zero() {
<a href=#269 id=269 data-nosnippet>269</a> <span class="self">Self</span>::ZERO
<a href=#270 id=270 data-nosnippet>270</a> } <span class="kw">else </span>{
<a href=#271 id=271 data-nosnippet>271</a> BigInt {
<a href=#272 id=272 data-nosnippet>272</a> sign: Plus,
<a href=#273 id=273 data-nosnippet>273</a> data: n,
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a> }
<a href=#276 id=276 data-nosnippet>276</a> }
<a href=#277 id=277 data-nosnippet>277</a>}
<a href=#278 id=278 data-nosnippet>278</a>
<a href=#279 id=279 data-nosnippet>279</a><span class="kw">impl </span>ToBigInt <span class="kw">for </span>BigInt {
<a href=#280 id=280 data-nosnippet>280</a> <span class="attr">#[inline]
<a href=#281 id=281 data-nosnippet>281</a> </span><span class="kw">fn </span>to_bigint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#282 id=282 data-nosnippet>282</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.clone())
<a href=#283 id=283 data-nosnippet>283</a> }
<a href=#284 id=284 data-nosnippet>284</a>}
<a href=#285 id=285 data-nosnippet>285</a>
<a href=#286 id=286 data-nosnippet>286</a><span class="kw">impl </span>ToBigInt <span class="kw">for </span>BigUint {
<a href=#287 id=287 data-nosnippet>287</a> <span class="attr">#[inline]
<a href=#288 id=288 data-nosnippet>288</a> </span><span class="kw">fn </span>to_bigint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#289 id=289 data-nosnippet>289</a> <span class="kw">if </span><span class="self">self</span>.is_zero() {
<a href=#290 id=290 data-nosnippet>290</a> <span class="prelude-val">Some</span>(BigInt::ZERO)
<a href=#291 id=291 data-nosnippet>291</a> } <span class="kw">else </span>{
<a href=#292 id=292 data-nosnippet>292</a> <span class="prelude-val">Some</span>(BigInt {
<a href=#293 id=293 data-nosnippet>293</a> sign: Plus,
<a href=#294 id=294 data-nosnippet>294</a> data: <span class="self">self</span>.clone(),
<a href=#295 id=295 data-nosnippet>295</a> })
<a href=#296 id=296 data-nosnippet>296</a> }
<a href=#297 id=297 data-nosnippet>297</a> }
<a href=#298 id=298 data-nosnippet>298</a>}
<a href=#299 id=299 data-nosnippet>299</a>
<a href=#300 id=300 data-nosnippet>300</a><span class="kw">impl </span>ToBigUint <span class="kw">for </span>BigInt {
<a href=#301 id=301 data-nosnippet>301</a> <span class="attr">#[inline]
<a href=#302 id=302 data-nosnippet>302</a> </span><span class="kw">fn </span>to_biguint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#303 id=303 data-nosnippet>303</a> <span class="kw">match </span><span class="self">self</span>.sign() {
<a href=#304 id=304 data-nosnippet>304</a> Plus =&gt; <span class="prelude-val">Some</span>(<span class="self">self</span>.data.clone()),
<a href=#305 id=305 data-nosnippet>305</a> NoSign =&gt; <span class="prelude-val">Some</span>(BigUint::ZERO),
<a href=#306 id=306 data-nosnippet>306</a> Minus =&gt; <span class="prelude-val">None</span>,
<a href=#307 id=307 data-nosnippet>307</a> }
<a href=#308 id=308 data-nosnippet>308</a> }
<a href=#309 id=309 data-nosnippet>309</a>}
<a href=#310 id=310 data-nosnippet>310</a>
<a href=#311 id=311 data-nosnippet>311</a><span class="kw">impl </span>TryFrom&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigUint {
<a href=#312 id=312 data-nosnippet>312</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;()&gt;;
<a href=#313 id=313 data-nosnippet>313</a>
<a href=#314 id=314 data-nosnippet>314</a> <span class="attr">#[inline]
<a href=#315 id=315 data-nosnippet>315</a> </span><span class="kw">fn </span>try_from(value: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Result</span>&lt;BigUint, TryFromBigIntError&lt;()&gt;&gt; {
<a href=#316 id=316 data-nosnippet>316</a> value
<a href=#317 id=317 data-nosnippet>317</a> .to_biguint()
<a href=#318 id=318 data-nosnippet>318</a> .ok_or_else(|| TryFromBigIntError::new(()))
<a href=#319 id=319 data-nosnippet>319</a> }
<a href=#320 id=320 data-nosnippet>320</a>}
<a href=#321 id=321 data-nosnippet>321</a>
<a href=#322 id=322 data-nosnippet>322</a><span class="kw">impl </span>TryFrom&lt;BigInt&gt; <span class="kw">for </span>BigUint {
<a href=#323 id=323 data-nosnippet>323</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;BigInt&gt;;
<a href=#324 id=324 data-nosnippet>324</a>
<a href=#325 id=325 data-nosnippet>325</a> <span class="attr">#[inline]
<a href=#326 id=326 data-nosnippet>326</a> </span><span class="kw">fn </span>try_from(value: BigInt) -&gt; <span class="prelude-ty">Result</span>&lt;BigUint, TryFromBigIntError&lt;BigInt&gt;&gt; {
<a href=#327 id=327 data-nosnippet>327</a> <span class="kw">if </span>value.sign() == Sign::Minus {
<a href=#328 id=328 data-nosnippet>328</a> <span class="prelude-val">Err</span>(TryFromBigIntError::new(value))
<a href=#329 id=329 data-nosnippet>329</a> } <span class="kw">else </span>{
<a href=#330 id=330 data-nosnippet>330</a> <span class="prelude-val">Ok</span>(value.data)
<a href=#331 id=331 data-nosnippet>331</a> }
<a href=#332 id=332 data-nosnippet>332</a> }
<a href=#333 id=333 data-nosnippet>333</a>}
<a href=#334 id=334 data-nosnippet>334</a>
<a href=#335 id=335 data-nosnippet>335</a><span class="macro">macro_rules!</span> impl_to_bigint {
<a href=#336 id=336 data-nosnippet>336</a> (<span class="macro-nonterminal">$T</span>:ty, <span class="macro-nonterminal">$from_ty</span>:path) =&gt; {
<a href=#337 id=337 data-nosnippet>337</a> <span class="kw">impl </span>ToBigInt <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#338 id=338 data-nosnippet>338</a> <span class="attr">#[inline]
<a href=#339 id=339 data-nosnippet>339</a> </span><span class="kw">fn </span>to_bigint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#340 id=340 data-nosnippet>340</a> <span class="macro-nonterminal">$from_ty</span>(<span class="kw-2">*</span><span class="self">self</span>)
<a href=#341 id=341 data-nosnippet>341</a> }
<a href=#342 id=342 data-nosnippet>342</a> }
<a href=#343 id=343 data-nosnippet>343</a> };
<a href=#344 id=344 data-nosnippet>344</a>}
<a href=#345 id=345 data-nosnippet>345</a>
<a href=#346 id=346 data-nosnippet>346</a><span class="macro">impl_to_bigint!</span>(isize, FromPrimitive::from_isize);
<a href=#347 id=347 data-nosnippet>347</a><span class="macro">impl_to_bigint!</span>(i8, FromPrimitive::from_i8);
<a href=#348 id=348 data-nosnippet>348</a><span class="macro">impl_to_bigint!</span>(i16, FromPrimitive::from_i16);
<a href=#349 id=349 data-nosnippet>349</a><span class="macro">impl_to_bigint!</span>(i32, FromPrimitive::from_i32);
<a href=#350 id=350 data-nosnippet>350</a><span class="macro">impl_to_bigint!</span>(i64, FromPrimitive::from_i64);
<a href=#351 id=351 data-nosnippet>351</a><span class="macro">impl_to_bigint!</span>(i128, FromPrimitive::from_i128);
<a href=#352 id=352 data-nosnippet>352</a>
<a href=#353 id=353 data-nosnippet>353</a><span class="macro">impl_to_bigint!</span>(usize, FromPrimitive::from_usize);
<a href=#354 id=354 data-nosnippet>354</a><span class="macro">impl_to_bigint!</span>(u8, FromPrimitive::from_u8);
<a href=#355 id=355 data-nosnippet>355</a><span class="macro">impl_to_bigint!</span>(u16, FromPrimitive::from_u16);
<a href=#356 id=356 data-nosnippet>356</a><span class="macro">impl_to_bigint!</span>(u32, FromPrimitive::from_u32);
<a href=#357 id=357 data-nosnippet>357</a><span class="macro">impl_to_bigint!</span>(u64, FromPrimitive::from_u64);
<a href=#358 id=358 data-nosnippet>358</a><span class="macro">impl_to_bigint!</span>(u128, FromPrimitive::from_u128);
<a href=#359 id=359 data-nosnippet>359</a>
<a href=#360 id=360 data-nosnippet>360</a><span class="macro">impl_to_bigint!</span>(f32, FromPrimitive::from_f32);
<a href=#361 id=361 data-nosnippet>361</a><span class="macro">impl_to_bigint!</span>(f64, FromPrimitive::from_f64);
<a href=#362 id=362 data-nosnippet>362</a>
<a href=#363 id=363 data-nosnippet>363</a><span class="kw">impl </span>From&lt;bool&gt; <span class="kw">for </span>BigInt {
<a href=#364 id=364 data-nosnippet>364</a> <span class="kw">fn </span>from(x: bool) -&gt; <span class="self">Self </span>{
<a href=#365 id=365 data-nosnippet>365</a> <span class="kw">if </span>x {
<a href=#366 id=366 data-nosnippet>366</a> One::one()
<a href=#367 id=367 data-nosnippet>367</a> } <span class="kw">else </span>{
<a href=#368 id=368 data-nosnippet>368</a> <span class="self">Self</span>::ZERO
<a href=#369 id=369 data-nosnippet>369</a> }
<a href=#370 id=370 data-nosnippet>370</a> }
<a href=#371 id=371 data-nosnippet>371</a>}
<a href=#372 id=372 data-nosnippet>372</a>
<a href=#373 id=373 data-nosnippet>373</a><span class="attr">#[inline]
<a href=#374 id=374 data-nosnippet>374</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>from_signed_bytes_be(digits: <span class="kw-2">&amp;</span>[u8]) -&gt; BigInt {
<a href=#375 id=375 data-nosnippet>375</a> <span class="kw">let </span>sign = <span class="kw">match </span>digits.first() {
<a href=#376 id=376 data-nosnippet>376</a> <span class="prelude-val">Some</span>(v) <span class="kw">if </span><span class="kw-2">*</span>v &gt; <span class="number">0x7f </span>=&gt; Sign::Minus,
<a href=#377 id=377 data-nosnippet>377</a> <span class="prelude-val">Some</span>(<span class="kw">_</span>) =&gt; Sign::Plus,
<a href=#378 id=378 data-nosnippet>378</a> <span class="prelude-val">None </span>=&gt; <span class="kw">return </span>BigInt::ZERO,
<a href=#379 id=379 data-nosnippet>379</a> };
<a href=#380 id=380 data-nosnippet>380</a>
<a href=#381 id=381 data-nosnippet>381</a> <span class="kw">if </span>sign == Sign::Minus {
<a href=#382 id=382 data-nosnippet>382</a> <span class="comment">// two's-complement the content to retrieve the magnitude
<a href=#383 id=383 data-nosnippet>383</a> </span><span class="kw">let </span><span class="kw-2">mut </span>digits = Vec::from(digits);
<a href=#384 id=384 data-nosnippet>384</a> twos_complement_be(<span class="kw-2">&amp;mut </span>digits);
<a href=#385 id=385 data-nosnippet>385</a> BigInt::from_biguint(sign, BigUint::from_bytes_be(<span class="kw-2">&amp;</span>digits))
<a href=#386 id=386 data-nosnippet>386</a> } <span class="kw">else </span>{
<a href=#387 id=387 data-nosnippet>387</a> BigInt::from_biguint(sign, BigUint::from_bytes_be(digits))
<a href=#388 id=388 data-nosnippet>388</a> }
<a href=#389 id=389 data-nosnippet>389</a>}
<a href=#390 id=390 data-nosnippet>390</a>
<a href=#391 id=391 data-nosnippet>391</a><span class="attr">#[inline]
<a href=#392 id=392 data-nosnippet>392</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>from_signed_bytes_le(digits: <span class="kw-2">&amp;</span>[u8]) -&gt; BigInt {
<a href=#393 id=393 data-nosnippet>393</a> <span class="kw">let </span>sign = <span class="kw">match </span>digits.last() {
<a href=#394 id=394 data-nosnippet>394</a> <span class="prelude-val">Some</span>(v) <span class="kw">if </span><span class="kw-2">*</span>v &gt; <span class="number">0x7f </span>=&gt; Sign::Minus,
<a href=#395 id=395 data-nosnippet>395</a> <span class="prelude-val">Some</span>(<span class="kw">_</span>) =&gt; Sign::Plus,
<a href=#396 id=396 data-nosnippet>396</a> <span class="prelude-val">None </span>=&gt; <span class="kw">return </span>BigInt::ZERO,
<a href=#397 id=397 data-nosnippet>397</a> };
<a href=#398 id=398 data-nosnippet>398</a>
<a href=#399 id=399 data-nosnippet>399</a> <span class="kw">if </span>sign == Sign::Minus {
<a href=#400 id=400 data-nosnippet>400</a> <span class="comment">// two's-complement the content to retrieve the magnitude
<a href=#401 id=401 data-nosnippet>401</a> </span><span class="kw">let </span><span class="kw-2">mut </span>digits = Vec::from(digits);
<a href=#402 id=402 data-nosnippet>402</a> twos_complement_le(<span class="kw-2">&amp;mut </span>digits);
<a href=#403 id=403 data-nosnippet>403</a> BigInt::from_biguint(sign, BigUint::from_bytes_le(<span class="kw-2">&amp;</span>digits))
<a href=#404 id=404 data-nosnippet>404</a> } <span class="kw">else </span>{
<a href=#405 id=405 data-nosnippet>405</a> BigInt::from_biguint(sign, BigUint::from_bytes_le(digits))
<a href=#406 id=406 data-nosnippet>406</a> }
<a href=#407 id=407 data-nosnippet>407</a>}
<a href=#408 id=408 data-nosnippet>408</a>
<a href=#409 id=409 data-nosnippet>409</a><span class="attr">#[inline]
<a href=#410 id=410 data-nosnippet>410</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>to_signed_bytes_be(x: <span class="kw-2">&amp;</span>BigInt) -&gt; Vec&lt;u8&gt; {
<a href=#411 id=411 data-nosnippet>411</a> <span class="kw">let </span><span class="kw-2">mut </span>bytes = x.data.to_bytes_be();
<a href=#412 id=412 data-nosnippet>412</a> <span class="kw">let </span>first_byte = bytes.first().cloned().unwrap_or(<span class="number">0</span>);
<a href=#413 id=413 data-nosnippet>413</a> <span class="kw">if </span>first_byte &gt; <span class="number">0x7f
<a href=#414 id=414 data-nosnippet>414</a> </span>&amp;&amp; !(first_byte == <span class="number">0x80 </span>&amp;&amp; bytes.iter().skip(<span class="number">1</span>).all(Zero::is_zero) &amp;&amp; x.sign == Sign::Minus)
<a href=#415 id=415 data-nosnippet>415</a> {
<a href=#416 id=416 data-nosnippet>416</a> <span class="comment">// msb used by magnitude, extend by 1 byte
<a href=#417 id=417 data-nosnippet>417</a> </span>bytes.insert(<span class="number">0</span>, <span class="number">0</span>);
<a href=#418 id=418 data-nosnippet>418</a> }
<a href=#419 id=419 data-nosnippet>419</a> <span class="kw">if </span>x.sign == Sign::Minus {
<a href=#420 id=420 data-nosnippet>420</a> twos_complement_be(<span class="kw-2">&amp;mut </span>bytes);
<a href=#421 id=421 data-nosnippet>421</a> }
<a href=#422 id=422 data-nosnippet>422</a> bytes
<a href=#423 id=423 data-nosnippet>423</a>}
<a href=#424 id=424 data-nosnippet>424</a>
<a href=#425 id=425 data-nosnippet>425</a><span class="attr">#[inline]
<a href=#426 id=426 data-nosnippet>426</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>to_signed_bytes_le(x: <span class="kw-2">&amp;</span>BigInt) -&gt; Vec&lt;u8&gt; {
<a href=#427 id=427 data-nosnippet>427</a> <span class="kw">let </span><span class="kw-2">mut </span>bytes = x.data.to_bytes_le();
<a href=#428 id=428 data-nosnippet>428</a> <span class="kw">let </span>last_byte = bytes.last().cloned().unwrap_or(<span class="number">0</span>);
<a href=#429 id=429 data-nosnippet>429</a> <span class="kw">if </span>last_byte &gt; <span class="number">0x7f
<a href=#430 id=430 data-nosnippet>430</a> </span>&amp;&amp; !(last_byte == <span class="number">0x80
<a href=#431 id=431 data-nosnippet>431</a> </span>&amp;&amp; bytes.iter().rev().skip(<span class="number">1</span>).all(Zero::is_zero)
<a href=#432 id=432 data-nosnippet>432</a> &amp;&amp; x.sign == Sign::Minus)
<a href=#433 id=433 data-nosnippet>433</a> {
<a href=#434 id=434 data-nosnippet>434</a> <span class="comment">// msb used by magnitude, extend by 1 byte
<a href=#435 id=435 data-nosnippet>435</a> </span>bytes.push(<span class="number">0</span>);
<a href=#436 id=436 data-nosnippet>436</a> }
<a href=#437 id=437 data-nosnippet>437</a> <span class="kw">if </span>x.sign == Sign::Minus {
<a href=#438 id=438 data-nosnippet>438</a> twos_complement_le(<span class="kw-2">&amp;mut </span>bytes);
<a href=#439 id=439 data-nosnippet>439</a> }
<a href=#440 id=440 data-nosnippet>440</a> bytes
<a href=#441 id=441 data-nosnippet>441</a>}
<a href=#442 id=442 data-nosnippet>442</a>
<a href=#443 id=443 data-nosnippet>443</a><span class="doccomment">/// Perform in-place two's complement of the given binary representation,
<a href=#444 id=444 data-nosnippet>444</a>/// in little-endian byte order.
<a href=#445 id=445 data-nosnippet>445</a></span><span class="attr">#[inline]
<a href=#446 id=446 data-nosnippet>446</a></span><span class="kw">fn </span>twos_complement_le(digits: <span class="kw-2">&amp;mut </span>[u8]) {
<a href=#447 id=447 data-nosnippet>447</a> twos_complement(digits)
<a href=#448 id=448 data-nosnippet>448</a>}
<a href=#449 id=449 data-nosnippet>449</a>
<a href=#450 id=450 data-nosnippet>450</a><span class="doccomment">/// Perform in-place two's complement of the given binary representation
<a href=#451 id=451 data-nosnippet>451</a>/// in big-endian byte order.
<a href=#452 id=452 data-nosnippet>452</a></span><span class="attr">#[inline]
<a href=#453 id=453 data-nosnippet>453</a></span><span class="kw">fn </span>twos_complement_be(digits: <span class="kw-2">&amp;mut </span>[u8]) {
<a href=#454 id=454 data-nosnippet>454</a> twos_complement(digits.iter_mut().rev())
<a href=#455 id=455 data-nosnippet>455</a>}
<a href=#456 id=456 data-nosnippet>456</a>
<a href=#457 id=457 data-nosnippet>457</a><span class="doccomment">/// Perform in-place two's complement of the given digit iterator
<a href=#458 id=458 data-nosnippet>458</a>/// starting from the least significant byte.
<a href=#459 id=459 data-nosnippet>459</a></span><span class="attr">#[inline]
<a href=#460 id=460 data-nosnippet>460</a></span><span class="kw">fn </span>twos_complement&lt;<span class="lifetime">'a</span>, I&gt;(digits: I)
<a href=#461 id=461 data-nosnippet>461</a><span class="kw">where
<a href=#462 id=462 data-nosnippet>462</a> </span>I: IntoIterator&lt;Item = <span class="kw-2">&amp;</span><span class="lifetime">'a </span><span class="kw-2">mut </span>u8&gt;,
<a href=#463 id=463 data-nosnippet>463</a>{
<a href=#464 id=464 data-nosnippet>464</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="bool-val">true</span>;
<a href=#465 id=465 data-nosnippet>465</a> <span class="kw">for </span>d <span class="kw">in </span>digits {
<a href=#466 id=466 data-nosnippet>466</a> <span class="kw-2">*</span>d = !<span class="kw-2">*</span>d;
<a href=#467 id=467 data-nosnippet>467</a> <span class="kw">if </span>carry {
<a href=#468 id=468 data-nosnippet>468</a> <span class="kw-2">*</span>d = d.wrapping_add(<span class="number">1</span>);
<a href=#469 id=469 data-nosnippet>469</a> carry = d.is_zero();
<a href=#470 id=470 data-nosnippet>470</a> }
<a href=#471 id=471 data-nosnippet>471</a> }
<a href=#472 id=472 data-nosnippet>472</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,514 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/division.rs`."><title>division.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>division.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::CheckedUnsignedAbs::{Negative, Positive};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::NoSign;
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use super</span>::{BigInt, UnsignedAbs};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use crate</span>::{IsizePromotion, UsizePromotion};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::ops::{Div, DivAssign, Rem, RemAssign};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>num_integer::Integer;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>num_traits::{CheckedDiv, CheckedEuclid, Euclid, Signed, ToPrimitive, Zero};
<a href=#10 id=10 data-nosnippet>10</a>
<a href=#11 id=11 data-nosnippet>11</a><span class="macro">forward_all_binop_to_ref_ref!</span>(<span class="kw">impl </span>Div <span class="kw">for </span>BigInt, div);
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="kw">impl </span>Div&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#14 id=14 data-nosnippet>14</a> <span class="kw">type </span>Output = BigInt;
<a href=#15 id=15 data-nosnippet>15</a>
<a href=#16 id=16 data-nosnippet>16</a> <span class="attr">#[inline]
<a href=#17 id=17 data-nosnippet>17</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#18 id=18 data-nosnippet>18</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = <span class="self">self</span>.div_rem(other);
<a href=#19 id=19 data-nosnippet>19</a> q
<a href=#20 id=20 data-nosnippet>20</a> }
<a href=#21 id=21 data-nosnippet>21</a>}
<a href=#22 id=22 data-nosnippet>22</a>
<a href=#23 id=23 data-nosnippet>23</a><span class="kw">impl </span>DivAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#24 id=24 data-nosnippet>24</a> <span class="attr">#[inline]
<a href=#25 id=25 data-nosnippet>25</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#26 id=26 data-nosnippet>26</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>/ other;
<a href=#27 id=27 data-nosnippet>27</a> }
<a href=#28 id=28 data-nosnippet>28</a>}
<a href=#29 id=29 data-nosnippet>29</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>DivAssign <span class="kw">for </span>BigInt, div_assign);
<a href=#30 id=30 data-nosnippet>30</a>
<a href=#31 id=31 data-nosnippet>31</a><span class="macro">promote_all_scalars!</span>(<span class="kw">impl </span>Div <span class="kw">for </span>BigInt, div);
<a href=#32 id=32 data-nosnippet>32</a><span class="macro">promote_all_scalars_assign!</span>(<span class="kw">impl </span>DivAssign <span class="kw">for </span>BigInt, div_assign);
<a href=#33 id=33 data-nosnippet>33</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u32&gt; <span class="kw">for </span>BigInt, div);
<a href=#34 id=34 data-nosnippet>34</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u64&gt; <span class="kw">for </span>BigInt, div);
<a href=#35 id=35 data-nosnippet>35</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u128&gt; <span class="kw">for </span>BigInt, div);
<a href=#36 id=36 data-nosnippet>36</a>
<a href=#37 id=37 data-nosnippet>37</a><span class="kw">impl </span>Div&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">type </span>Output = BigInt;
<a href=#39 id=39 data-nosnippet>39</a>
<a href=#40 id=40 data-nosnippet>40</a> <span class="attr">#[inline]
<a href=#41 id=41 data-nosnippet>41</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u32) -&gt; BigInt {
<a href=#42 id=42 data-nosnippet>42</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data / other)
<a href=#43 id=43 data-nosnippet>43</a> }
<a href=#44 id=44 data-nosnippet>44</a>}
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a><span class="kw">impl </span>DivAssign&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#47 id=47 data-nosnippet>47</a> <span class="attr">#[inline]
<a href=#48 id=48 data-nosnippet>48</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#49 id=49 data-nosnippet>49</a> <span class="self">self</span>.data /= other;
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#51 id=51 data-nosnippet>51</a> <span class="self">self</span>.sign = NoSign;
<a href=#52 id=52 data-nosnippet>52</a> }
<a href=#53 id=53 data-nosnippet>53</a> }
<a href=#54 id=54 data-nosnippet>54</a>}
<a href=#55 id=55 data-nosnippet>55</a>
<a href=#56 id=56 data-nosnippet>56</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>u32 {
<a href=#57 id=57 data-nosnippet>57</a> <span class="kw">type </span>Output = BigInt;
<a href=#58 id=58 data-nosnippet>58</a>
<a href=#59 id=59 data-nosnippet>59</a> <span class="attr">#[inline]
<a href=#60 id=60 data-nosnippet>60</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#61 id=61 data-nosnippet>61</a> BigInt::from_biguint(other.sign, <span class="self">self </span>/ other.data)
<a href=#62 id=62 data-nosnippet>62</a> }
<a href=#63 id=63 data-nosnippet>63</a>}
<a href=#64 id=64 data-nosnippet>64</a>
<a href=#65 id=65 data-nosnippet>65</a><span class="kw">impl </span>Div&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#66 id=66 data-nosnippet>66</a> <span class="kw">type </span>Output = BigInt;
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a> <span class="attr">#[inline]
<a href=#69 id=69 data-nosnippet>69</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u64) -&gt; BigInt {
<a href=#70 id=70 data-nosnippet>70</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data / other)
<a href=#71 id=71 data-nosnippet>71</a> }
<a href=#72 id=72 data-nosnippet>72</a>}
<a href=#73 id=73 data-nosnippet>73</a>
<a href=#74 id=74 data-nosnippet>74</a><span class="kw">impl </span>DivAssign&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#75 id=75 data-nosnippet>75</a> <span class="attr">#[inline]
<a href=#76 id=76 data-nosnippet>76</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#77 id=77 data-nosnippet>77</a> <span class="self">self</span>.data /= other;
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#79 id=79 data-nosnippet>79</a> <span class="self">self</span>.sign = NoSign;
<a href=#80 id=80 data-nosnippet>80</a> }
<a href=#81 id=81 data-nosnippet>81</a> }
<a href=#82 id=82 data-nosnippet>82</a>}
<a href=#83 id=83 data-nosnippet>83</a>
<a href=#84 id=84 data-nosnippet>84</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>u64 {
<a href=#85 id=85 data-nosnippet>85</a> <span class="kw">type </span>Output = BigInt;
<a href=#86 id=86 data-nosnippet>86</a>
<a href=#87 id=87 data-nosnippet>87</a> <span class="attr">#[inline]
<a href=#88 id=88 data-nosnippet>88</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#89 id=89 data-nosnippet>89</a> BigInt::from_biguint(other.sign, <span class="self">self </span>/ other.data)
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a>}
<a href=#92 id=92 data-nosnippet>92</a>
<a href=#93 id=93 data-nosnippet>93</a><span class="kw">impl </span>Div&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">type </span>Output = BigInt;
<a href=#95 id=95 data-nosnippet>95</a>
<a href=#96 id=96 data-nosnippet>96</a> <span class="attr">#[inline]
<a href=#97 id=97 data-nosnippet>97</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u128) -&gt; BigInt {
<a href=#98 id=98 data-nosnippet>98</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data / other)
<a href=#99 id=99 data-nosnippet>99</a> }
<a href=#100 id=100 data-nosnippet>100</a>}
<a href=#101 id=101 data-nosnippet>101</a>
<a href=#102 id=102 data-nosnippet>102</a><span class="kw">impl </span>DivAssign&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#103 id=103 data-nosnippet>103</a> <span class="attr">#[inline]
<a href=#104 id=104 data-nosnippet>104</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#105 id=105 data-nosnippet>105</a> <span class="self">self</span>.data /= other;
<a href=#106 id=106 data-nosnippet>106</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#107 id=107 data-nosnippet>107</a> <span class="self">self</span>.sign = NoSign;
<a href=#108 id=108 data-nosnippet>108</a> }
<a href=#109 id=109 data-nosnippet>109</a> }
<a href=#110 id=110 data-nosnippet>110</a>}
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>u128 {
<a href=#113 id=113 data-nosnippet>113</a> <span class="kw">type </span>Output = BigInt;
<a href=#114 id=114 data-nosnippet>114</a>
<a href=#115 id=115 data-nosnippet>115</a> <span class="attr">#[inline]
<a href=#116 id=116 data-nosnippet>116</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#117 id=117 data-nosnippet>117</a> BigInt::from_biguint(other.sign, <span class="self">self </span>/ other.data)
<a href=#118 id=118 data-nosnippet>118</a> }
<a href=#119 id=119 data-nosnippet>119</a>}
<a href=#120 id=120 data-nosnippet>120</a>
<a href=#121 id=121 data-nosnippet>121</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;i32&gt; <span class="kw">for </span>BigInt, div);
<a href=#122 id=122 data-nosnippet>122</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;i64&gt; <span class="kw">for </span>BigInt, div);
<a href=#123 id=123 data-nosnippet>123</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;i128&gt; <span class="kw">for </span>BigInt, div);
<a href=#124 id=124 data-nosnippet>124</a>
<a href=#125 id=125 data-nosnippet>125</a><span class="kw">impl </span>Div&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#126 id=126 data-nosnippet>126</a> <span class="kw">type </span>Output = BigInt;
<a href=#127 id=127 data-nosnippet>127</a>
<a href=#128 id=128 data-nosnippet>128</a> <span class="attr">#[inline]
<a href=#129 id=129 data-nosnippet>129</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: i32) -&gt; BigInt {
<a href=#130 id=130 data-nosnippet>130</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#131 id=131 data-nosnippet>131</a> Positive(u) =&gt; <span class="self">self </span>/ u,
<a href=#132 id=132 data-nosnippet>132</a> Negative(u) =&gt; -<span class="self">self </span>/ u,
<a href=#133 id=133 data-nosnippet>133</a> }
<a href=#134 id=134 data-nosnippet>134</a> }
<a href=#135 id=135 data-nosnippet>135</a>}
<a href=#136 id=136 data-nosnippet>136</a>
<a href=#137 id=137 data-nosnippet>137</a><span class="kw">impl </span>DivAssign&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#138 id=138 data-nosnippet>138</a> <span class="attr">#[inline]
<a href=#139 id=139 data-nosnippet>139</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i32) {
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#141 id=141 data-nosnippet>141</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>/= u,
<a href=#142 id=142 data-nosnippet>142</a> Negative(u) =&gt; {
<a href=#143 id=143 data-nosnippet>143</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#144 id=144 data-nosnippet>144</a> <span class="kw-2">*</span><span class="self">self </span>/= u;
<a href=#145 id=145 data-nosnippet>145</a> }
<a href=#146 id=146 data-nosnippet>146</a> }
<a href=#147 id=147 data-nosnippet>147</a> }
<a href=#148 id=148 data-nosnippet>148</a>}
<a href=#149 id=149 data-nosnippet>149</a>
<a href=#150 id=150 data-nosnippet>150</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>i32 {
<a href=#151 id=151 data-nosnippet>151</a> <span class="kw">type </span>Output = BigInt;
<a href=#152 id=152 data-nosnippet>152</a>
<a href=#153 id=153 data-nosnippet>153</a> <span class="attr">#[inline]
<a href=#154 id=154 data-nosnippet>154</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#155 id=155 data-nosnippet>155</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#156 id=156 data-nosnippet>156</a> Positive(u) =&gt; u / other,
<a href=#157 id=157 data-nosnippet>157</a> Negative(u) =&gt; u / -other,
<a href=#158 id=158 data-nosnippet>158</a> }
<a href=#159 id=159 data-nosnippet>159</a> }
<a href=#160 id=160 data-nosnippet>160</a>}
<a href=#161 id=161 data-nosnippet>161</a>
<a href=#162 id=162 data-nosnippet>162</a><span class="kw">impl </span>Div&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#163 id=163 data-nosnippet>163</a> <span class="kw">type </span>Output = BigInt;
<a href=#164 id=164 data-nosnippet>164</a>
<a href=#165 id=165 data-nosnippet>165</a> <span class="attr">#[inline]
<a href=#166 id=166 data-nosnippet>166</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: i64) -&gt; BigInt {
<a href=#167 id=167 data-nosnippet>167</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#168 id=168 data-nosnippet>168</a> Positive(u) =&gt; <span class="self">self </span>/ u,
<a href=#169 id=169 data-nosnippet>169</a> Negative(u) =&gt; -<span class="self">self </span>/ u,
<a href=#170 id=170 data-nosnippet>170</a> }
<a href=#171 id=171 data-nosnippet>171</a> }
<a href=#172 id=172 data-nosnippet>172</a>}
<a href=#173 id=173 data-nosnippet>173</a>
<a href=#174 id=174 data-nosnippet>174</a><span class="kw">impl </span>DivAssign&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#175 id=175 data-nosnippet>175</a> <span class="attr">#[inline]
<a href=#176 id=176 data-nosnippet>176</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i64) {
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#178 id=178 data-nosnippet>178</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>/= u,
<a href=#179 id=179 data-nosnippet>179</a> Negative(u) =&gt; {
<a href=#180 id=180 data-nosnippet>180</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#181 id=181 data-nosnippet>181</a> <span class="kw-2">*</span><span class="self">self </span>/= u;
<a href=#182 id=182 data-nosnippet>182</a> }
<a href=#183 id=183 data-nosnippet>183</a> }
<a href=#184 id=184 data-nosnippet>184</a> }
<a href=#185 id=185 data-nosnippet>185</a>}
<a href=#186 id=186 data-nosnippet>186</a>
<a href=#187 id=187 data-nosnippet>187</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>i64 {
<a href=#188 id=188 data-nosnippet>188</a> <span class="kw">type </span>Output = BigInt;
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a> <span class="attr">#[inline]
<a href=#191 id=191 data-nosnippet>191</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#193 id=193 data-nosnippet>193</a> Positive(u) =&gt; u / other,
<a href=#194 id=194 data-nosnippet>194</a> Negative(u) =&gt; u / -other,
<a href=#195 id=195 data-nosnippet>195</a> }
<a href=#196 id=196 data-nosnippet>196</a> }
<a href=#197 id=197 data-nosnippet>197</a>}
<a href=#198 id=198 data-nosnippet>198</a>
<a href=#199 id=199 data-nosnippet>199</a><span class="kw">impl </span>Div&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">type </span>Output = BigInt;
<a href=#201 id=201 data-nosnippet>201</a>
<a href=#202 id=202 data-nosnippet>202</a> <span class="attr">#[inline]
<a href=#203 id=203 data-nosnippet>203</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: i128) -&gt; BigInt {
<a href=#204 id=204 data-nosnippet>204</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#205 id=205 data-nosnippet>205</a> Positive(u) =&gt; <span class="self">self </span>/ u,
<a href=#206 id=206 data-nosnippet>206</a> Negative(u) =&gt; -<span class="self">self </span>/ u,
<a href=#207 id=207 data-nosnippet>207</a> }
<a href=#208 id=208 data-nosnippet>208</a> }
<a href=#209 id=209 data-nosnippet>209</a>}
<a href=#210 id=210 data-nosnippet>210</a>
<a href=#211 id=211 data-nosnippet>211</a><span class="kw">impl </span>DivAssign&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#212 id=212 data-nosnippet>212</a> <span class="attr">#[inline]
<a href=#213 id=213 data-nosnippet>213</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i128) {
<a href=#214 id=214 data-nosnippet>214</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#215 id=215 data-nosnippet>215</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>/= u,
<a href=#216 id=216 data-nosnippet>216</a> Negative(u) =&gt; {
<a href=#217 id=217 data-nosnippet>217</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#218 id=218 data-nosnippet>218</a> <span class="kw-2">*</span><span class="self">self </span>/= u;
<a href=#219 id=219 data-nosnippet>219</a> }
<a href=#220 id=220 data-nosnippet>220</a> }
<a href=#221 id=221 data-nosnippet>221</a> }
<a href=#222 id=222 data-nosnippet>222</a>}
<a href=#223 id=223 data-nosnippet>223</a>
<a href=#224 id=224 data-nosnippet>224</a><span class="kw">impl </span>Div&lt;BigInt&gt; <span class="kw">for </span>i128 {
<a href=#225 id=225 data-nosnippet>225</a> <span class="kw">type </span>Output = BigInt;
<a href=#226 id=226 data-nosnippet>226</a>
<a href=#227 id=227 data-nosnippet>227</a> <span class="attr">#[inline]
<a href=#228 id=228 data-nosnippet>228</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#229 id=229 data-nosnippet>229</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#230 id=230 data-nosnippet>230</a> Positive(u) =&gt; u / other,
<a href=#231 id=231 data-nosnippet>231</a> Negative(u) =&gt; u / -other,
<a href=#232 id=232 data-nosnippet>232</a> }
<a href=#233 id=233 data-nosnippet>233</a> }
<a href=#234 id=234 data-nosnippet>234</a>}
<a href=#235 id=235 data-nosnippet>235</a>
<a href=#236 id=236 data-nosnippet>236</a><span class="macro">forward_all_binop_to_ref_ref!</span>(<span class="kw">impl </span>Rem <span class="kw">for </span>BigInt, rem);
<a href=#237 id=237 data-nosnippet>237</a>
<a href=#238 id=238 data-nosnippet>238</a><span class="kw">impl </span>Rem&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#239 id=239 data-nosnippet>239</a> <span class="kw">type </span>Output = BigInt;
<a href=#240 id=240 data-nosnippet>240</a>
<a href=#241 id=241 data-nosnippet>241</a> <span class="attr">#[inline]
<a href=#242 id=242 data-nosnippet>242</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#243 id=243 data-nosnippet>243</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = other.to_u32() {
<a href=#244 id=244 data-nosnippet>244</a> <span class="self">self </span>% other
<a href=#245 id=245 data-nosnippet>245</a> } <span class="kw">else if let </span><span class="prelude-val">Some</span>(other) = other.to_i32() {
<a href=#246 id=246 data-nosnippet>246</a> <span class="self">self </span>% other
<a href=#247 id=247 data-nosnippet>247</a> } <span class="kw">else </span>{
<a href=#248 id=248 data-nosnippet>248</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = <span class="self">self</span>.div_rem(other);
<a href=#249 id=249 data-nosnippet>249</a> r
<a href=#250 id=250 data-nosnippet>250</a> }
<a href=#251 id=251 data-nosnippet>251</a> }
<a href=#252 id=252 data-nosnippet>252</a>}
<a href=#253 id=253 data-nosnippet>253</a>
<a href=#254 id=254 data-nosnippet>254</a><span class="kw">impl </span>RemAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#255 id=255 data-nosnippet>255</a> <span class="attr">#[inline]
<a href=#256 id=256 data-nosnippet>256</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#257 id=257 data-nosnippet>257</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>% other;
<a href=#258 id=258 data-nosnippet>258</a> }
<a href=#259 id=259 data-nosnippet>259</a>}
<a href=#260 id=260 data-nosnippet>260</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>RemAssign <span class="kw">for </span>BigInt, rem_assign);
<a href=#261 id=261 data-nosnippet>261</a>
<a href=#262 id=262 data-nosnippet>262</a><span class="macro">promote_all_scalars!</span>(<span class="kw">impl </span>Rem <span class="kw">for </span>BigInt, rem);
<a href=#263 id=263 data-nosnippet>263</a><span class="macro">promote_all_scalars_assign!</span>(<span class="kw">impl </span>RemAssign <span class="kw">for </span>BigInt, rem_assign);
<a href=#264 id=264 data-nosnippet>264</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;u32&gt; <span class="kw">for </span>BigInt, rem);
<a href=#265 id=265 data-nosnippet>265</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;u64&gt; <span class="kw">for </span>BigInt, rem);
<a href=#266 id=266 data-nosnippet>266</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;u128&gt; <span class="kw">for </span>BigInt, rem);
<a href=#267 id=267 data-nosnippet>267</a>
<a href=#268 id=268 data-nosnippet>268</a><span class="kw">impl </span>Rem&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#269 id=269 data-nosnippet>269</a> <span class="kw">type </span>Output = BigInt;
<a href=#270 id=270 data-nosnippet>270</a>
<a href=#271 id=271 data-nosnippet>271</a> <span class="attr">#[inline]
<a href=#272 id=272 data-nosnippet>272</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u32) -&gt; BigInt {
<a href=#273 id=273 data-nosnippet>273</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data % other)
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a>}
<a href=#276 id=276 data-nosnippet>276</a>
<a href=#277 id=277 data-nosnippet>277</a><span class="kw">impl </span>RemAssign&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#278 id=278 data-nosnippet>278</a> <span class="attr">#[inline]
<a href=#279 id=279 data-nosnippet>279</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#280 id=280 data-nosnippet>280</a> <span class="self">self</span>.data %= other;
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#282 id=282 data-nosnippet>282</a> <span class="self">self</span>.sign = NoSign;
<a href=#283 id=283 data-nosnippet>283</a> }
<a href=#284 id=284 data-nosnippet>284</a> }
<a href=#285 id=285 data-nosnippet>285</a>}
<a href=#286 id=286 data-nosnippet>286</a>
<a href=#287 id=287 data-nosnippet>287</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>u32 {
<a href=#288 id=288 data-nosnippet>288</a> <span class="kw">type </span>Output = BigInt;
<a href=#289 id=289 data-nosnippet>289</a>
<a href=#290 id=290 data-nosnippet>290</a> <span class="attr">#[inline]
<a href=#291 id=291 data-nosnippet>291</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#292 id=292 data-nosnippet>292</a> BigInt::from(<span class="self">self </span>% other.data)
<a href=#293 id=293 data-nosnippet>293</a> }
<a href=#294 id=294 data-nosnippet>294</a>}
<a href=#295 id=295 data-nosnippet>295</a>
<a href=#296 id=296 data-nosnippet>296</a><span class="kw">impl </span>Rem&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#297 id=297 data-nosnippet>297</a> <span class="kw">type </span>Output = BigInt;
<a href=#298 id=298 data-nosnippet>298</a>
<a href=#299 id=299 data-nosnippet>299</a> <span class="attr">#[inline]
<a href=#300 id=300 data-nosnippet>300</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u64) -&gt; BigInt {
<a href=#301 id=301 data-nosnippet>301</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data % other)
<a href=#302 id=302 data-nosnippet>302</a> }
<a href=#303 id=303 data-nosnippet>303</a>}
<a href=#304 id=304 data-nosnippet>304</a>
<a href=#305 id=305 data-nosnippet>305</a><span class="kw">impl </span>RemAssign&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#306 id=306 data-nosnippet>306</a> <span class="attr">#[inline]
<a href=#307 id=307 data-nosnippet>307</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#308 id=308 data-nosnippet>308</a> <span class="self">self</span>.data %= other;
<a href=#309 id=309 data-nosnippet>309</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#310 id=310 data-nosnippet>310</a> <span class="self">self</span>.sign = NoSign;
<a href=#311 id=311 data-nosnippet>311</a> }
<a href=#312 id=312 data-nosnippet>312</a> }
<a href=#313 id=313 data-nosnippet>313</a>}
<a href=#314 id=314 data-nosnippet>314</a>
<a href=#315 id=315 data-nosnippet>315</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>u64 {
<a href=#316 id=316 data-nosnippet>316</a> <span class="kw">type </span>Output = BigInt;
<a href=#317 id=317 data-nosnippet>317</a>
<a href=#318 id=318 data-nosnippet>318</a> <span class="attr">#[inline]
<a href=#319 id=319 data-nosnippet>319</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#320 id=320 data-nosnippet>320</a> BigInt::from(<span class="self">self </span>% other.data)
<a href=#321 id=321 data-nosnippet>321</a> }
<a href=#322 id=322 data-nosnippet>322</a>}
<a href=#323 id=323 data-nosnippet>323</a>
<a href=#324 id=324 data-nosnippet>324</a><span class="kw">impl </span>Rem&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#325 id=325 data-nosnippet>325</a> <span class="kw">type </span>Output = BigInt;
<a href=#326 id=326 data-nosnippet>326</a>
<a href=#327 id=327 data-nosnippet>327</a> <span class="attr">#[inline]
<a href=#328 id=328 data-nosnippet>328</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u128) -&gt; BigInt {
<a href=#329 id=329 data-nosnippet>329</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data % other)
<a href=#330 id=330 data-nosnippet>330</a> }
<a href=#331 id=331 data-nosnippet>331</a>}
<a href=#332 id=332 data-nosnippet>332</a>
<a href=#333 id=333 data-nosnippet>333</a><span class="kw">impl </span>RemAssign&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#334 id=334 data-nosnippet>334</a> <span class="attr">#[inline]
<a href=#335 id=335 data-nosnippet>335</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#336 id=336 data-nosnippet>336</a> <span class="self">self</span>.data %= other;
<a href=#337 id=337 data-nosnippet>337</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#338 id=338 data-nosnippet>338</a> <span class="self">self</span>.sign = NoSign;
<a href=#339 id=339 data-nosnippet>339</a> }
<a href=#340 id=340 data-nosnippet>340</a> }
<a href=#341 id=341 data-nosnippet>341</a>}
<a href=#342 id=342 data-nosnippet>342</a>
<a href=#343 id=343 data-nosnippet>343</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>u128 {
<a href=#344 id=344 data-nosnippet>344</a> <span class="kw">type </span>Output = BigInt;
<a href=#345 id=345 data-nosnippet>345</a>
<a href=#346 id=346 data-nosnippet>346</a> <span class="attr">#[inline]
<a href=#347 id=347 data-nosnippet>347</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#348 id=348 data-nosnippet>348</a> BigInt::from(<span class="self">self </span>% other.data)
<a href=#349 id=349 data-nosnippet>349</a> }
<a href=#350 id=350 data-nosnippet>350</a>}
<a href=#351 id=351 data-nosnippet>351</a>
<a href=#352 id=352 data-nosnippet>352</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;i32&gt; <span class="kw">for </span>BigInt, rem);
<a href=#353 id=353 data-nosnippet>353</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;i64&gt; <span class="kw">for </span>BigInt, rem);
<a href=#354 id=354 data-nosnippet>354</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;i128&gt; <span class="kw">for </span>BigInt, rem);
<a href=#355 id=355 data-nosnippet>355</a>
<a href=#356 id=356 data-nosnippet>356</a><span class="kw">impl </span>Rem&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#357 id=357 data-nosnippet>357</a> <span class="kw">type </span>Output = BigInt;
<a href=#358 id=358 data-nosnippet>358</a>
<a href=#359 id=359 data-nosnippet>359</a> <span class="attr">#[inline]
<a href=#360 id=360 data-nosnippet>360</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: i32) -&gt; BigInt {
<a href=#361 id=361 data-nosnippet>361</a> <span class="self">self </span>% other.unsigned_abs()
<a href=#362 id=362 data-nosnippet>362</a> }
<a href=#363 id=363 data-nosnippet>363</a>}
<a href=#364 id=364 data-nosnippet>364</a>
<a href=#365 id=365 data-nosnippet>365</a><span class="kw">impl </span>RemAssign&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#366 id=366 data-nosnippet>366</a> <span class="attr">#[inline]
<a href=#367 id=367 data-nosnippet>367</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i32) {
<a href=#368 id=368 data-nosnippet>368</a> <span class="kw-2">*</span><span class="self">self </span>%= other.unsigned_abs();
<a href=#369 id=369 data-nosnippet>369</a> }
<a href=#370 id=370 data-nosnippet>370</a>}
<a href=#371 id=371 data-nosnippet>371</a>
<a href=#372 id=372 data-nosnippet>372</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>i32 {
<a href=#373 id=373 data-nosnippet>373</a> <span class="kw">type </span>Output = BigInt;
<a href=#374 id=374 data-nosnippet>374</a>
<a href=#375 id=375 data-nosnippet>375</a> <span class="attr">#[inline]
<a href=#376 id=376 data-nosnippet>376</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#377 id=377 data-nosnippet>377</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#378 id=378 data-nosnippet>378</a> Positive(u) =&gt; u % other,
<a href=#379 id=379 data-nosnippet>379</a> Negative(u) =&gt; -(u % other),
<a href=#380 id=380 data-nosnippet>380</a> }
<a href=#381 id=381 data-nosnippet>381</a> }
<a href=#382 id=382 data-nosnippet>382</a>}
<a href=#383 id=383 data-nosnippet>383</a>
<a href=#384 id=384 data-nosnippet>384</a><span class="kw">impl </span>Rem&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#385 id=385 data-nosnippet>385</a> <span class="kw">type </span>Output = BigInt;
<a href=#386 id=386 data-nosnippet>386</a>
<a href=#387 id=387 data-nosnippet>387</a> <span class="attr">#[inline]
<a href=#388 id=388 data-nosnippet>388</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: i64) -&gt; BigInt {
<a href=#389 id=389 data-nosnippet>389</a> <span class="self">self </span>% other.unsigned_abs()
<a href=#390 id=390 data-nosnippet>390</a> }
<a href=#391 id=391 data-nosnippet>391</a>}
<a href=#392 id=392 data-nosnippet>392</a>
<a href=#393 id=393 data-nosnippet>393</a><span class="kw">impl </span>RemAssign&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#394 id=394 data-nosnippet>394</a> <span class="attr">#[inline]
<a href=#395 id=395 data-nosnippet>395</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i64) {
<a href=#396 id=396 data-nosnippet>396</a> <span class="kw-2">*</span><span class="self">self </span>%= other.unsigned_abs();
<a href=#397 id=397 data-nosnippet>397</a> }
<a href=#398 id=398 data-nosnippet>398</a>}
<a href=#399 id=399 data-nosnippet>399</a>
<a href=#400 id=400 data-nosnippet>400</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>i64 {
<a href=#401 id=401 data-nosnippet>401</a> <span class="kw">type </span>Output = BigInt;
<a href=#402 id=402 data-nosnippet>402</a>
<a href=#403 id=403 data-nosnippet>403</a> <span class="attr">#[inline]
<a href=#404 id=404 data-nosnippet>404</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#405 id=405 data-nosnippet>405</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#406 id=406 data-nosnippet>406</a> Positive(u) =&gt; u % other,
<a href=#407 id=407 data-nosnippet>407</a> Negative(u) =&gt; -(u % other),
<a href=#408 id=408 data-nosnippet>408</a> }
<a href=#409 id=409 data-nosnippet>409</a> }
<a href=#410 id=410 data-nosnippet>410</a>}
<a href=#411 id=411 data-nosnippet>411</a>
<a href=#412 id=412 data-nosnippet>412</a><span class="kw">impl </span>Rem&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#413 id=413 data-nosnippet>413</a> <span class="kw">type </span>Output = BigInt;
<a href=#414 id=414 data-nosnippet>414</a>
<a href=#415 id=415 data-nosnippet>415</a> <span class="attr">#[inline]
<a href=#416 id=416 data-nosnippet>416</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: i128) -&gt; BigInt {
<a href=#417 id=417 data-nosnippet>417</a> <span class="self">self </span>% other.unsigned_abs()
<a href=#418 id=418 data-nosnippet>418</a> }
<a href=#419 id=419 data-nosnippet>419</a>}
<a href=#420 id=420 data-nosnippet>420</a>
<a href=#421 id=421 data-nosnippet>421</a><span class="kw">impl </span>RemAssign&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#422 id=422 data-nosnippet>422</a> <span class="attr">#[inline]
<a href=#423 id=423 data-nosnippet>423</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i128) {
<a href=#424 id=424 data-nosnippet>424</a> <span class="kw-2">*</span><span class="self">self </span>%= other.unsigned_abs();
<a href=#425 id=425 data-nosnippet>425</a> }
<a href=#426 id=426 data-nosnippet>426</a>}
<a href=#427 id=427 data-nosnippet>427</a>
<a href=#428 id=428 data-nosnippet>428</a><span class="kw">impl </span>Rem&lt;BigInt&gt; <span class="kw">for </span>i128 {
<a href=#429 id=429 data-nosnippet>429</a> <span class="kw">type </span>Output = BigInt;
<a href=#430 id=430 data-nosnippet>430</a>
<a href=#431 id=431 data-nosnippet>431</a> <span class="attr">#[inline]
<a href=#432 id=432 data-nosnippet>432</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#433 id=433 data-nosnippet>433</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#434 id=434 data-nosnippet>434</a> Positive(u) =&gt; u % other,
<a href=#435 id=435 data-nosnippet>435</a> Negative(u) =&gt; -(u % other),
<a href=#436 id=436 data-nosnippet>436</a> }
<a href=#437 id=437 data-nosnippet>437</a> }
<a href=#438 id=438 data-nosnippet>438</a>}
<a href=#439 id=439 data-nosnippet>439</a>
<a href=#440 id=440 data-nosnippet>440</a><span class="kw">impl </span>CheckedDiv <span class="kw">for </span>BigInt {
<a href=#441 id=441 data-nosnippet>441</a> <span class="attr">#[inline]
<a href=#442 id=442 data-nosnippet>442</a> </span><span class="kw">fn </span>checked_div(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#443 id=443 data-nosnippet>443</a> <span class="kw">if </span>v.is_zero() {
<a href=#444 id=444 data-nosnippet>444</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#445 id=445 data-nosnippet>445</a> }
<a href=#446 id=446 data-nosnippet>446</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div(v))
<a href=#447 id=447 data-nosnippet>447</a> }
<a href=#448 id=448 data-nosnippet>448</a>}
<a href=#449 id=449 data-nosnippet>449</a>
<a href=#450 id=450 data-nosnippet>450</a><span class="kw">impl </span>CheckedEuclid <span class="kw">for </span>BigInt {
<a href=#451 id=451 data-nosnippet>451</a> <span class="attr">#[inline]
<a href=#452 id=452 data-nosnippet>452</a> </span><span class="kw">fn </span>checked_div_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#453 id=453 data-nosnippet>453</a> <span class="kw">if </span>v.is_zero() {
<a href=#454 id=454 data-nosnippet>454</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#455 id=455 data-nosnippet>455</a> }
<a href=#456 id=456 data-nosnippet>456</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div_euclid(v))
<a href=#457 id=457 data-nosnippet>457</a> }
<a href=#458 id=458 data-nosnippet>458</a>
<a href=#459 id=459 data-nosnippet>459</a> <span class="attr">#[inline]
<a href=#460 id=460 data-nosnippet>460</a> </span><span class="kw">fn </span>checked_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#461 id=461 data-nosnippet>461</a> <span class="kw">if </span>v.is_zero() {
<a href=#462 id=462 data-nosnippet>462</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#463 id=463 data-nosnippet>463</a> }
<a href=#464 id=464 data-nosnippet>464</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.rem_euclid(v))
<a href=#465 id=465 data-nosnippet>465</a> }
<a href=#466 id=466 data-nosnippet>466</a>
<a href=#467 id=467 data-nosnippet>467</a> <span class="kw">fn </span>checked_div_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span><span class="self">Self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;(<span class="self">Self</span>, <span class="self">Self</span>)&gt; {
<a href=#468 id=468 data-nosnippet>468</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div_rem_euclid(v))
<a href=#469 id=469 data-nosnippet>469</a> }
<a href=#470 id=470 data-nosnippet>470</a>}
<a href=#471 id=471 data-nosnippet>471</a>
<a href=#472 id=472 data-nosnippet>472</a><span class="kw">impl </span>Euclid <span class="kw">for </span>BigInt {
<a href=#473 id=473 data-nosnippet>473</a> <span class="attr">#[inline]
<a href=#474 id=474 data-nosnippet>474</a> </span><span class="kw">fn </span>div_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#475 id=475 data-nosnippet>475</a> <span class="kw">let </span>(q, r) = <span class="self">self</span>.div_rem(v);
<a href=#476 id=476 data-nosnippet>476</a> <span class="kw">if </span>r.is_negative() {
<a href=#477 id=477 data-nosnippet>477</a> <span class="kw">if </span>v.is_positive() {
<a href=#478 id=478 data-nosnippet>478</a> q - <span class="number">1
<a href=#479 id=479 data-nosnippet>479</a> </span>} <span class="kw">else </span>{
<a href=#480 id=480 data-nosnippet>480</a> q + <span class="number">1
<a href=#481 id=481 data-nosnippet>481</a> </span>}
<a href=#482 id=482 data-nosnippet>482</a> } <span class="kw">else </span>{
<a href=#483 id=483 data-nosnippet>483</a> q
<a href=#484 id=484 data-nosnippet>484</a> }
<a href=#485 id=485 data-nosnippet>485</a> }
<a href=#486 id=486 data-nosnippet>486</a>
<a href=#487 id=487 data-nosnippet>487</a> <span class="attr">#[inline]
<a href=#488 id=488 data-nosnippet>488</a> </span><span class="kw">fn </span>rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#489 id=489 data-nosnippet>489</a> <span class="kw">let </span>r = <span class="self">self </span>% v;
<a href=#490 id=490 data-nosnippet>490</a> <span class="kw">if </span>r.is_negative() {
<a href=#491 id=491 data-nosnippet>491</a> <span class="kw">if </span>v.is_positive() {
<a href=#492 id=492 data-nosnippet>492</a> r + v
<a href=#493 id=493 data-nosnippet>493</a> } <span class="kw">else </span>{
<a href=#494 id=494 data-nosnippet>494</a> r - v
<a href=#495 id=495 data-nosnippet>495</a> }
<a href=#496 id=496 data-nosnippet>496</a> } <span class="kw">else </span>{
<a href=#497 id=497 data-nosnippet>497</a> r
<a href=#498 id=498 data-nosnippet>498</a> }
<a href=#499 id=499 data-nosnippet>499</a> }
<a href=#500 id=500 data-nosnippet>500</a>
<a href=#501 id=501 data-nosnippet>501</a> <span class="kw">fn </span>div_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span><span class="self">Self</span>) -&gt; (<span class="self">Self</span>, <span class="self">Self</span>) {
<a href=#502 id=502 data-nosnippet>502</a> <span class="kw">let </span>(q, r) = <span class="self">self</span>.div_rem(v);
<a href=#503 id=503 data-nosnippet>503</a> <span class="kw">if </span>r.is_negative() {
<a href=#504 id=504 data-nosnippet>504</a> <span class="kw">if </span>v.is_positive() {
<a href=#505 id=505 data-nosnippet>505</a> (q - <span class="number">1</span>, r + v)
<a href=#506 id=506 data-nosnippet>506</a> } <span class="kw">else </span>{
<a href=#507 id=507 data-nosnippet>507</a> (q + <span class="number">1</span>, r - v)
<a href=#508 id=508 data-nosnippet>508</a> }
<a href=#509 id=509 data-nosnippet>509</a> } <span class="kw">else </span>{
<a href=#510 id=510 data-nosnippet>510</a> (q, r)
<a href=#511 id=511 data-nosnippet>511</a> }
<a href=#512 id=512 data-nosnippet>512</a> }
<a href=#513 id=513 data-nosnippet>513</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,218 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/multiplication.rs`."><title>multiplication.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>multiplication.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::CheckedUnsignedAbs::{Negative, Positive};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::{<span class="self">self</span>, Minus, NoSign, Plus};
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use super</span>::{BigInt, UnsignedAbs};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use crate</span>::{IsizePromotion, UsizePromotion};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::iter::Product;
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::ops::{Mul, MulAssign};
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>num_traits::{CheckedMul, One, Zero};
<a href=#10 id=10 data-nosnippet>10</a>
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">impl </span>Mul&lt;Sign&gt; <span class="kw">for </span>Sign {
<a href=#12 id=12 data-nosnippet>12</a> <span class="kw">type </span>Output = Sign;
<a href=#13 id=13 data-nosnippet>13</a>
<a href=#14 id=14 data-nosnippet>14</a> <span class="attr">#[inline]
<a href=#15 id=15 data-nosnippet>15</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: Sign) -&gt; Sign {
<a href=#16 id=16 data-nosnippet>16</a> <span class="kw">match </span>(<span class="self">self</span>, other) {
<a href=#17 id=17 data-nosnippet>17</a> (NoSign, <span class="kw">_</span>) | (<span class="kw">_</span>, NoSign) =&gt; NoSign,
<a href=#18 id=18 data-nosnippet>18</a> (Plus, Plus) | (Minus, Minus) =&gt; Plus,
<a href=#19 id=19 data-nosnippet>19</a> (Plus, Minus) | (Minus, Plus) =&gt; Minus,
<a href=#20 id=20 data-nosnippet>20</a> }
<a href=#21 id=21 data-nosnippet>21</a> }
<a href=#22 id=22 data-nosnippet>22</a>}
<a href=#23 id=23 data-nosnippet>23</a>
<a href=#24 id=24 data-nosnippet>24</a><span class="macro">macro_rules!</span> impl_mul {
<a href=#25 id=25 data-nosnippet>25</a> ($(<span class="kw">impl </span>Mul&lt;<span class="macro-nonterminal">$Other</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$Self</span>:ty;)<span class="kw-2">*</span>) =&gt; {$(
<a href=#26 id=26 data-nosnippet>26</a> <span class="kw">impl </span>Mul&lt;<span class="macro-nonterminal">$Other</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$Self </span>{
<a href=#27 id=27 data-nosnippet>27</a> <span class="kw">type </span>Output = BigInt;
<a href=#28 id=28 data-nosnippet>28</a>
<a href=#29 id=29 data-nosnippet>29</a> <span class="attr">#[inline]
<a href=#30 id=30 data-nosnippet>30</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: <span class="macro-nonterminal">$Other</span>) -&gt; BigInt {
<a href=#31 id=31 data-nosnippet>31</a> <span class="comment">// automatically match value/ref
<a href=#32 id=32 data-nosnippet>32</a> </span><span class="kw">let </span>BigInt { data: x, .. } = <span class="self">self</span>;
<a href=#33 id=33 data-nosnippet>33</a> <span class="kw">let </span>BigInt { data: y, .. } = other;
<a href=#34 id=34 data-nosnippet>34</a> BigInt::from_biguint(<span class="self">self</span>.sign * other.sign, x * y)
<a href=#35 id=35 data-nosnippet>35</a> }
<a href=#36 id=36 data-nosnippet>36</a> }
<a href=#37 id=37 data-nosnippet>37</a> )<span class="kw-2">*</span>}
<a href=#38 id=38 data-nosnippet>38</a>}
<a href=#39 id=39 data-nosnippet>39</a><span class="macro">impl_mul!</span> {
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">impl </span>Mul&lt;BigInt&gt; <span class="kw">for </span>BigInt;
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw">impl </span>Mul&lt;BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt;
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">impl </span>Mul&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt;
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">impl </span>Mul&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt;
<a href=#44 id=44 data-nosnippet>44</a>}
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a><span class="macro">macro_rules!</span> impl_mul_assign {
<a href=#47 id=47 data-nosnippet>47</a> ($(<span class="kw">impl </span>MulAssign&lt;<span class="macro-nonterminal">$Other</span>:ty&gt; <span class="kw">for </span>BigInt;)<span class="kw-2">*</span>) =&gt; {$(
<a href=#48 id=48 data-nosnippet>48</a> <span class="kw">impl </span>MulAssign&lt;<span class="macro-nonterminal">$Other</span>&gt; <span class="kw">for </span>BigInt {
<a href=#49 id=49 data-nosnippet>49</a> <span class="attr">#[inline]
<a href=#50 id=50 data-nosnippet>50</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="macro-nonterminal">$Other</span>) {
<a href=#51 id=51 data-nosnippet>51</a> <span class="comment">// automatically match value/ref
<a href=#52 id=52 data-nosnippet>52</a> </span><span class="kw">let </span>BigInt { data: y, .. } = other;
<a href=#53 id=53 data-nosnippet>53</a> <span class="self">self</span>.data <span class="kw-2">*</span>= y;
<a href=#54 id=54 data-nosnippet>54</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#55 id=55 data-nosnippet>55</a> <span class="self">self</span>.sign = NoSign;
<a href=#56 id=56 data-nosnippet>56</a> } <span class="kw">else </span>{
<a href=#57 id=57 data-nosnippet>57</a> <span class="self">self</span>.sign = <span class="self">self</span>.sign * other.sign;
<a href=#58 id=58 data-nosnippet>58</a> }
<a href=#59 id=59 data-nosnippet>59</a> }
<a href=#60 id=60 data-nosnippet>60</a> }
<a href=#61 id=61 data-nosnippet>61</a> )<span class="kw-2">*</span>}
<a href=#62 id=62 data-nosnippet>62</a>}
<a href=#63 id=63 data-nosnippet>63</a><span class="macro">impl_mul_assign!</span> {
<a href=#64 id=64 data-nosnippet>64</a> <span class="kw">impl </span>MulAssign&lt;BigInt&gt; <span class="kw">for </span>BigInt;
<a href=#65 id=65 data-nosnippet>65</a> <span class="kw">impl </span>MulAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt;
<a href=#66 id=66 data-nosnippet>66</a>}
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a><span class="macro">promote_all_scalars!</span>(<span class="kw">impl </span>Mul <span class="kw">for </span>BigInt, mul);
<a href=#69 id=69 data-nosnippet>69</a><span class="macro">promote_all_scalars_assign!</span>(<span class="kw">impl </span>MulAssign <span class="kw">for </span>BigInt, mul_assign);
<a href=#70 id=70 data-nosnippet>70</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u32&gt; <span class="kw">for </span>BigInt, mul);
<a href=#71 id=71 data-nosnippet>71</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u64&gt; <span class="kw">for </span>BigInt, mul);
<a href=#72 id=72 data-nosnippet>72</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u128&gt; <span class="kw">for </span>BigInt, mul);
<a href=#73 id=73 data-nosnippet>73</a>
<a href=#74 id=74 data-nosnippet>74</a><span class="kw">impl </span>Mul&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#75 id=75 data-nosnippet>75</a> <span class="kw">type </span>Output = BigInt;
<a href=#76 id=76 data-nosnippet>76</a>
<a href=#77 id=77 data-nosnippet>77</a> <span class="attr">#[inline]
<a href=#78 id=78 data-nosnippet>78</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: u32) -&gt; BigInt {
<a href=#79 id=79 data-nosnippet>79</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data * other)
<a href=#80 id=80 data-nosnippet>80</a> }
<a href=#81 id=81 data-nosnippet>81</a>}
<a href=#82 id=82 data-nosnippet>82</a>
<a href=#83 id=83 data-nosnippet>83</a><span class="kw">impl </span>MulAssign&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#84 id=84 data-nosnippet>84</a> <span class="attr">#[inline]
<a href=#85 id=85 data-nosnippet>85</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#86 id=86 data-nosnippet>86</a> <span class="self">self</span>.data <span class="kw-2">*</span>= other;
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#88 id=88 data-nosnippet>88</a> <span class="self">self</span>.sign = NoSign;
<a href=#89 id=89 data-nosnippet>89</a> }
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a>}
<a href=#92 id=92 data-nosnippet>92</a>
<a href=#93 id=93 data-nosnippet>93</a><span class="kw">impl </span>Mul&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">type </span>Output = BigInt;
<a href=#95 id=95 data-nosnippet>95</a>
<a href=#96 id=96 data-nosnippet>96</a> <span class="attr">#[inline]
<a href=#97 id=97 data-nosnippet>97</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: u64) -&gt; BigInt {
<a href=#98 id=98 data-nosnippet>98</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data * other)
<a href=#99 id=99 data-nosnippet>99</a> }
<a href=#100 id=100 data-nosnippet>100</a>}
<a href=#101 id=101 data-nosnippet>101</a>
<a href=#102 id=102 data-nosnippet>102</a><span class="kw">impl </span>MulAssign&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#103 id=103 data-nosnippet>103</a> <span class="attr">#[inline]
<a href=#104 id=104 data-nosnippet>104</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#105 id=105 data-nosnippet>105</a> <span class="self">self</span>.data <span class="kw-2">*</span>= other;
<a href=#106 id=106 data-nosnippet>106</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#107 id=107 data-nosnippet>107</a> <span class="self">self</span>.sign = NoSign;
<a href=#108 id=108 data-nosnippet>108</a> }
<a href=#109 id=109 data-nosnippet>109</a> }
<a href=#110 id=110 data-nosnippet>110</a>}
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a><span class="kw">impl </span>Mul&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#113 id=113 data-nosnippet>113</a> <span class="kw">type </span>Output = BigInt;
<a href=#114 id=114 data-nosnippet>114</a>
<a href=#115 id=115 data-nosnippet>115</a> <span class="attr">#[inline]
<a href=#116 id=116 data-nosnippet>116</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: u128) -&gt; BigInt {
<a href=#117 id=117 data-nosnippet>117</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data * other)
<a href=#118 id=118 data-nosnippet>118</a> }
<a href=#119 id=119 data-nosnippet>119</a>}
<a href=#120 id=120 data-nosnippet>120</a>
<a href=#121 id=121 data-nosnippet>121</a><span class="kw">impl </span>MulAssign&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#122 id=122 data-nosnippet>122</a> <span class="attr">#[inline]
<a href=#123 id=123 data-nosnippet>123</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#124 id=124 data-nosnippet>124</a> <span class="self">self</span>.data <span class="kw-2">*</span>= other;
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">if </span><span class="self">self</span>.data.is_zero() {
<a href=#126 id=126 data-nosnippet>126</a> <span class="self">self</span>.sign = NoSign;
<a href=#127 id=127 data-nosnippet>127</a> }
<a href=#128 id=128 data-nosnippet>128</a> }
<a href=#129 id=129 data-nosnippet>129</a>}
<a href=#130 id=130 data-nosnippet>130</a>
<a href=#131 id=131 data-nosnippet>131</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;i32&gt; <span class="kw">for </span>BigInt, mul);
<a href=#132 id=132 data-nosnippet>132</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;i64&gt; <span class="kw">for </span>BigInt, mul);
<a href=#133 id=133 data-nosnippet>133</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;i128&gt; <span class="kw">for </span>BigInt, mul);
<a href=#134 id=134 data-nosnippet>134</a>
<a href=#135 id=135 data-nosnippet>135</a><span class="kw">impl </span>Mul&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">type </span>Output = BigInt;
<a href=#137 id=137 data-nosnippet>137</a>
<a href=#138 id=138 data-nosnippet>138</a> <span class="attr">#[inline]
<a href=#139 id=139 data-nosnippet>139</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: i32) -&gt; BigInt {
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#141 id=141 data-nosnippet>141</a> Positive(u) =&gt; <span class="self">self </span>* u,
<a href=#142 id=142 data-nosnippet>142</a> Negative(u) =&gt; -<span class="self">self </span>* u,
<a href=#143 id=143 data-nosnippet>143</a> }
<a href=#144 id=144 data-nosnippet>144</a> }
<a href=#145 id=145 data-nosnippet>145</a>}
<a href=#146 id=146 data-nosnippet>146</a>
<a href=#147 id=147 data-nosnippet>147</a><span class="kw">impl </span>MulAssign&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#148 id=148 data-nosnippet>148</a> <span class="attr">#[inline]
<a href=#149 id=149 data-nosnippet>149</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i32) {
<a href=#150 id=150 data-nosnippet>150</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#151 id=151 data-nosnippet>151</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span><span class="kw-2">*</span>= u,
<a href=#152 id=152 data-nosnippet>152</a> Negative(u) =&gt; {
<a href=#153 id=153 data-nosnippet>153</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#154 id=154 data-nosnippet>154</a> <span class="self">self</span>.data <span class="kw-2">*</span>= u;
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a> }
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a>}
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a><span class="kw">impl </span>Mul&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">type </span>Output = BigInt;
<a href=#162 id=162 data-nosnippet>162</a>
<a href=#163 id=163 data-nosnippet>163</a> <span class="attr">#[inline]
<a href=#164 id=164 data-nosnippet>164</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: i64) -&gt; BigInt {
<a href=#165 id=165 data-nosnippet>165</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#166 id=166 data-nosnippet>166</a> Positive(u) =&gt; <span class="self">self </span>* u,
<a href=#167 id=167 data-nosnippet>167</a> Negative(u) =&gt; -<span class="self">self </span>* u,
<a href=#168 id=168 data-nosnippet>168</a> }
<a href=#169 id=169 data-nosnippet>169</a> }
<a href=#170 id=170 data-nosnippet>170</a>}
<a href=#171 id=171 data-nosnippet>171</a>
<a href=#172 id=172 data-nosnippet>172</a><span class="kw">impl </span>MulAssign&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#173 id=173 data-nosnippet>173</a> <span class="attr">#[inline]
<a href=#174 id=174 data-nosnippet>174</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i64) {
<a href=#175 id=175 data-nosnippet>175</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#176 id=176 data-nosnippet>176</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span><span class="kw-2">*</span>= u,
<a href=#177 id=177 data-nosnippet>177</a> Negative(u) =&gt; {
<a href=#178 id=178 data-nosnippet>178</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#179 id=179 data-nosnippet>179</a> <span class="self">self</span>.data <span class="kw-2">*</span>= u;
<a href=#180 id=180 data-nosnippet>180</a> }
<a href=#181 id=181 data-nosnippet>181</a> }
<a href=#182 id=182 data-nosnippet>182</a> }
<a href=#183 id=183 data-nosnippet>183</a>}
<a href=#184 id=184 data-nosnippet>184</a>
<a href=#185 id=185 data-nosnippet>185</a><span class="kw">impl </span>Mul&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#186 id=186 data-nosnippet>186</a> <span class="kw">type </span>Output = BigInt;
<a href=#187 id=187 data-nosnippet>187</a>
<a href=#188 id=188 data-nosnippet>188</a> <span class="attr">#[inline]
<a href=#189 id=189 data-nosnippet>189</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: i128) -&gt; BigInt {
<a href=#190 id=190 data-nosnippet>190</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#191 id=191 data-nosnippet>191</a> Positive(u) =&gt; <span class="self">self </span>* u,
<a href=#192 id=192 data-nosnippet>192</a> Negative(u) =&gt; -<span class="self">self </span>* u,
<a href=#193 id=193 data-nosnippet>193</a> }
<a href=#194 id=194 data-nosnippet>194</a> }
<a href=#195 id=195 data-nosnippet>195</a>}
<a href=#196 id=196 data-nosnippet>196</a>
<a href=#197 id=197 data-nosnippet>197</a><span class="kw">impl </span>MulAssign&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#198 id=198 data-nosnippet>198</a> <span class="attr">#[inline]
<a href=#199 id=199 data-nosnippet>199</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i128) {
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#201 id=201 data-nosnippet>201</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span><span class="kw-2">*</span>= u,
<a href=#202 id=202 data-nosnippet>202</a> Negative(u) =&gt; {
<a href=#203 id=203 data-nosnippet>203</a> <span class="self">self</span>.sign = -<span class="self">self</span>.sign;
<a href=#204 id=204 data-nosnippet>204</a> <span class="self">self</span>.data <span class="kw-2">*</span>= u;
<a href=#205 id=205 data-nosnippet>205</a> }
<a href=#206 id=206 data-nosnippet>206</a> }
<a href=#207 id=207 data-nosnippet>207</a> }
<a href=#208 id=208 data-nosnippet>208</a>}
<a href=#209 id=209 data-nosnippet>209</a>
<a href=#210 id=210 data-nosnippet>210</a><span class="kw">impl </span>CheckedMul <span class="kw">for </span>BigInt {
<a href=#211 id=211 data-nosnippet>211</a> <span class="attr">#[inline]
<a href=#212 id=212 data-nosnippet>212</a> </span><span class="kw">fn </span>checked_mul(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#213 id=213 data-nosnippet>213</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.mul(v))
<a href=#214 id=214 data-nosnippet>214</a> }
<a href=#215 id=215 data-nosnippet>215</a>}
<a href=#216 id=216 data-nosnippet>216</a>
<a href=#217 id=217 data-nosnippet>217</a><span class="macro">impl_product_iter_type!</span>(BigInt);
</code></pre></div></section></main></body></html>
@@ -0,0 +1,95 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/power.rs`."><title>power.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>power.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-2"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::BigInt;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::{<span class="self">self</span>, Minus, Plus};
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::BigUint;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>num_integer::Integer;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>num_traits::{Pow, Signed, Zero};
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="doccomment">/// Help function for pow
<a href=#10 id=10 data-nosnippet>10</a>///
<a href=#11 id=11 data-nosnippet>11</a>/// Computes the effect of the exponent on the sign.
<a href=#12 id=12 data-nosnippet>12</a></span><span class="attr">#[inline]
<a href=#13 id=13 data-nosnippet>13</a></span><span class="kw">fn </span>powsign&lt;T: Integer&gt;(sign: Sign, other: <span class="kw-2">&amp;</span>T) -&gt; Sign {
<a href=#14 id=14 data-nosnippet>14</a> <span class="kw">if </span>other.is_zero() {
<a href=#15 id=15 data-nosnippet>15</a> Plus
<a href=#16 id=16 data-nosnippet>16</a> } <span class="kw">else if </span><span class="macro">sign !</span>= Minus || other.is_odd() {
<a href=#17 id=17 data-nosnippet>17</a> sign
<a href=#18 id=18 data-nosnippet>18</a> } <span class="kw">else </span>{
<a href=#19 id=19 data-nosnippet>19</a> -sign
<a href=#20 id=20 data-nosnippet>20</a> }
<a href=#21 id=21 data-nosnippet>21</a>}
<a href=#22 id=22 data-nosnippet>22</a>
<a href=#23 id=23 data-nosnippet>23</a><span class="macro">macro_rules!</span> pow_impl {
<a href=#24 id=24 data-nosnippet>24</a> (<span class="macro-nonterminal">$T</span>:ty) =&gt; {
<a href=#25 id=25 data-nosnippet>25</a> <span class="kw">impl </span>Pow&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigInt {
<a href=#26 id=26 data-nosnippet>26</a> <span class="kw">type </span>Output = BigInt;
<a href=#27 id=27 data-nosnippet>27</a>
<a href=#28 id=28 data-nosnippet>28</a> <span class="attr">#[inline]
<a href=#29 id=29 data-nosnippet>29</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$T</span>) -&gt; BigInt {
<a href=#30 id=30 data-nosnippet>30</a> BigInt::from_biguint(powsign(<span class="self">self</span>.sign, <span class="kw-2">&amp;</span>rhs), <span class="self">self</span>.data.pow(rhs))
<a href=#31 id=31 data-nosnippet>31</a> }
<a href=#32 id=32 data-nosnippet>32</a> }
<a href=#33 id=33 data-nosnippet>33</a>
<a href=#34 id=34 data-nosnippet>34</a> <span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigInt {
<a href=#35 id=35 data-nosnippet>35</a> <span class="kw">type </span>Output = BigInt;
<a href=#36 id=36 data-nosnippet>36</a>
<a href=#37 id=37 data-nosnippet>37</a> <span class="attr">#[inline]
<a href=#38 id=38 data-nosnippet>38</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>) -&gt; BigInt {
<a href=#39 id=39 data-nosnippet>39</a> BigInt::from_biguint(powsign(<span class="self">self</span>.sign, rhs), <span class="self">self</span>.data.pow(rhs))
<a href=#40 id=40 data-nosnippet>40</a> }
<a href=#41 id=41 data-nosnippet>41</a> }
<a href=#42 id=42 data-nosnippet>42</a>
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">impl </span>Pow&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw">type </span>Output = BigInt;
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a> <span class="attr">#[inline]
<a href=#47 id=47 data-nosnippet>47</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$T</span>) -&gt; BigInt {
<a href=#48 id=48 data-nosnippet>48</a> BigInt::from_biguint(powsign(<span class="self">self</span>.sign, <span class="kw-2">&amp;</span>rhs), Pow::pow(<span class="kw-2">&amp;</span><span class="self">self</span>.data, rhs))
<a href=#49 id=49 data-nosnippet>49</a> }
<a href=#50 id=50 data-nosnippet>50</a> }
<a href=#51 id=51 data-nosnippet>51</a>
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#53 id=53 data-nosnippet>53</a> <span class="kw">type </span>Output = BigInt;
<a href=#54 id=54 data-nosnippet>54</a>
<a href=#55 id=55 data-nosnippet>55</a> <span class="attr">#[inline]
<a href=#56 id=56 data-nosnippet>56</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>) -&gt; BigInt {
<a href=#57 id=57 data-nosnippet>57</a> BigInt::from_biguint(powsign(<span class="self">self</span>.sign, rhs), Pow::pow(<span class="kw-2">&amp;</span><span class="self">self</span>.data, rhs))
<a href=#58 id=58 data-nosnippet>58</a> }
<a href=#59 id=59 data-nosnippet>59</a> }
<a href=#60 id=60 data-nosnippet>60</a> };
<a href=#61 id=61 data-nosnippet>61</a>}
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a><span class="macro">pow_impl!</span>(u8);
<a href=#64 id=64 data-nosnippet>64</a><span class="macro">pow_impl!</span>(u16);
<a href=#65 id=65 data-nosnippet>65</a><span class="macro">pow_impl!</span>(u32);
<a href=#66 id=66 data-nosnippet>66</a><span class="macro">pow_impl!</span>(u64);
<a href=#67 id=67 data-nosnippet>67</a><span class="macro">pow_impl!</span>(usize);
<a href=#68 id=68 data-nosnippet>68</a><span class="macro">pow_impl!</span>(u128);
<a href=#69 id=69 data-nosnippet>69</a><span class="macro">pow_impl!</span>(BigUint);
<a href=#70 id=70 data-nosnippet>70</a>
<a href=#71 id=71 data-nosnippet>71</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>modpow(x: <span class="kw-2">&amp;</span>BigInt, exponent: <span class="kw-2">&amp;</span>BigInt, modulus: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#72 id=72 data-nosnippet>72</a> <span class="macro">assert!</span>(
<a href=#73 id=73 data-nosnippet>73</a> !exponent.is_negative(),
<a href=#74 id=74 data-nosnippet>74</a> <span class="string">"negative exponentiation is not supported!"
<a href=#75 id=75 data-nosnippet>75</a> </span>);
<a href=#76 id=76 data-nosnippet>76</a> <span class="macro">assert!</span>(
<a href=#77 id=77 data-nosnippet>77</a> !modulus.is_zero(),
<a href=#78 id=78 data-nosnippet>78</a> <span class="string">"attempt to calculate with zero modulus!"
<a href=#79 id=79 data-nosnippet>79</a> </span>);
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a> <span class="kw">let </span>result = x.data.modpow(<span class="kw-2">&amp;</span>exponent.data, <span class="kw-2">&amp;</span>modulus.data);
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">if </span>result.is_zero() {
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">return </span>BigInt::ZERO;
<a href=#84 id=84 data-nosnippet>84</a> }
<a href=#85 id=85 data-nosnippet>85</a>
<a href=#86 id=86 data-nosnippet>86</a> <span class="comment">// The sign of the result follows the modulus, like `mod_floor`.
<a href=#87 id=87 data-nosnippet>87</a> </span><span class="kw">let </span>(sign, mag) = <span class="kw">match </span>(x.is_negative() &amp;&amp; exponent.is_odd(), modulus.is_negative()) {
<a href=#88 id=88 data-nosnippet>88</a> (<span class="bool-val">false</span>, <span class="bool-val">false</span>) =&gt; (Plus, result),
<a href=#89 id=89 data-nosnippet>89</a> (<span class="bool-val">true</span>, <span class="bool-val">false</span>) =&gt; (Plus, <span class="kw-2">&amp;</span>modulus.data - result),
<a href=#90 id=90 data-nosnippet>90</a> (<span class="bool-val">false</span>, <span class="bool-val">true</span>) =&gt; (Minus, <span class="kw-2">&amp;</span>modulus.data - result),
<a href=#91 id=91 data-nosnippet>91</a> (<span class="bool-val">true</span>, <span class="bool-val">true</span>) =&gt; (Minus, result),
<a href=#92 id=92 data-nosnippet>92</a> };
<a href=#93 id=93 data-nosnippet>93</a> BigInt::from_biguint(sign, mag)
<a href=#94 id=94 data-nosnippet>94</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,108 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/shift.rs`."><title>shift.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>shift.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::BigInt;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::NoSign;
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span>core::ops::{Shl, ShlAssign, Shr, ShrAssign};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span>num_traits::{PrimInt, Signed, Zero};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="macro">macro_rules!</span> impl_shift {
<a href=#8 id=8 data-nosnippet>8</a> (@<span class="kw-2">ref </span><span class="macro-nonterminal">$Shx</span>:ident :: <span class="macro-nonterminal">$shx</span>:ident, <span class="macro-nonterminal">$ShxAssign</span>:ident :: <span class="macro-nonterminal">$shx_assign</span>:ident, <span class="macro-nonterminal">$rhs</span>:ty) =&gt; {
<a href=#9 id=9 data-nosnippet>9</a> <span class="kw">impl </span><span class="macro-nonterminal">$Shx</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#10 id=10 data-nosnippet>10</a> <span class="kw">type </span>Output = BigInt;
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a> <span class="attr">#[inline]
<a href=#13 id=13 data-nosnippet>13</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#14 id=14 data-nosnippet>14</a> <span class="macro-nonterminal">$Shx</span>::<span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs)
<a href=#15 id=15 data-nosnippet>15</a> }
<a href=#16 id=16 data-nosnippet>16</a> }
<a href=#17 id=17 data-nosnippet>17</a> <span class="kw">impl </span><span class="macro-nonterminal">$Shx</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#18 id=18 data-nosnippet>18</a> <span class="kw">type </span>Output = BigInt;
<a href=#19 id=19 data-nosnippet>19</a>
<a href=#20 id=20 data-nosnippet>20</a> <span class="attr">#[inline]
<a href=#21 id=21 data-nosnippet>21</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#22 id=22 data-nosnippet>22</a> <span class="macro-nonterminal">$Shx</span>::<span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs)
<a href=#23 id=23 data-nosnippet>23</a> }
<a href=#24 id=24 data-nosnippet>24</a> }
<a href=#25 id=25 data-nosnippet>25</a> <span class="kw">impl </span><span class="macro-nonterminal">$ShxAssign</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#26 id=26 data-nosnippet>26</a> <span class="attr">#[inline]
<a href=#27 id=27 data-nosnippet>27</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx_assign</span>(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) {
<a href=#28 id=28 data-nosnippet>28</a> <span class="macro-nonterminal">$ShxAssign</span>::<span class="macro-nonterminal">$shx_assign</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs);
<a href=#29 id=29 data-nosnippet>29</a> }
<a href=#30 id=30 data-nosnippet>30</a> }
<a href=#31 id=31 data-nosnippet>31</a> };
<a href=#32 id=32 data-nosnippet>32</a> ($(<span class="macro-nonterminal">$rhs</span>:ty),+) =&gt; {$(
<a href=#33 id=33 data-nosnippet>33</a> <span class="kw">impl </span>Shl&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#34 id=34 data-nosnippet>34</a> <span class="kw">type </span>Output = BigInt;
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a> <span class="attr">#[inline]
<a href=#37 id=37 data-nosnippet>37</a> </span><span class="kw">fn </span>shl(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#38 id=38 data-nosnippet>38</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="self">self</span>.data &lt;&lt; rhs)
<a href=#39 id=39 data-nosnippet>39</a> }
<a href=#40 id=40 data-nosnippet>40</a> }
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw">impl </span>Shl&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">type </span>Output = BigInt;
<a href=#43 id=43 data-nosnippet>43</a>
<a href=#44 id=44 data-nosnippet>44</a> <span class="attr">#[inline]
<a href=#45 id=45 data-nosnippet>45</a> </span><span class="kw">fn </span>shl(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#46 id=46 data-nosnippet>46</a> BigInt::from_biguint(<span class="self">self</span>.sign, <span class="kw-2">&amp;</span><span class="self">self</span>.data &lt;&lt; rhs)
<a href=#47 id=47 data-nosnippet>47</a> }
<a href=#48 id=48 data-nosnippet>48</a> }
<a href=#49 id=49 data-nosnippet>49</a> <span class="kw">impl </span>ShlAssign&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#50 id=50 data-nosnippet>50</a> <span class="attr">#[inline]
<a href=#51 id=51 data-nosnippet>51</a> </span><span class="kw">fn </span>shl_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) {
<a href=#52 id=52 data-nosnippet>52</a> <span class="self">self</span>.data &lt;&lt;= rhs
<a href=#53 id=53 data-nosnippet>53</a> }
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a> <span class="macro">impl_shift!</span> { @<span class="kw-2">ref </span>Shl::shl, ShlAssign::shl_assign, <span class="macro-nonterminal">$rhs </span>}
<a href=#56 id=56 data-nosnippet>56</a>
<a href=#57 id=57 data-nosnippet>57</a> <span class="kw">impl </span>Shr&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">type </span>Output = BigInt;
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a> <span class="attr">#[inline]
<a href=#61 id=61 data-nosnippet>61</a> </span><span class="kw">fn </span>shr(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">let </span>round_down = shr_round_down(<span class="kw-2">&amp;</span><span class="self">self</span>, rhs);
<a href=#63 id=63 data-nosnippet>63</a> <span class="kw">let </span>data = <span class="self">self</span>.data &gt;&gt; rhs;
<a href=#64 id=64 data-nosnippet>64</a> <span class="kw">let </span>data = <span class="kw">if </span>round_down { data + <span class="number">1u8 </span>} <span class="kw">else </span>{ data };
<a href=#65 id=65 data-nosnippet>65</a> BigInt::from_biguint(<span class="self">self</span>.sign, data)
<a href=#66 id=66 data-nosnippet>66</a> }
<a href=#67 id=67 data-nosnippet>67</a> }
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">impl </span>Shr&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">type </span>Output = BigInt;
<a href=#70 id=70 data-nosnippet>70</a>
<a href=#71 id=71 data-nosnippet>71</a> <span class="attr">#[inline]
<a href=#72 id=72 data-nosnippet>72</a> </span><span class="kw">fn </span>shr(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigInt {
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">let </span>round_down = shr_round_down(<span class="self">self</span>, rhs);
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">let </span>data = <span class="kw-2">&amp;</span><span class="self">self</span>.data &gt;&gt; rhs;
<a href=#75 id=75 data-nosnippet>75</a> <span class="kw">let </span>data = <span class="kw">if </span>round_down { data + <span class="number">1u8 </span>} <span class="kw">else </span>{ data };
<a href=#76 id=76 data-nosnippet>76</a> BigInt::from_biguint(<span class="self">self</span>.sign, data)
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a> }
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">impl </span>ShrAssign&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigInt {
<a href=#80 id=80 data-nosnippet>80</a> <span class="attr">#[inline]
<a href=#81 id=81 data-nosnippet>81</a> </span><span class="kw">fn </span>shr_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) {
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">let </span>round_down = shr_round_down(<span class="self">self</span>, rhs);
<a href=#83 id=83 data-nosnippet>83</a> <span class="self">self</span>.data &gt;&gt;= rhs;
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">if </span>round_down {
<a href=#85 id=85 data-nosnippet>85</a> <span class="self">self</span>.data += <span class="number">1u8</span>;
<a href=#86 id=86 data-nosnippet>86</a> } <span class="kw">else if </span><span class="self">self</span>.data.is_zero() {
<a href=#87 id=87 data-nosnippet>87</a> <span class="self">self</span>.sign = NoSign;
<a href=#88 id=88 data-nosnippet>88</a> }
<a href=#89 id=89 data-nosnippet>89</a> }
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> <span class="macro">impl_shift!</span> { @<span class="kw-2">ref </span>Shr::shr, ShrAssign::shr_assign, <span class="macro-nonterminal">$rhs </span>}
<a href=#92 id=92 data-nosnippet>92</a> )<span class="kw-2">*</span>};
<a href=#93 id=93 data-nosnippet>93</a>}
<a href=#94 id=94 data-nosnippet>94</a>
<a href=#95 id=95 data-nosnippet>95</a><span class="macro">impl_shift!</span> { u8, u16, u32, u64, u128, usize }
<a href=#96 id=96 data-nosnippet>96</a><span class="macro">impl_shift!</span> { i8, i16, i32, i64, i128, isize }
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a><span class="comment">// Negative values need a rounding adjustment if there are any ones in the
<a href=#99 id=99 data-nosnippet>99</a>// bits that are getting shifted out.
<a href=#100 id=100 data-nosnippet>100</a></span><span class="kw">fn </span>shr_round_down&lt;T: PrimInt&gt;(i: <span class="kw-2">&amp;</span>BigInt, shift: T) -&gt; bool {
<a href=#101 id=101 data-nosnippet>101</a> <span class="kw">if </span>i.is_negative() {
<a href=#102 id=102 data-nosnippet>102</a> <span class="kw">let </span>zeros = i.trailing_zeros().expect(<span class="string">"negative values are non-zero"</span>);
<a href=#103 id=103 data-nosnippet>103</a> shift &gt; T::zero() &amp;&amp; shift.to_u64().map(|shift| zeros &lt; shift).unwrap_or(<span class="bool-val">true</span>)
<a href=#104 id=104 data-nosnippet>104</a> } <span class="kw">else </span>{
<a href=#105 id=105 data-nosnippet>105</a> <span class="bool-val">false
<a href=#106 id=106 data-nosnippet>106</a> </span>}
<a href=#107 id=107 data-nosnippet>107</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,301 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/bigint/subtraction.rs`."><title>subtraction.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/bigint/</div>subtraction.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::CheckedUnsignedAbs::{Negative, Positive};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::Sign::{Minus, NoSign, Plus};
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use super</span>::{BigInt, UnsignedAbs};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use crate</span>::{IsizePromotion, UsizePromotion};
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::mem;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::ops::{Sub, SubAssign};
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>num_traits::CheckedSub;
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a><span class="comment">// We want to forward to BigUint::sub, but it's not clear how that will go until
<a href=#13 id=13 data-nosnippet>13</a>// we compare both sign and magnitude. So we duplicate this body for every
<a href=#14 id=14 data-nosnippet>14</a>// val/ref combination, deferring that decision to BigUint's own forwarding.
<a href=#15 id=15 data-nosnippet>15</a></span><span class="macro">macro_rules!</span> bigint_sub {
<a href=#16 id=16 data-nosnippet>16</a> (<span class="macro-nonterminal">$a</span>:expr, <span class="macro-nonterminal">$a_owned</span>:expr, <span class="macro-nonterminal">$a_data</span>:expr, <span class="macro-nonterminal">$b</span>:expr, <span class="macro-nonterminal">$b_owned</span>:expr, <span class="macro-nonterminal">$b_data</span>:expr) =&gt; {
<a href=#17 id=17 data-nosnippet>17</a> <span class="kw">match </span>(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$b</span>.sign) {
<a href=#18 id=18 data-nosnippet>18</a> (<span class="kw">_</span>, NoSign) =&gt; <span class="macro-nonterminal">$a_owned</span>,
<a href=#19 id=19 data-nosnippet>19</a> (NoSign, <span class="kw">_</span>) =&gt; -<span class="macro-nonterminal">$b_owned</span>,
<a href=#20 id=20 data-nosnippet>20</a> <span class="comment">// opposite signs =&gt; keep the sign of the left with the sum of magnitudes
<a href=#21 id=21 data-nosnippet>21</a> </span>(Plus, Minus) | (Minus, Plus) =&gt; BigInt::from_biguint(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$a_data </span>+ <span class="macro-nonterminal">$b_data</span>),
<a href=#22 id=22 data-nosnippet>22</a> <span class="comment">// same sign =&gt; keep or toggle the sign of the left with the difference of magnitudes
<a href=#23 id=23 data-nosnippet>23</a> </span>(Plus, Plus) | (Minus, Minus) =&gt; <span class="kw">match </span><span class="macro-nonterminal">$a</span>.data.cmp(<span class="kw-2">&amp;</span><span class="macro-nonterminal">$b</span>.data) {
<a href=#24 id=24 data-nosnippet>24</a> Less =&gt; BigInt::from_biguint(-<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$b_data </span>- <span class="macro-nonterminal">$a_data</span>),
<a href=#25 id=25 data-nosnippet>25</a> Greater =&gt; BigInt::from_biguint(<span class="macro-nonterminal">$a</span>.sign, <span class="macro-nonterminal">$a_data </span>- <span class="macro-nonterminal">$b_data</span>),
<a href=#26 id=26 data-nosnippet>26</a> Equal =&gt; BigInt::ZERO,
<a href=#27 id=27 data-nosnippet>27</a> },
<a href=#28 id=28 data-nosnippet>28</a> }
<a href=#29 id=29 data-nosnippet>29</a> };
<a href=#30 id=30 data-nosnippet>30</a>}
<a href=#31 id=31 data-nosnippet>31</a>
<a href=#32 id=32 data-nosnippet>32</a><span class="kw">impl </span>Sub&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#33 id=33 data-nosnippet>33</a> <span class="kw">type </span>Output = BigInt;
<a href=#34 id=34 data-nosnippet>34</a>
<a href=#35 id=35 data-nosnippet>35</a> <span class="attr">#[inline]
<a href=#36 id=36 data-nosnippet>36</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#37 id=37 data-nosnippet>37</a> <span class="macro">bigint_sub!</span>(
<a href=#38 id=38 data-nosnippet>38</a> <span class="self">self</span>,
<a href=#39 id=39 data-nosnippet>39</a> <span class="self">self</span>.clone(),
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw-2">&amp;</span><span class="self">self</span>.data,
<a href=#41 id=41 data-nosnippet>41</a> other,
<a href=#42 id=42 data-nosnippet>42</a> other.clone(),
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw-2">&amp;</span>other.data
<a href=#44 id=44 data-nosnippet>44</a> )
<a href=#45 id=45 data-nosnippet>45</a> }
<a href=#46 id=46 data-nosnippet>46</a>}
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigInt {
<a href=#49 id=49 data-nosnippet>49</a> <span class="kw">type </span>Output = BigInt;
<a href=#50 id=50 data-nosnippet>50</a>
<a href=#51 id=51 data-nosnippet>51</a> <span class="attr">#[inline]
<a href=#52 id=52 data-nosnippet>52</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#53 id=53 data-nosnippet>53</a> <span class="macro">bigint_sub!</span>(<span class="self">self</span>, <span class="self">self</span>.clone(), <span class="kw-2">&amp;</span><span class="self">self</span>.data, other, other, other.data)
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a>}
<a href=#56 id=56 data-nosnippet>56</a>
<a href=#57 id=57 data-nosnippet>57</a><span class="kw">impl </span>Sub&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">type </span>Output = BigInt;
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a> <span class="attr">#[inline]
<a href=#61 id=61 data-nosnippet>61</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) -&gt; BigInt {
<a href=#62 id=62 data-nosnippet>62</a> <span class="macro">bigint_sub!</span>(<span class="self">self</span>, <span class="self">self</span>, <span class="self">self</span>.data, other, other.clone(), <span class="kw-2">&amp;</span>other.data)
<a href=#63 id=63 data-nosnippet>63</a> }
<a href=#64 id=64 data-nosnippet>64</a>}
<a href=#65 id=65 data-nosnippet>65</a>
<a href=#66 id=66 data-nosnippet>66</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#67 id=67 data-nosnippet>67</a> <span class="kw">type </span>Output = BigInt;
<a href=#68 id=68 data-nosnippet>68</a>
<a href=#69 id=69 data-nosnippet>69</a> <span class="attr">#[inline]
<a href=#70 id=70 data-nosnippet>70</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#71 id=71 data-nosnippet>71</a> <span class="macro">bigint_sub!</span>(<span class="self">self</span>, <span class="self">self</span>, <span class="self">self</span>.data, other, other, other.data)
<a href=#72 id=72 data-nosnippet>72</a> }
<a href=#73 id=73 data-nosnippet>73</a>}
<a href=#74 id=74 data-nosnippet>74</a>
<a href=#75 id=75 data-nosnippet>75</a><span class="kw">impl </span>SubAssign&lt;<span class="kw-2">&amp;</span>BigInt&gt; <span class="kw">for </span>BigInt {
<a href=#76 id=76 data-nosnippet>76</a> <span class="attr">#[inline]
<a href=#77 id=77 data-nosnippet>77</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigInt) {
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw-2">*</span><span class="self">self </span>= n - other;
<a href=#80 id=80 data-nosnippet>80</a> }
<a href=#81 id=81 data-nosnippet>81</a>}
<a href=#82 id=82 data-nosnippet>82</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>SubAssign <span class="kw">for </span>BigInt, sub_assign);
<a href=#83 id=83 data-nosnippet>83</a>
<a href=#84 id=84 data-nosnippet>84</a><span class="macro">promote_all_scalars!</span>(<span class="kw">impl </span>Sub <span class="kw">for </span>BigInt, sub);
<a href=#85 id=85 data-nosnippet>85</a><span class="macro">promote_all_scalars_assign!</span>(<span class="kw">impl </span>SubAssign <span class="kw">for </span>BigInt, sub_assign);
<a href=#86 id=86 data-nosnippet>86</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u32&gt; <span class="kw">for </span>BigInt, sub);
<a href=#87 id=87 data-nosnippet>87</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u64&gt; <span class="kw">for </span>BigInt, sub);
<a href=#88 id=88 data-nosnippet>88</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u128&gt; <span class="kw">for </span>BigInt, sub);
<a href=#89 id=89 data-nosnippet>89</a>
<a href=#90 id=90 data-nosnippet>90</a><span class="kw">impl </span>Sub&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#91 id=91 data-nosnippet>91</a> <span class="kw">type </span>Output = BigInt;
<a href=#92 id=92 data-nosnippet>92</a>
<a href=#93 id=93 data-nosnippet>93</a> <span class="attr">#[inline]
<a href=#94 id=94 data-nosnippet>94</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: u32) -&gt; BigInt {
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#96 id=96 data-nosnippet>96</a> NoSign =&gt; -BigInt::from(other),
<a href=#97 id=97 data-nosnippet>97</a> Minus =&gt; -BigInt::from(<span class="self">self</span>.data + other),
<a href=#98 id=98 data-nosnippet>98</a> Plus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#99 id=99 data-nosnippet>99</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#100 id=100 data-nosnippet>100</a> Greater =&gt; BigInt::from(<span class="self">self</span>.data - other),
<a href=#101 id=101 data-nosnippet>101</a> Less =&gt; -BigInt::from(other - <span class="self">self</span>.data),
<a href=#102 id=102 data-nosnippet>102</a> },
<a href=#103 id=103 data-nosnippet>103</a> }
<a href=#104 id=104 data-nosnippet>104</a> }
<a href=#105 id=105 data-nosnippet>105</a>}
<a href=#106 id=106 data-nosnippet>106</a><span class="kw">impl </span>SubAssign&lt;u32&gt; <span class="kw">for </span>BigInt {
<a href=#107 id=107 data-nosnippet>107</a> <span class="attr">#[inline]
<a href=#108 id=108 data-nosnippet>108</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#110 id=110 data-nosnippet>110</a> <span class="kw-2">*</span><span class="self">self </span>= n - other;
<a href=#111 id=111 data-nosnippet>111</a> }
<a href=#112 id=112 data-nosnippet>112</a>}
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>u32 {
<a href=#115 id=115 data-nosnippet>115</a> <span class="kw">type </span>Output = BigInt;
<a href=#116 id=116 data-nosnippet>116</a>
<a href=#117 id=117 data-nosnippet>117</a> <span class="attr">#[inline]
<a href=#118 id=118 data-nosnippet>118</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#119 id=119 data-nosnippet>119</a> -(other - <span class="self">self</span>)
<a href=#120 id=120 data-nosnippet>120</a> }
<a href=#121 id=121 data-nosnippet>121</a>}
<a href=#122 id=122 data-nosnippet>122</a>
<a href=#123 id=123 data-nosnippet>123</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>u64 {
<a href=#124 id=124 data-nosnippet>124</a> <span class="kw">type </span>Output = BigInt;
<a href=#125 id=125 data-nosnippet>125</a>
<a href=#126 id=126 data-nosnippet>126</a> <span class="attr">#[inline]
<a href=#127 id=127 data-nosnippet>127</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#128 id=128 data-nosnippet>128</a> -(other - <span class="self">self</span>)
<a href=#129 id=129 data-nosnippet>129</a> }
<a href=#130 id=130 data-nosnippet>130</a>}
<a href=#131 id=131 data-nosnippet>131</a>
<a href=#132 id=132 data-nosnippet>132</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>u128 {
<a href=#133 id=133 data-nosnippet>133</a> <span class="kw">type </span>Output = BigInt;
<a href=#134 id=134 data-nosnippet>134</a>
<a href=#135 id=135 data-nosnippet>135</a> <span class="attr">#[inline]
<a href=#136 id=136 data-nosnippet>136</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#137 id=137 data-nosnippet>137</a> -(other - <span class="self">self</span>)
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a>}
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a><span class="kw">impl </span>Sub&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">type </span>Output = BigInt;
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a> <span class="attr">#[inline]
<a href=#145 id=145 data-nosnippet>145</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: u64) -&gt; BigInt {
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#147 id=147 data-nosnippet>147</a> NoSign =&gt; -BigInt::from(other),
<a href=#148 id=148 data-nosnippet>148</a> Minus =&gt; -BigInt::from(<span class="self">self</span>.data + other),
<a href=#149 id=149 data-nosnippet>149</a> Plus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#150 id=150 data-nosnippet>150</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#151 id=151 data-nosnippet>151</a> Greater =&gt; BigInt::from(<span class="self">self</span>.data - other),
<a href=#152 id=152 data-nosnippet>152</a> Less =&gt; -BigInt::from(other - <span class="self">self</span>.data),
<a href=#153 id=153 data-nosnippet>153</a> },
<a href=#154 id=154 data-nosnippet>154</a> }
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a>}
<a href=#157 id=157 data-nosnippet>157</a>
<a href=#158 id=158 data-nosnippet>158</a><span class="kw">impl </span>SubAssign&lt;u64&gt; <span class="kw">for </span>BigInt {
<a href=#159 id=159 data-nosnippet>159</a> <span class="attr">#[inline]
<a href=#160 id=160 data-nosnippet>160</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw-2">*</span><span class="self">self </span>= n - other;
<a href=#163 id=163 data-nosnippet>163</a> }
<a href=#164 id=164 data-nosnippet>164</a>}
<a href=#165 id=165 data-nosnippet>165</a>
<a href=#166 id=166 data-nosnippet>166</a><span class="kw">impl </span>Sub&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#167 id=167 data-nosnippet>167</a> <span class="kw">type </span>Output = BigInt;
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a> <span class="attr">#[inline]
<a href=#170 id=170 data-nosnippet>170</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: u128) -&gt; BigInt {
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">match </span><span class="self">self</span>.sign {
<a href=#172 id=172 data-nosnippet>172</a> NoSign =&gt; -BigInt::from(other),
<a href=#173 id=173 data-nosnippet>173</a> Minus =&gt; -BigInt::from(<span class="self">self</span>.data + other),
<a href=#174 id=174 data-nosnippet>174</a> Plus =&gt; <span class="kw">match </span><span class="self">self</span>.data.cmp(<span class="kw-2">&amp;</span>From::from(other)) {
<a href=#175 id=175 data-nosnippet>175</a> Equal =&gt; <span class="self">Self</span>::ZERO,
<a href=#176 id=176 data-nosnippet>176</a> Greater =&gt; BigInt::from(<span class="self">self</span>.data - other),
<a href=#177 id=177 data-nosnippet>177</a> Less =&gt; -BigInt::from(other - <span class="self">self</span>.data),
<a href=#178 id=178 data-nosnippet>178</a> },
<a href=#179 id=179 data-nosnippet>179</a> }
<a href=#180 id=180 data-nosnippet>180</a> }
<a href=#181 id=181 data-nosnippet>181</a>}
<a href=#182 id=182 data-nosnippet>182</a>
<a href=#183 id=183 data-nosnippet>183</a><span class="kw">impl </span>SubAssign&lt;u128&gt; <span class="kw">for </span>BigInt {
<a href=#184 id=184 data-nosnippet>184</a> <span class="attr">#[inline]
<a href=#185 id=185 data-nosnippet>185</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#186 id=186 data-nosnippet>186</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#187 id=187 data-nosnippet>187</a> <span class="kw-2">*</span><span class="self">self </span>= n - other;
<a href=#188 id=188 data-nosnippet>188</a> }
<a href=#189 id=189 data-nosnippet>189</a>}
<a href=#190 id=190 data-nosnippet>190</a>
<a href=#191 id=191 data-nosnippet>191</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;i32&gt; <span class="kw">for </span>BigInt, sub);
<a href=#192 id=192 data-nosnippet>192</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;i64&gt; <span class="kw">for </span>BigInt, sub);
<a href=#193 id=193 data-nosnippet>193</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;i128&gt; <span class="kw">for </span>BigInt, sub);
<a href=#194 id=194 data-nosnippet>194</a>
<a href=#195 id=195 data-nosnippet>195</a><span class="kw">impl </span>Sub&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#196 id=196 data-nosnippet>196</a> <span class="kw">type </span>Output = BigInt;
<a href=#197 id=197 data-nosnippet>197</a>
<a href=#198 id=198 data-nosnippet>198</a> <span class="attr">#[inline]
<a href=#199 id=199 data-nosnippet>199</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: i32) -&gt; BigInt {
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#201 id=201 data-nosnippet>201</a> Positive(u) =&gt; <span class="self">self </span>- u,
<a href=#202 id=202 data-nosnippet>202</a> Negative(u) =&gt; <span class="self">self </span>+ u,
<a href=#203 id=203 data-nosnippet>203</a> }
<a href=#204 id=204 data-nosnippet>204</a> }
<a href=#205 id=205 data-nosnippet>205</a>}
<a href=#206 id=206 data-nosnippet>206</a><span class="kw">impl </span>SubAssign&lt;i32&gt; <span class="kw">for </span>BigInt {
<a href=#207 id=207 data-nosnippet>207</a> <span class="attr">#[inline]
<a href=#208 id=208 data-nosnippet>208</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i32) {
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#210 id=210 data-nosnippet>210</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#211 id=211 data-nosnippet>211</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#212 id=212 data-nosnippet>212</a> }
<a href=#213 id=213 data-nosnippet>213</a> }
<a href=#214 id=214 data-nosnippet>214</a>}
<a href=#215 id=215 data-nosnippet>215</a>
<a href=#216 id=216 data-nosnippet>216</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>i32 {
<a href=#217 id=217 data-nosnippet>217</a> <span class="kw">type </span>Output = BigInt;
<a href=#218 id=218 data-nosnippet>218</a>
<a href=#219 id=219 data-nosnippet>219</a> <span class="attr">#[inline]
<a href=#220 id=220 data-nosnippet>220</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#221 id=221 data-nosnippet>221</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#222 id=222 data-nosnippet>222</a> Positive(u) =&gt; u - other,
<a href=#223 id=223 data-nosnippet>223</a> Negative(u) =&gt; -other - u,
<a href=#224 id=224 data-nosnippet>224</a> }
<a href=#225 id=225 data-nosnippet>225</a> }
<a href=#226 id=226 data-nosnippet>226</a>}
<a href=#227 id=227 data-nosnippet>227</a>
<a href=#228 id=228 data-nosnippet>228</a><span class="kw">impl </span>Sub&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#229 id=229 data-nosnippet>229</a> <span class="kw">type </span>Output = BigInt;
<a href=#230 id=230 data-nosnippet>230</a>
<a href=#231 id=231 data-nosnippet>231</a> <span class="attr">#[inline]
<a href=#232 id=232 data-nosnippet>232</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: i64) -&gt; BigInt {
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#234 id=234 data-nosnippet>234</a> Positive(u) =&gt; <span class="self">self </span>- u,
<a href=#235 id=235 data-nosnippet>235</a> Negative(u) =&gt; <span class="self">self </span>+ u,
<a href=#236 id=236 data-nosnippet>236</a> }
<a href=#237 id=237 data-nosnippet>237</a> }
<a href=#238 id=238 data-nosnippet>238</a>}
<a href=#239 id=239 data-nosnippet>239</a><span class="kw">impl </span>SubAssign&lt;i64&gt; <span class="kw">for </span>BigInt {
<a href=#240 id=240 data-nosnippet>240</a> <span class="attr">#[inline]
<a href=#241 id=241 data-nosnippet>241</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i64) {
<a href=#242 id=242 data-nosnippet>242</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#243 id=243 data-nosnippet>243</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#244 id=244 data-nosnippet>244</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#245 id=245 data-nosnippet>245</a> }
<a href=#246 id=246 data-nosnippet>246</a> }
<a href=#247 id=247 data-nosnippet>247</a>}
<a href=#248 id=248 data-nosnippet>248</a>
<a href=#249 id=249 data-nosnippet>249</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>i64 {
<a href=#250 id=250 data-nosnippet>250</a> <span class="kw">type </span>Output = BigInt;
<a href=#251 id=251 data-nosnippet>251</a>
<a href=#252 id=252 data-nosnippet>252</a> <span class="attr">#[inline]
<a href=#253 id=253 data-nosnippet>253</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#254 id=254 data-nosnippet>254</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#255 id=255 data-nosnippet>255</a> Positive(u) =&gt; u - other,
<a href=#256 id=256 data-nosnippet>256</a> Negative(u) =&gt; -other - u,
<a href=#257 id=257 data-nosnippet>257</a> }
<a href=#258 id=258 data-nosnippet>258</a> }
<a href=#259 id=259 data-nosnippet>259</a>}
<a href=#260 id=260 data-nosnippet>260</a>
<a href=#261 id=261 data-nosnippet>261</a><span class="kw">impl </span>Sub&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#262 id=262 data-nosnippet>262</a> <span class="kw">type </span>Output = BigInt;
<a href=#263 id=263 data-nosnippet>263</a>
<a href=#264 id=264 data-nosnippet>264</a> <span class="attr">#[inline]
<a href=#265 id=265 data-nosnippet>265</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: i128) -&gt; BigInt {
<a href=#266 id=266 data-nosnippet>266</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#267 id=267 data-nosnippet>267</a> Positive(u) =&gt; <span class="self">self </span>- u,
<a href=#268 id=268 data-nosnippet>268</a> Negative(u) =&gt; <span class="self">self </span>+ u,
<a href=#269 id=269 data-nosnippet>269</a> }
<a href=#270 id=270 data-nosnippet>270</a> }
<a href=#271 id=271 data-nosnippet>271</a>}
<a href=#272 id=272 data-nosnippet>272</a>
<a href=#273 id=273 data-nosnippet>273</a><span class="kw">impl </span>SubAssign&lt;i128&gt; <span class="kw">for </span>BigInt {
<a href=#274 id=274 data-nosnippet>274</a> <span class="attr">#[inline]
<a href=#275 id=275 data-nosnippet>275</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: i128) {
<a href=#276 id=276 data-nosnippet>276</a> <span class="kw">match </span>other.checked_uabs() {
<a href=#277 id=277 data-nosnippet>277</a> Positive(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>-= u,
<a href=#278 id=278 data-nosnippet>278</a> Negative(u) =&gt; <span class="kw-2">*</span><span class="self">self </span>+= u,
<a href=#279 id=279 data-nosnippet>279</a> }
<a href=#280 id=280 data-nosnippet>280</a> }
<a href=#281 id=281 data-nosnippet>281</a>}
<a href=#282 id=282 data-nosnippet>282</a>
<a href=#283 id=283 data-nosnippet>283</a><span class="kw">impl </span>Sub&lt;BigInt&gt; <span class="kw">for </span>i128 {
<a href=#284 id=284 data-nosnippet>284</a> <span class="kw">type </span>Output = BigInt;
<a href=#285 id=285 data-nosnippet>285</a>
<a href=#286 id=286 data-nosnippet>286</a> <span class="attr">#[inline]
<a href=#287 id=287 data-nosnippet>287</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, other: BigInt) -&gt; BigInt {
<a href=#288 id=288 data-nosnippet>288</a> <span class="kw">match </span><span class="self">self</span>.checked_uabs() {
<a href=#289 id=289 data-nosnippet>289</a> Positive(u) =&gt; u - other,
<a href=#290 id=290 data-nosnippet>290</a> Negative(u) =&gt; -other - u,
<a href=#291 id=291 data-nosnippet>291</a> }
<a href=#292 id=292 data-nosnippet>292</a> }
<a href=#293 id=293 data-nosnippet>293</a>}
<a href=#294 id=294 data-nosnippet>294</a>
<a href=#295 id=295 data-nosnippet>295</a><span class="kw">impl </span>CheckedSub <span class="kw">for </span>BigInt {
<a href=#296 id=296 data-nosnippet>296</a> <span class="attr">#[inline]
<a href=#297 id=297 data-nosnippet>297</a> </span><span class="kw">fn </span>checked_sub(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigInt) -&gt; <span class="prelude-ty">Option</span>&lt;BigInt&gt; {
<a href=#298 id=298 data-nosnippet>298</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.sub(v))
<a href=#299 id=299 data-nosnippet>299</a> }
<a href=#300 id=300 data-nosnippet>300</a>}
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,257 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/addition.rs`."><title>addition.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>addition.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use super</span>::{BigUint, IntDigits};
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit};
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::UsizePromotion;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>core::iter::Sum;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::ops::{Add, AddAssign};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>num_traits::CheckedAdd;
<a href=#9 id=9 data-nosnippet>9</a>
<a href=#10 id=10 data-nosnippet>10</a><span class="attr">#[cfg(target_arch = <span class="string">"x86_64"</span>)]
<a href=#11 id=11 data-nosnippet>11</a></span><span class="kw">use </span>core::arch::x86_64 <span class="kw">as </span>arch;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="attr">#[cfg(target_arch = <span class="string">"x86"</span>)]
<a href=#14 id=14 data-nosnippet>14</a></span><span class="kw">use </span>core::arch::x86 <span class="kw">as </span>arch;
<a href=#15 id=15 data-nosnippet>15</a>
<a href=#16 id=16 data-nosnippet>16</a><span class="comment">// Add with carry:
<a href=#17 id=17 data-nosnippet>17</a></span><span class="attr">#[cfg(target_arch = <span class="string">"x86_64"</span>)]
<a href=#18 id=18 data-nosnippet>18</a></span><span class="macro">cfg_64!</span>(
<a href=#19 id=19 data-nosnippet>19</a> <span class="attr">#[inline]
<a href=#20 id=20 data-nosnippet>20</a> </span><span class="kw">fn </span>adc(carry: u8, a: u64, b: u64, out: <span class="kw-2">&amp;mut </span>u64) -&gt; u8 {
<a href=#21 id=21 data-nosnippet>21</a> <span class="comment">// Safety: There are absolutely no safety concerns with calling `_addcarry_u64`.
<a href=#22 id=22 data-nosnippet>22</a> // It's just unsafe for API consistency with other intrinsics.
<a href=#23 id=23 data-nosnippet>23</a> </span><span class="kw">unsafe </span>{ arch::_addcarry_u64(carry, a, b, out) }
<a href=#24 id=24 data-nosnippet>24</a> }
<a href=#25 id=25 data-nosnippet>25</a>);
<a href=#26 id=26 data-nosnippet>26</a>
<a href=#27 id=27 data-nosnippet>27</a><span class="attr">#[cfg(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>))]
<a href=#28 id=28 data-nosnippet>28</a></span><span class="macro">cfg_32!</span>(
<a href=#29 id=29 data-nosnippet>29</a> <span class="attr">#[inline]
<a href=#30 id=30 data-nosnippet>30</a> </span><span class="kw">fn </span>adc(carry: u8, a: u32, b: u32, out: <span class="kw-2">&amp;mut </span>u32) -&gt; u8 {
<a href=#31 id=31 data-nosnippet>31</a> <span class="comment">// Safety: There are absolutely no safety concerns with calling `_addcarry_u32`.
<a href=#32 id=32 data-nosnippet>32</a> // It's just unsafe for API consistency with other intrinsics.
<a href=#33 id=33 data-nosnippet>33</a> </span><span class="kw">unsafe </span>{ arch::_addcarry_u32(carry, a, b, out) }
<a href=#34 id=34 data-nosnippet>34</a> }
<a href=#35 id=35 data-nosnippet>35</a>);
<a href=#36 id=36 data-nosnippet>36</a>
<a href=#37 id=37 data-nosnippet>37</a><span class="comment">// fallback for environments where we don't have an addcarry intrinsic
<a href=#38 id=38 data-nosnippet>38</a>// (copied from the standard library's `carrying_add`)
<a href=#39 id=39 data-nosnippet>39</a></span><span class="attr">#[cfg(not(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>)))]
<a href=#40 id=40 data-nosnippet>40</a>#[inline]
<a href=#41 id=41 data-nosnippet>41</a></span><span class="kw">fn </span>adc(carry: u8, lhs: BigDigit, rhs: BigDigit, out: <span class="kw-2">&amp;mut </span>BigDigit) -&gt; u8 {
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">let </span>(a, b) = lhs.overflowing_add(rhs);
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">let </span>(c, d) = a.overflowing_add(carry <span class="kw">as </span>BigDigit);
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw-2">*</span>out = c;
<a href=#45 id=45 data-nosnippet>45</a> u8::from(b || d)
<a href=#46 id=46 data-nosnippet>46</a>}
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a><span class="doccomment">/// Two argument addition of raw slices, `a += b`, returning the carry.
<a href=#49 id=49 data-nosnippet>49</a>///
<a href=#50 id=50 data-nosnippet>50</a>/// This is used when the data `Vec` might need to resize to push a non-zero carry, so we perform
<a href=#51 id=51 data-nosnippet>51</a>/// the addition first hoping that it will fit.
<a href=#52 id=52 data-nosnippet>52</a>///
<a href=#53 id=53 data-nosnippet>53</a>/// The caller _must_ ensure that `a` is at least as long as `b`.
<a href=#54 id=54 data-nosnippet>54</a></span><span class="attr">#[inline]
<a href=#55 id=55 data-nosnippet>55</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>__add2(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; BigDigit {
<a href=#56 id=56 data-nosnippet>56</a> <span class="macro">debug_assert!</span>(a.len() &gt;= b.len());
<a href=#57 id=57 data-nosnippet>57</a>
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="number">0</span>;
<a href=#59 id=59 data-nosnippet>59</a> <span class="kw">let </span>(a_lo, a_hi) = a.split_at_mut(b.len());
<a href=#60 id=60 data-nosnippet>60</a>
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw">for </span>(a, b) <span class="kw">in </span>a_lo.iter_mut().zip(b) {
<a href=#62 id=62 data-nosnippet>62</a> carry = adc(carry, <span class="kw-2">*</span>a, <span class="kw-2">*</span>b, a);
<a href=#63 id=63 data-nosnippet>63</a> }
<a href=#64 id=64 data-nosnippet>64</a>
<a href=#65 id=65 data-nosnippet>65</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#66 id=66 data-nosnippet>66</a> <span class="kw">for </span>a <span class="kw">in </span>a_hi {
<a href=#67 id=67 data-nosnippet>67</a> carry = adc(carry, <span class="kw-2">*</span>a, <span class="number">0</span>, a);
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">if </span>carry == <span class="number">0 </span>{
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">break</span>;
<a href=#70 id=70 data-nosnippet>70</a> }
<a href=#71 id=71 data-nosnippet>71</a> }
<a href=#72 id=72 data-nosnippet>72</a> }
<a href=#73 id=73 data-nosnippet>73</a>
<a href=#74 id=74 data-nosnippet>74</a> carry <span class="kw">as </span>BigDigit
<a href=#75 id=75 data-nosnippet>75</a>}
<a href=#76 id=76 data-nosnippet>76</a>
<a href=#77 id=77 data-nosnippet>77</a><span class="doccomment">/// Two argument addition of raw slices:
<a href=#78 id=78 data-nosnippet>78</a>/// a += b
<a href=#79 id=79 data-nosnippet>79</a>///
<a href=#80 id=80 data-nosnippet>80</a>/// The caller _must_ ensure that a is big enough to store the result - typically this means
<a href=#81 id=81 data-nosnippet>81</a>/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry.
<a href=#82 id=82 data-nosnippet>82</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>add2(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">let </span>carry = __add2(a, b);
<a href=#84 id=84 data-nosnippet>84</a>
<a href=#85 id=85 data-nosnippet>85</a> <span class="macro">debug_assert!</span>(carry == <span class="number">0</span>);
<a href=#86 id=86 data-nosnippet>86</a>}
<a href=#87 id=87 data-nosnippet>87</a>
<a href=#88 id=88 data-nosnippet>88</a><span class="macro">forward_all_binop_to_val_ref_commutative!</span>(<span class="kw">impl </span>Add <span class="kw">for </span>BigUint, add);
<a href=#89 id=89 data-nosnippet>89</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>AddAssign <span class="kw">for </span>BigUint, add_assign);
<a href=#90 id=90 data-nosnippet>90</a>
<a href=#91 id=91 data-nosnippet>91</a><span class="kw">impl </span>Add&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">type </span>Output = BigUint;
<a href=#93 id=93 data-nosnippet>93</a>
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">fn </span>add(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#95 id=95 data-nosnippet>95</a> <span class="self">self </span>+= other;
<a href=#96 id=96 data-nosnippet>96</a> <span class="self">self
<a href=#97 id=97 data-nosnippet>97</a> </span>}
<a href=#98 id=98 data-nosnippet>98</a>}
<a href=#99 id=99 data-nosnippet>99</a><span class="kw">impl </span>AddAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#100 id=100 data-nosnippet>100</a> <span class="attr">#[inline]
<a href=#101 id=101 data-nosnippet>101</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#102 id=102 data-nosnippet>102</a> <span class="kw">let </span>self_len = <span class="self">self</span>.data.len();
<a href=#103 id=103 data-nosnippet>103</a> <span class="kw">let </span>carry = <span class="kw">if </span>self_len &lt; other.data.len() {
<a href=#104 id=104 data-nosnippet>104</a> <span class="kw">let </span>lo_carry = __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>other.data[..self_len]);
<a href=#105 id=105 data-nosnippet>105</a> <span class="self">self</span>.data.extend_from_slice(<span class="kw-2">&amp;</span>other.data[self_len..]);
<a href=#106 id=106 data-nosnippet>106</a> __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[self_len..], <span class="kw-2">&amp;</span>[lo_carry])
<a href=#107 id=107 data-nosnippet>107</a> } <span class="kw">else </span>{
<a href=#108 id=108 data-nosnippet>108</a> __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>other.data[..])
<a href=#109 id=109 data-nosnippet>109</a> };
<a href=#110 id=110 data-nosnippet>110</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#111 id=111 data-nosnippet>111</a> <span class="self">self</span>.data.push(carry);
<a href=#112 id=112 data-nosnippet>112</a> }
<a href=#113 id=113 data-nosnippet>113</a> }
<a href=#114 id=114 data-nosnippet>114</a>}
<a href=#115 id=115 data-nosnippet>115</a>
<a href=#116 id=116 data-nosnippet>116</a><span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span>Add <span class="kw">for </span>BigUint, add);
<a href=#117 id=117 data-nosnippet>117</a><span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span>AddAssign <span class="kw">for </span>BigUint, add_assign);
<a href=#118 id=118 data-nosnippet>118</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u32&gt; <span class="kw">for </span>BigUint, add);
<a href=#119 id=119 data-nosnippet>119</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u64&gt; <span class="kw">for </span>BigUint, add);
<a href=#120 id=120 data-nosnippet>120</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Add&lt;u128&gt; <span class="kw">for </span>BigUint, add);
<a href=#121 id=121 data-nosnippet>121</a>
<a href=#122 id=122 data-nosnippet>122</a><span class="kw">impl </span>Add&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">type </span>Output = BigUint;
<a href=#124 id=124 data-nosnippet>124</a>
<a href=#125 id=125 data-nosnippet>125</a> <span class="attr">#[inline]
<a href=#126 id=126 data-nosnippet>126</a> </span><span class="kw">fn </span>add(<span class="kw-2">mut </span><span class="self">self</span>, other: u32) -&gt; BigUint {
<a href=#127 id=127 data-nosnippet>127</a> <span class="self">self </span>+= other;
<a href=#128 id=128 data-nosnippet>128</a> <span class="self">self
<a href=#129 id=129 data-nosnippet>129</a> </span>}
<a href=#130 id=130 data-nosnippet>130</a>}
<a href=#131 id=131 data-nosnippet>131</a>
<a href=#132 id=132 data-nosnippet>132</a><span class="kw">impl </span>AddAssign&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#133 id=133 data-nosnippet>133</a> <span class="attr">#[inline]
<a href=#134 id=134 data-nosnippet>134</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#135 id=135 data-nosnippet>135</a> <span class="kw">if </span><span class="macro">other !</span>= <span class="number">0 </span>{
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">if </span><span class="self">self</span>.data.is_empty() {
<a href=#137 id=137 data-nosnippet>137</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a>
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span>carry = __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[other <span class="kw">as </span>BigDigit]);
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#142 id=142 data-nosnippet>142</a> <span class="self">self</span>.data.push(carry);
<a href=#143 id=143 data-nosnippet>143</a> }
<a href=#144 id=144 data-nosnippet>144</a> }
<a href=#145 id=145 data-nosnippet>145</a> }
<a href=#146 id=146 data-nosnippet>146</a>}
<a href=#147 id=147 data-nosnippet>147</a>
<a href=#148 id=148 data-nosnippet>148</a><span class="kw">impl </span>Add&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#149 id=149 data-nosnippet>149</a> <span class="kw">type </span>Output = BigUint;
<a href=#150 id=150 data-nosnippet>150</a>
<a href=#151 id=151 data-nosnippet>151</a> <span class="attr">#[inline]
<a href=#152 id=152 data-nosnippet>152</a> </span><span class="kw">fn </span>add(<span class="kw-2">mut </span><span class="self">self</span>, other: u64) -&gt; BigUint {
<a href=#153 id=153 data-nosnippet>153</a> <span class="self">self </span>+= other;
<a href=#154 id=154 data-nosnippet>154</a> <span class="self">self
<a href=#155 id=155 data-nosnippet>155</a> </span>}
<a href=#156 id=156 data-nosnippet>156</a>}
<a href=#157 id=157 data-nosnippet>157</a>
<a href=#158 id=158 data-nosnippet>158</a><span class="kw">impl </span>AddAssign&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#159 id=159 data-nosnippet>159</a> <span class="macro">cfg_digit!</span>(
<a href=#160 id=160 data-nosnippet>160</a> <span class="attr">#[inline]
<a href=#161 id=161 data-nosnippet>161</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#163 id=163 data-nosnippet>163</a> <span class="kw">if </span>hi == <span class="number">0 </span>{
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw-2">*</span><span class="self">self </span>+= lo;
<a href=#165 id=165 data-nosnippet>165</a> } <span class="kw">else </span>{
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">while </span><span class="self">self</span>.data.len() &lt; <span class="number">2 </span>{
<a href=#167 id=167 data-nosnippet>167</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#168 id=168 data-nosnippet>168</a> }
<a href=#169 id=169 data-nosnippet>169</a>
<a href=#170 id=170 data-nosnippet>170</a> <span class="kw">let </span>carry = __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#172 id=172 data-nosnippet>172</a> <span class="self">self</span>.data.push(carry);
<a href=#173 id=173 data-nosnippet>173</a> }
<a href=#174 id=174 data-nosnippet>174</a> }
<a href=#175 id=175 data-nosnippet>175</a> }
<a href=#176 id=176 data-nosnippet>176</a>
<a href=#177 id=177 data-nosnippet>177</a> <span class="attr">#[inline]
<a href=#178 id=178 data-nosnippet>178</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#179 id=179 data-nosnippet>179</a> <span class="kw">if </span><span class="macro">other !</span>= <span class="number">0 </span>{
<a href=#180 id=180 data-nosnippet>180</a> <span class="kw">if </span><span class="self">self</span>.data.is_empty() {
<a href=#181 id=181 data-nosnippet>181</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#182 id=182 data-nosnippet>182</a> }
<a href=#183 id=183 data-nosnippet>183</a>
<a href=#184 id=184 data-nosnippet>184</a> <span class="kw">let </span>carry = __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[other <span class="kw">as </span>BigDigit]);
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#186 id=186 data-nosnippet>186</a> <span class="self">self</span>.data.push(carry);
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a> }
<a href=#189 id=189 data-nosnippet>189</a> }
<a href=#190 id=190 data-nosnippet>190</a> );
<a href=#191 id=191 data-nosnippet>191</a>}
<a href=#192 id=192 data-nosnippet>192</a>
<a href=#193 id=193 data-nosnippet>193</a><span class="kw">impl </span>Add&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#194 id=194 data-nosnippet>194</a> <span class="kw">type </span>Output = BigUint;
<a href=#195 id=195 data-nosnippet>195</a>
<a href=#196 id=196 data-nosnippet>196</a> <span class="attr">#[inline]
<a href=#197 id=197 data-nosnippet>197</a> </span><span class="kw">fn </span>add(<span class="kw-2">mut </span><span class="self">self</span>, other: u128) -&gt; BigUint {
<a href=#198 id=198 data-nosnippet>198</a> <span class="self">self </span>+= other;
<a href=#199 id=199 data-nosnippet>199</a> <span class="self">self
<a href=#200 id=200 data-nosnippet>200</a> </span>}
<a href=#201 id=201 data-nosnippet>201</a>}
<a href=#202 id=202 data-nosnippet>202</a>
<a href=#203 id=203 data-nosnippet>203</a><span class="kw">impl </span>AddAssign&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#204 id=204 data-nosnippet>204</a> <span class="macro">cfg_digit!</span>(
<a href=#205 id=205 data-nosnippet>205</a> <span class="attr">#[inline]
<a href=#206 id=206 data-nosnippet>206</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#207 id=207 data-nosnippet>207</a> <span class="kw">if </span>other &lt;= u128::from(u64::MAX) {
<a href=#208 id=208 data-nosnippet>208</a> <span class="kw-2">*</span><span class="self">self </span>+= other <span class="kw">as </span>u64
<a href=#209 id=209 data-nosnippet>209</a> } <span class="kw">else </span>{
<a href=#210 id=210 data-nosnippet>210</a> <span class="kw">let </span>(a, b, c, d) = <span class="kw">super</span>::u32_from_u128(other);
<a href=#211 id=211 data-nosnippet>211</a> <span class="kw">let </span>carry = <span class="kw">if </span>a &gt; <span class="number">0 </span>{
<a href=#212 id=212 data-nosnippet>212</a> <span class="kw">while </span><span class="self">self</span>.data.len() &lt; <span class="number">4 </span>{
<a href=#213 id=213 data-nosnippet>213</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#214 id=214 data-nosnippet>214</a> }
<a href=#215 id=215 data-nosnippet>215</a> __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[d, c, b, a])
<a href=#216 id=216 data-nosnippet>216</a> } <span class="kw">else </span>{
<a href=#217 id=217 data-nosnippet>217</a> <span class="macro">debug_assert!</span>(b &gt; <span class="number">0</span>);
<a href=#218 id=218 data-nosnippet>218</a> <span class="kw">while </span><span class="self">self</span>.data.len() &lt; <span class="number">3 </span>{
<a href=#219 id=219 data-nosnippet>219</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#220 id=220 data-nosnippet>220</a> }
<a href=#221 id=221 data-nosnippet>221</a> __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[d, c, b])
<a href=#222 id=222 data-nosnippet>222</a> };
<a href=#223 id=223 data-nosnippet>223</a>
<a href=#224 id=224 data-nosnippet>224</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#225 id=225 data-nosnippet>225</a> <span class="self">self</span>.data.push(carry);
<a href=#226 id=226 data-nosnippet>226</a> }
<a href=#227 id=227 data-nosnippet>227</a> }
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a>
<a href=#230 id=230 data-nosnippet>230</a> <span class="attr">#[inline]
<a href=#231 id=231 data-nosnippet>231</a> </span><span class="kw">fn </span>add_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#232 id=232 data-nosnippet>232</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">if </span>hi == <span class="number">0 </span>{
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw-2">*</span><span class="self">self </span>+= lo;
<a href=#235 id=235 data-nosnippet>235</a> } <span class="kw">else </span>{
<a href=#236 id=236 data-nosnippet>236</a> <span class="kw">while </span><span class="self">self</span>.data.len() &lt; <span class="number">2 </span>{
<a href=#237 id=237 data-nosnippet>237</a> <span class="self">self</span>.data.push(<span class="number">0</span>);
<a href=#238 id=238 data-nosnippet>238</a> }
<a href=#239 id=239 data-nosnippet>239</a>
<a href=#240 id=240 data-nosnippet>240</a> <span class="kw">let </span>carry = __add2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#241 id=241 data-nosnippet>241</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#242 id=242 data-nosnippet>242</a> <span class="self">self</span>.data.push(carry);
<a href=#243 id=243 data-nosnippet>243</a> }
<a href=#244 id=244 data-nosnippet>244</a> }
<a href=#245 id=245 data-nosnippet>245</a> }
<a href=#246 id=246 data-nosnippet>246</a> );
<a href=#247 id=247 data-nosnippet>247</a>}
<a href=#248 id=248 data-nosnippet>248</a>
<a href=#249 id=249 data-nosnippet>249</a><span class="kw">impl </span>CheckedAdd <span class="kw">for </span>BigUint {
<a href=#250 id=250 data-nosnippet>250</a> <span class="attr">#[inline]
<a href=#251 id=251 data-nosnippet>251</a> </span><span class="kw">fn </span>checked_add(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#252 id=252 data-nosnippet>252</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.add(v))
<a href=#253 id=253 data-nosnippet>253</a> }
<a href=#254 id=254 data-nosnippet>254</a>}
<a href=#255 id=255 data-nosnippet>255</a>
<a href=#256 id=256 data-nosnippet>256</a><span class="macro">impl_sum_iter_type!</span>(BigUint);
</code></pre></div></section></main></body></html>
@@ -0,0 +1,94 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/bits.rs`."><title>bits.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>bits.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-2"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use super</span>::{BigUint, IntDigits};
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use </span>core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span>BitAnd <span class="kw">for </span>BigUint, bitand);
<a href=#6 id=6 data-nosnippet>6</a><span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span>BitAnd <span class="kw">for </span>BigUint, bitand);
<a href=#7 id=7 data-nosnippet>7</a>
<a href=#8 id=8 data-nosnippet>8</a><span class="comment">// do not use forward_ref_ref_binop_commutative! for bitand so that we can
<a href=#9 id=9 data-nosnippet>9</a>// clone the smaller value rather than the larger, avoiding over-allocation
<a href=#10 id=10 data-nosnippet>10</a></span><span class="kw">impl </span>BitAnd&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#11 id=11 data-nosnippet>11</a> <span class="kw">type </span>Output = BigUint;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a> <span class="attr">#[inline]
<a href=#14 id=14 data-nosnippet>14</a> </span><span class="kw">fn </span>bitand(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#15 id=15 data-nosnippet>15</a> <span class="comment">// forward to val-ref, choosing the smaller to clone
<a href=#16 id=16 data-nosnippet>16</a> </span><span class="kw">if </span><span class="self">self</span>.data.len() &lt;= other.data.len() {
<a href=#17 id=17 data-nosnippet>17</a> <span class="self">self</span>.clone() &amp; other
<a href=#18 id=18 data-nosnippet>18</a> } <span class="kw">else </span>{
<a href=#19 id=19 data-nosnippet>19</a> other.clone() &amp; <span class="self">self
<a href=#20 id=20 data-nosnippet>20</a> </span>}
<a href=#21 id=21 data-nosnippet>21</a> }
<a href=#22 id=22 data-nosnippet>22</a>}
<a href=#23 id=23 data-nosnippet>23</a>
<a href=#24 id=24 data-nosnippet>24</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitAndAssign <span class="kw">for </span>BigUint, bitand_assign);
<a href=#25 id=25 data-nosnippet>25</a>
<a href=#26 id=26 data-nosnippet>26</a><span class="kw">impl </span>BitAnd&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#27 id=27 data-nosnippet>27</a> <span class="kw">type </span>Output = BigUint;
<a href=#28 id=28 data-nosnippet>28</a>
<a href=#29 id=29 data-nosnippet>29</a> <span class="attr">#[inline]
<a href=#30 id=30 data-nosnippet>30</a> </span><span class="kw">fn </span>bitand(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#31 id=31 data-nosnippet>31</a> <span class="self">self </span>&amp;= other;
<a href=#32 id=32 data-nosnippet>32</a> <span class="self">self
<a href=#33 id=33 data-nosnippet>33</a> </span>}
<a href=#34 id=34 data-nosnippet>34</a>}
<a href=#35 id=35 data-nosnippet>35</a><span class="kw">impl </span>BitAndAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#36 id=36 data-nosnippet>36</a> <span class="attr">#[inline]
<a href=#37 id=37 data-nosnippet>37</a> </span><span class="kw">fn </span>bitand_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span><span class="self">self</span>.data.iter_mut().zip(other.data.iter()) {
<a href=#39 id=39 data-nosnippet>39</a> <span class="kw-2">*</span>ai &amp;= bi;
<a href=#40 id=40 data-nosnippet>40</a> }
<a href=#41 id=41 data-nosnippet>41</a> <span class="self">self</span>.data.truncate(other.data.len());
<a href=#42 id=42 data-nosnippet>42</a> <span class="self">self</span>.normalize();
<a href=#43 id=43 data-nosnippet>43</a> }
<a href=#44 id=44 data-nosnippet>44</a>}
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a><span class="macro">forward_all_binop_to_val_ref_commutative!</span>(<span class="kw">impl </span>BitOr <span class="kw">for </span>BigUint, bitor);
<a href=#47 id=47 data-nosnippet>47</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitOrAssign <span class="kw">for </span>BigUint, bitor_assign);
<a href=#48 id=48 data-nosnippet>48</a>
<a href=#49 id=49 data-nosnippet>49</a><span class="kw">impl </span>BitOr&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">type </span>Output = BigUint;
<a href=#51 id=51 data-nosnippet>51</a>
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">fn </span>bitor(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#53 id=53 data-nosnippet>53</a> <span class="self">self </span>|= other;
<a href=#54 id=54 data-nosnippet>54</a> <span class="self">self
<a href=#55 id=55 data-nosnippet>55</a> </span>}
<a href=#56 id=56 data-nosnippet>56</a>}
<a href=#57 id=57 data-nosnippet>57</a><span class="kw">impl </span>BitOrAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#58 id=58 data-nosnippet>58</a> <span class="attr">#[inline]
<a href=#59 id=59 data-nosnippet>59</a> </span><span class="kw">fn </span>bitor_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#60 id=60 data-nosnippet>60</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span><span class="self">self</span>.data.iter_mut().zip(other.data.iter()) {
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw-2">*</span>ai |= bi;
<a href=#62 id=62 data-nosnippet>62</a> }
<a href=#63 id=63 data-nosnippet>63</a> <span class="kw">if </span>other.data.len() &gt; <span class="self">self</span>.data.len() {
<a href=#64 id=64 data-nosnippet>64</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>other.data[<span class="self">self</span>.data.len()..];
<a href=#65 id=65 data-nosnippet>65</a> <span class="self">self</span>.data.extend(extra.iter().cloned());
<a href=#66 id=66 data-nosnippet>66</a> }
<a href=#67 id=67 data-nosnippet>67</a> }
<a href=#68 id=68 data-nosnippet>68</a>}
<a href=#69 id=69 data-nosnippet>69</a>
<a href=#70 id=70 data-nosnippet>70</a><span class="macro">forward_all_binop_to_val_ref_commutative!</span>(<span class="kw">impl </span>BitXor <span class="kw">for </span>BigUint, bitxor);
<a href=#71 id=71 data-nosnippet>71</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>BitXorAssign <span class="kw">for </span>BigUint, bitxor_assign);
<a href=#72 id=72 data-nosnippet>72</a>
<a href=#73 id=73 data-nosnippet>73</a><span class="kw">impl </span>BitXor&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">type </span>Output = BigUint;
<a href=#75 id=75 data-nosnippet>75</a>
<a href=#76 id=76 data-nosnippet>76</a> <span class="kw">fn </span>bitxor(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#77 id=77 data-nosnippet>77</a> <span class="self">self </span>^= other;
<a href=#78 id=78 data-nosnippet>78</a> <span class="self">self
<a href=#79 id=79 data-nosnippet>79</a> </span>}
<a href=#80 id=80 data-nosnippet>80</a>}
<a href=#81 id=81 data-nosnippet>81</a><span class="kw">impl </span>BitXorAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#82 id=82 data-nosnippet>82</a> <span class="attr">#[inline]
<a href=#83 id=83 data-nosnippet>83</a> </span><span class="kw">fn </span>bitxor_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">for </span>(ai, <span class="kw-2">&amp;</span>bi) <span class="kw">in </span><span class="self">self</span>.data.iter_mut().zip(other.data.iter()) {
<a href=#85 id=85 data-nosnippet>85</a> <span class="kw-2">*</span>ai ^= bi;
<a href=#86 id=86 data-nosnippet>86</a> }
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw">if </span>other.data.len() &gt; <span class="self">self</span>.data.len() {
<a href=#88 id=88 data-nosnippet>88</a> <span class="kw">let </span>extra = <span class="kw-2">&amp;</span>other.data[<span class="self">self</span>.data.len()..];
<a href=#89 id=89 data-nosnippet>89</a> <span class="self">self</span>.data.extend(extra.iter().cloned());
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> <span class="self">self</span>.normalize();
<a href=#92 id=92 data-nosnippet>92</a> }
<a href=#93 id=93 data-nosnippet>93</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,867 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/convert.rs`."><title>convert.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>convert.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="comment">// This uses stdlib features higher than the MSRV
<a href=#2 id=2 data-nosnippet>2</a></span><span class="attr">#![allow(clippy::manual_range_contains)] </span><span class="comment">// 1.35
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">use super</span>::{biguint_from_vec, BigUint, ToBigUint};
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">super</span>::addition::add2;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">super</span>::division::{div_rem_digit, FAST_DIV_WIDE};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">super</span>::multiplication::mac_with_carry;
<a href=#9 id=9 data-nosnippet>9</a>
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit};
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span><span class="kw">crate</span>::ParseBigIntError;
<a href=#12 id=12 data-nosnippet>12</a><span class="kw">use </span><span class="kw">crate</span>::TryFromBigIntError;
<a href=#13 id=13 data-nosnippet>13</a>
<a href=#14 id=14 data-nosnippet>14</a><span class="kw">use </span>alloc::vec::Vec;
<a href=#15 id=15 data-nosnippet>15</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#16 id=16 data-nosnippet>16</a><span class="kw">use </span>core::convert::TryFrom;
<a href=#17 id=17 data-nosnippet>17</a><span class="kw">use </span>core::mem;
<a href=#18 id=18 data-nosnippet>18</a><span class="kw">use </span>core::str::FromStr;
<a href=#19 id=19 data-nosnippet>19</a><span class="kw">use </span>num_integer::{Integer, Roots};
<a href=#20 id=20 data-nosnippet>20</a><span class="kw">use </span>num_traits::float::FloatCore;
<a href=#21 id=21 data-nosnippet>21</a><span class="kw">use </span>num_traits::{FromPrimitive, Num, One, PrimInt, ToPrimitive, Zero};
<a href=#22 id=22 data-nosnippet>22</a>
<a href=#23 id=23 data-nosnippet>23</a><span class="doccomment">/// Find last set bit
<a href=#24 id=24 data-nosnippet>24</a>/// fls(0) == 0, fls(u32::MAX) == 32
<a href=#25 id=25 data-nosnippet>25</a></span><span class="kw">fn </span>fls&lt;T: PrimInt&gt;(v: T) -&gt; u8 {
<a href=#26 id=26 data-nosnippet>26</a> mem::size_of::&lt;T&gt;() <span class="kw">as </span>u8 * <span class="number">8 </span>- v.leading_zeros() <span class="kw">as </span>u8
<a href=#27 id=27 data-nosnippet>27</a>}
<a href=#28 id=28 data-nosnippet>28</a>
<a href=#29 id=29 data-nosnippet>29</a><span class="kw">fn </span>ilog2&lt;T: PrimInt&gt;(v: T) -&gt; u8 {
<a href=#30 id=30 data-nosnippet>30</a> fls(v) - <span class="number">1
<a href=#31 id=31 data-nosnippet>31</a></span>}
<a href=#32 id=32 data-nosnippet>32</a>
<a href=#33 id=33 data-nosnippet>33</a><span class="kw">impl </span>FromStr <span class="kw">for </span>BigUint {
<a href=#34 id=34 data-nosnippet>34</a> <span class="kw">type </span><span class="prelude-val">Err </span>= ParseBigIntError;
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a> <span class="attr">#[inline]
<a href=#37 id=37 data-nosnippet>37</a> </span><span class="kw">fn </span>from_str(s: <span class="kw-2">&amp;</span>str) -&gt; <span class="prelude-ty">Result</span>&lt;BigUint, ParseBigIntError&gt; {
<a href=#38 id=38 data-nosnippet>38</a> BigUint::from_str_radix(s, <span class="number">10</span>)
<a href=#39 id=39 data-nosnippet>39</a> }
<a href=#40 id=40 data-nosnippet>40</a>}
<a href=#41 id=41 data-nosnippet>41</a>
<a href=#42 id=42 data-nosnippet>42</a><span class="comment">// Convert from a power of two radix (bits == ilog2(radix)) where bits evenly divides
<a href=#43 id=43 data-nosnippet>43</a>// BigDigit::BITS
<a href=#44 id=44 data-nosnippet>44</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>from_bitwise_digits_le(v: <span class="kw-2">&amp;</span>[u8], bits: u8) -&gt; BigUint {
<a href=#45 id=45 data-nosnippet>45</a> <span class="macro">debug_assert!</span>(!v.is_empty() &amp;&amp; bits &lt;= <span class="number">8 </span>&amp;&amp; big_digit::BITS % bits == <span class="number">0</span>);
<a href=#46 id=46 data-nosnippet>46</a> <span class="macro">debug_assert!</span>(v.iter().all(|<span class="kw-2">&amp;</span>c| BigDigit::from(c) &lt; (<span class="number">1 </span>&lt;&lt; bits)));
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a> <span class="kw">let </span>digits_per_big_digit = big_digit::BITS / bits;
<a href=#49 id=49 data-nosnippet>49</a>
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">let </span>data = v
<a href=#51 id=51 data-nosnippet>51</a> .chunks(digits_per_big_digit.into())
<a href=#52 id=52 data-nosnippet>52</a> .map(|chunk| {
<a href=#53 id=53 data-nosnippet>53</a> chunk
<a href=#54 id=54 data-nosnippet>54</a> .iter()
<a href=#55 id=55 data-nosnippet>55</a> .rev()
<a href=#56 id=56 data-nosnippet>56</a> .fold(<span class="number">0</span>, |acc, <span class="kw-2">&amp;</span>c| (acc &lt;&lt; bits) | BigDigit::from(c))
<a href=#57 id=57 data-nosnippet>57</a> })
<a href=#58 id=58 data-nosnippet>58</a> .collect();
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a> biguint_from_vec(data)
<a href=#61 id=61 data-nosnippet>61</a>}
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a><span class="comment">// Convert from a power of two radix (bits == ilog2(radix)) where bits doesn't evenly divide
<a href=#64 id=64 data-nosnippet>64</a>// BigDigit::BITS
<a href=#65 id=65 data-nosnippet>65</a></span><span class="kw">fn </span>from_inexact_bitwise_digits_le(v: <span class="kw-2">&amp;</span>[u8], bits: u8) -&gt; BigUint {
<a href=#66 id=66 data-nosnippet>66</a> <span class="macro">debug_assert!</span>(!v.is_empty() &amp;&amp; bits &lt;= <span class="number">8 </span>&amp;&amp; big_digit::BITS % <span class="macro">bits !</span>= <span class="number">0</span>);
<a href=#67 id=67 data-nosnippet>67</a> <span class="macro">debug_assert!</span>(v.iter().all(|<span class="kw-2">&amp;</span>c| BigDigit::from(c) &lt; (<span class="number">1 </span>&lt;&lt; bits)));
<a href=#68 id=68 data-nosnippet>68</a>
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">let </span>total_bits = (v.len() <span class="kw">as </span>u64).saturating_mul(bits.into());
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">let </span>big_digits = Integer::div_ceil(<span class="kw-2">&amp;</span>total_bits, <span class="kw-2">&amp;</span>big_digit::BITS.into())
<a href=#71 id=71 data-nosnippet>71</a> .to_usize()
<a href=#72 id=72 data-nosnippet>72</a> .unwrap_or(usize::MAX);
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">let </span><span class="kw-2">mut </span>data = Vec::with_capacity(big_digits);
<a href=#74 id=74 data-nosnippet>74</a>
<a href=#75 id=75 data-nosnippet>75</a> <span class="kw">let </span><span class="kw-2">mut </span>d = <span class="number">0</span>;
<a href=#76 id=76 data-nosnippet>76</a> <span class="kw">let </span><span class="kw-2">mut </span>dbits = <span class="number">0</span>; <span class="comment">// number of bits we currently have in d
<a href=#77 id=77 data-nosnippet>77</a>
<a href=#78 id=78 data-nosnippet>78</a> // walk v accumululating bits in d; whenever we accumulate big_digit::BITS in d, spit out a
<a href=#79 id=79 data-nosnippet>79</a> // big_digit:
<a href=#80 id=80 data-nosnippet>80</a> </span><span class="kw">for </span><span class="kw-2">&amp;</span>c <span class="kw">in </span>v {
<a href=#81 id=81 data-nosnippet>81</a> d |= BigDigit::from(c) &lt;&lt; dbits;
<a href=#82 id=82 data-nosnippet>82</a> dbits += bits;
<a href=#83 id=83 data-nosnippet>83</a>
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">if </span>dbits &gt;= big_digit::BITS {
<a href=#85 id=85 data-nosnippet>85</a> data.push(d);
<a href=#86 id=86 data-nosnippet>86</a> dbits -= big_digit::BITS;
<a href=#87 id=87 data-nosnippet>87</a> <span class="comment">// if dbits was &gt; big_digit::BITS, we dropped some of the bits in c (they couldn't fit
<a href=#88 id=88 data-nosnippet>88</a> // in d) - grab the bits we lost here:
<a href=#89 id=89 data-nosnippet>89</a> </span>d = BigDigit::from(c) &gt;&gt; (bits - dbits);
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> }
<a href=#92 id=92 data-nosnippet>92</a>
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">if </span>dbits &gt; <span class="number">0 </span>{
<a href=#94 id=94 data-nosnippet>94</a> <span class="macro">debug_assert!</span>(dbits &lt; big_digit::BITS);
<a href=#95 id=95 data-nosnippet>95</a> data.push(d <span class="kw">as </span>BigDigit);
<a href=#96 id=96 data-nosnippet>96</a> }
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a> biguint_from_vec(data)
<a href=#99 id=99 data-nosnippet>99</a>}
<a href=#100 id=100 data-nosnippet>100</a>
<a href=#101 id=101 data-nosnippet>101</a><span class="comment">// Read little-endian radix digits
<a href=#102 id=102 data-nosnippet>102</a></span><span class="kw">fn </span>from_radix_digits_be(v: <span class="kw-2">&amp;</span>[u8], radix: u32) -&gt; BigUint {
<a href=#103 id=103 data-nosnippet>103</a> <span class="macro">debug_assert!</span>(!v.is_empty() &amp;&amp; !radix.is_power_of_two());
<a href=#104 id=104 data-nosnippet>104</a> <span class="macro">debug_assert!</span>(v.iter().all(|<span class="kw-2">&amp;</span>c| u32::from(c) &lt; radix));
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a> <span class="comment">// Estimate how big the result will be, so we can pre-allocate it.
<a href=#107 id=107 data-nosnippet>107</a> </span><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#108 id=108 data-nosnippet>108</a> </span><span class="kw">let </span>big_digits = {
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">let </span>radix_log2 = f64::from(radix).log2();
<a href=#110 id=110 data-nosnippet>110</a> <span class="kw">let </span>bits = radix_log2 * v.len() <span class="kw">as </span>f64;
<a href=#111 id=111 data-nosnippet>111</a> (bits / big_digit::BITS <span class="kw">as </span>f64).ceil()
<a href=#112 id=112 data-nosnippet>112</a> };
<a href=#113 id=113 data-nosnippet>113</a> <span class="attr">#[cfg(not(feature = <span class="string">"std"</span>))]
<a href=#114 id=114 data-nosnippet>114</a> </span><span class="kw">let </span>big_digits = {
<a href=#115 id=115 data-nosnippet>115</a> <span class="kw">let </span>radix_log2 = ilog2(radix.next_power_of_two()) <span class="kw">as </span>usize;
<a href=#116 id=116 data-nosnippet>116</a> <span class="kw">let </span>bits = radix_log2 * v.len();
<a href=#117 id=117 data-nosnippet>117</a> (bits / big_digit::BITS <span class="kw">as </span>usize) + <span class="number">1
<a href=#118 id=118 data-nosnippet>118</a> </span>};
<a href=#119 id=119 data-nosnippet>119</a>
<a href=#120 id=120 data-nosnippet>120</a> <span class="kw">let </span><span class="kw-2">mut </span>data = Vec::with_capacity(big_digits.to_usize().unwrap_or(<span class="number">0</span>));
<a href=#121 id=121 data-nosnippet>121</a>
<a href=#122 id=122 data-nosnippet>122</a> <span class="kw">let </span>(base, power) = get_radix_base(radix);
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">let </span>radix = radix <span class="kw">as </span>BigDigit;
<a href=#124 id=124 data-nosnippet>124</a>
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">let </span>r = v.len() % power;
<a href=#126 id=126 data-nosnippet>126</a> <span class="kw">let </span>i = <span class="kw">if </span>r == <span class="number">0 </span>{ power } <span class="kw">else </span>{ r };
<a href=#127 id=127 data-nosnippet>127</a> <span class="kw">let </span>(head, tail) = v.split_at(i);
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a> <span class="kw">let </span>first = head
<a href=#130 id=130 data-nosnippet>130</a> .iter()
<a href=#131 id=131 data-nosnippet>131</a> .fold(<span class="number">0</span>, |acc, <span class="kw-2">&amp;</span>d| acc * radix + BigDigit::from(d));
<a href=#132 id=132 data-nosnippet>132</a> data.push(first);
<a href=#133 id=133 data-nosnippet>133</a>
<a href=#134 id=134 data-nosnippet>134</a> <span class="macro">debug_assert!</span>(tail.len() % power == <span class="number">0</span>);
<a href=#135 id=135 data-nosnippet>135</a> <span class="kw">for </span>chunk <span class="kw">in </span>tail.chunks(power) {
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">if </span>data.last() != <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) {
<a href=#137 id=137 data-nosnippet>137</a> data.push(<span class="number">0</span>);
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a>
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="number">0</span>;
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">for </span>d <span class="kw">in </span>data.iter_mut() {
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw-2">*</span>d = mac_with_carry(<span class="number">0</span>, <span class="kw-2">*</span>d, base, <span class="kw-2">&amp;mut </span>carry);
<a href=#143 id=143 data-nosnippet>143</a> }
<a href=#144 id=144 data-nosnippet>144</a> <span class="macro">debug_assert!</span>(carry == <span class="number">0</span>);
<a href=#145 id=145 data-nosnippet>145</a>
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">let </span>n = chunk
<a href=#147 id=147 data-nosnippet>147</a> .iter()
<a href=#148 id=148 data-nosnippet>148</a> .fold(<span class="number">0</span>, |acc, <span class="kw-2">&amp;</span>d| acc * radix + BigDigit::from(d));
<a href=#149 id=149 data-nosnippet>149</a> add2(<span class="kw-2">&amp;mut </span>data, <span class="kw-2">&amp;</span>[n]);
<a href=#150 id=150 data-nosnippet>150</a> }
<a href=#151 id=151 data-nosnippet>151</a>
<a href=#152 id=152 data-nosnippet>152</a> biguint_from_vec(data)
<a href=#153 id=153 data-nosnippet>153</a>}
<a href=#154 id=154 data-nosnippet>154</a>
<a href=#155 id=155 data-nosnippet>155</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>from_radix_be(buf: <span class="kw-2">&amp;</span>[u8], radix: u32) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#156 id=156 data-nosnippet>156</a> <span class="macro">assert!</span>(
<a href=#157 id=157 data-nosnippet>157</a> <span class="number">2 </span>&lt;= radix &amp;&amp; radix &lt;= <span class="number">256</span>,
<a href=#158 id=158 data-nosnippet>158</a> <span class="string">"The radix must be within 2...256"
<a href=#159 id=159 data-nosnippet>159</a> </span>);
<a href=#160 id=160 data-nosnippet>160</a>
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">if </span>buf.is_empty() {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">return </span><span class="prelude-val">Some</span>(BigUint::ZERO);
<a href=#163 id=163 data-nosnippet>163</a> }
<a href=#164 id=164 data-nosnippet>164</a>
<a href=#165 id=165 data-nosnippet>165</a> <span class="kw">if </span><span class="macro">radix !</span>= <span class="number">256 </span>&amp;&amp; buf.iter().any(|<span class="kw-2">&amp;</span>b| b &gt;= radix <span class="kw">as </span>u8) {
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#167 id=167 data-nosnippet>167</a> }
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">let </span>res = <span class="kw">if </span>radix.is_power_of_two() {
<a href=#170 id=170 data-nosnippet>170</a> <span class="comment">// Powers of two can use bitwise masks and shifting instead of multiplication
<a href=#171 id=171 data-nosnippet>171</a> </span><span class="kw">let </span>bits = ilog2(radix);
<a href=#172 id=172 data-nosnippet>172</a> <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::from(buf);
<a href=#173 id=173 data-nosnippet>173</a> v.reverse();
<a href=#174 id=174 data-nosnippet>174</a> <span class="kw">if </span>big_digit::BITS % bits == <span class="number">0 </span>{
<a href=#175 id=175 data-nosnippet>175</a> from_bitwise_digits_le(<span class="kw-2">&amp;</span>v, bits)
<a href=#176 id=176 data-nosnippet>176</a> } <span class="kw">else </span>{
<a href=#177 id=177 data-nosnippet>177</a> from_inexact_bitwise_digits_le(<span class="kw-2">&amp;</span>v, bits)
<a href=#178 id=178 data-nosnippet>178</a> }
<a href=#179 id=179 data-nosnippet>179</a> } <span class="kw">else </span>{
<a href=#180 id=180 data-nosnippet>180</a> from_radix_digits_be(buf, radix)
<a href=#181 id=181 data-nosnippet>181</a> };
<a href=#182 id=182 data-nosnippet>182</a>
<a href=#183 id=183 data-nosnippet>183</a> <span class="prelude-val">Some</span>(res)
<a href=#184 id=184 data-nosnippet>184</a>}
<a href=#185 id=185 data-nosnippet>185</a>
<a href=#186 id=186 data-nosnippet>186</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>from_radix_le(buf: <span class="kw-2">&amp;</span>[u8], radix: u32) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#187 id=187 data-nosnippet>187</a> <span class="macro">assert!</span>(
<a href=#188 id=188 data-nosnippet>188</a> <span class="number">2 </span>&lt;= radix &amp;&amp; radix &lt;= <span class="number">256</span>,
<a href=#189 id=189 data-nosnippet>189</a> <span class="string">"The radix must be within 2...256"
<a href=#190 id=190 data-nosnippet>190</a> </span>);
<a href=#191 id=191 data-nosnippet>191</a>
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">if </span>buf.is_empty() {
<a href=#193 id=193 data-nosnippet>193</a> <span class="kw">return </span><span class="prelude-val">Some</span>(BigUint::ZERO);
<a href=#194 id=194 data-nosnippet>194</a> }
<a href=#195 id=195 data-nosnippet>195</a>
<a href=#196 id=196 data-nosnippet>196</a> <span class="kw">if </span><span class="macro">radix !</span>= <span class="number">256 </span>&amp;&amp; buf.iter().any(|<span class="kw-2">&amp;</span>b| b &gt;= radix <span class="kw">as </span>u8) {
<a href=#197 id=197 data-nosnippet>197</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#198 id=198 data-nosnippet>198</a> }
<a href=#199 id=199 data-nosnippet>199</a>
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">let </span>res = <span class="kw">if </span>radix.is_power_of_two() {
<a href=#201 id=201 data-nosnippet>201</a> <span class="comment">// Powers of two can use bitwise masks and shifting instead of multiplication
<a href=#202 id=202 data-nosnippet>202</a> </span><span class="kw">let </span>bits = ilog2(radix);
<a href=#203 id=203 data-nosnippet>203</a> <span class="kw">if </span>big_digit::BITS % bits == <span class="number">0 </span>{
<a href=#204 id=204 data-nosnippet>204</a> from_bitwise_digits_le(buf, bits)
<a href=#205 id=205 data-nosnippet>205</a> } <span class="kw">else </span>{
<a href=#206 id=206 data-nosnippet>206</a> from_inexact_bitwise_digits_le(buf, bits)
<a href=#207 id=207 data-nosnippet>207</a> }
<a href=#208 id=208 data-nosnippet>208</a> } <span class="kw">else </span>{
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::from(buf);
<a href=#210 id=210 data-nosnippet>210</a> v.reverse();
<a href=#211 id=211 data-nosnippet>211</a> from_radix_digits_be(<span class="kw-2">&amp;</span>v, radix)
<a href=#212 id=212 data-nosnippet>212</a> };
<a href=#213 id=213 data-nosnippet>213</a>
<a href=#214 id=214 data-nosnippet>214</a> <span class="prelude-val">Some</span>(res)
<a href=#215 id=215 data-nosnippet>215</a>}
<a href=#216 id=216 data-nosnippet>216</a>
<a href=#217 id=217 data-nosnippet>217</a><span class="kw">impl </span>Num <span class="kw">for </span>BigUint {
<a href=#218 id=218 data-nosnippet>218</a> <span class="kw">type </span>FromStrRadixErr = ParseBigIntError;
<a href=#219 id=219 data-nosnippet>219</a>
<a href=#220 id=220 data-nosnippet>220</a> <span class="doccomment">/// Creates and initializes a `BigUint`.
<a href=#221 id=221 data-nosnippet>221</a> </span><span class="kw">fn </span>from_str_radix(s: <span class="kw-2">&amp;</span>str, radix: u32) -&gt; <span class="prelude-ty">Result</span>&lt;BigUint, ParseBigIntError&gt; {
<a href=#222 id=222 data-nosnippet>222</a> <span class="macro">assert!</span>(<span class="number">2 </span>&lt;= radix &amp;&amp; radix &lt;= <span class="number">36</span>, <span class="string">"The radix must be within 2...36"</span>);
<a href=#223 id=223 data-nosnippet>223</a> <span class="kw">let </span><span class="kw-2">mut </span>s = s;
<a href=#224 id=224 data-nosnippet>224</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(tail) = s.strip_prefix(<span class="string">'+'</span>) {
<a href=#225 id=225 data-nosnippet>225</a> <span class="kw">if </span>!tail.starts_with(<span class="string">'+'</span>) {
<a href=#226 id=226 data-nosnippet>226</a> s = tail
<a href=#227 id=227 data-nosnippet>227</a> }
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a>
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">if </span>s.is_empty() {
<a href=#231 id=231 data-nosnippet>231</a> <span class="kw">return </span><span class="prelude-val">Err</span>(ParseBigIntError::empty());
<a href=#232 id=232 data-nosnippet>232</a> }
<a href=#233 id=233 data-nosnippet>233</a>
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw">if </span>s.starts_with(<span class="string">'_'</span>) {
<a href=#235 id=235 data-nosnippet>235</a> <span class="comment">// Must lead with a real digit!
<a href=#236 id=236 data-nosnippet>236</a> </span><span class="kw">return </span><span class="prelude-val">Err</span>(ParseBigIntError::invalid());
<a href=#237 id=237 data-nosnippet>237</a> }
<a href=#238 id=238 data-nosnippet>238</a>
<a href=#239 id=239 data-nosnippet>239</a> <span class="comment">// First normalize all characters to plain digit values
<a href=#240 id=240 data-nosnippet>240</a> </span><span class="kw">let </span><span class="kw-2">mut </span>v = Vec::with_capacity(s.len());
<a href=#241 id=241 data-nosnippet>241</a> <span class="kw">for </span>b <span class="kw">in </span>s.bytes() {
<a href=#242 id=242 data-nosnippet>242</a> <span class="kw">let </span>d = <span class="kw">match </span>b {
<a href=#243 id=243 data-nosnippet>243</a> <span class="string">b'0'</span>..=<span class="string">b'9' </span>=&gt; b - <span class="string">b'0'</span>,
<a href=#244 id=244 data-nosnippet>244</a> <span class="string">b'a'</span>..=<span class="string">b'z' </span>=&gt; b - <span class="string">b'a' </span>+ <span class="number">10</span>,
<a href=#245 id=245 data-nosnippet>245</a> <span class="string">b'A'</span>..=<span class="string">b'Z' </span>=&gt; b - <span class="string">b'A' </span>+ <span class="number">10</span>,
<a href=#246 id=246 data-nosnippet>246</a> <span class="string">b'_' </span>=&gt; <span class="kw">continue</span>,
<a href=#247 id=247 data-nosnippet>247</a> <span class="kw">_ </span>=&gt; u8::MAX,
<a href=#248 id=248 data-nosnippet>248</a> };
<a href=#249 id=249 data-nosnippet>249</a> <span class="kw">if </span>d &lt; radix <span class="kw">as </span>u8 {
<a href=#250 id=250 data-nosnippet>250</a> v.push(d);
<a href=#251 id=251 data-nosnippet>251</a> } <span class="kw">else </span>{
<a href=#252 id=252 data-nosnippet>252</a> <span class="kw">return </span><span class="prelude-val">Err</span>(ParseBigIntError::invalid());
<a href=#253 id=253 data-nosnippet>253</a> }
<a href=#254 id=254 data-nosnippet>254</a> }
<a href=#255 id=255 data-nosnippet>255</a>
<a href=#256 id=256 data-nosnippet>256</a> <span class="kw">let </span>res = <span class="kw">if </span>radix.is_power_of_two() {
<a href=#257 id=257 data-nosnippet>257</a> <span class="comment">// Powers of two can use bitwise masks and shifting instead of multiplication
<a href=#258 id=258 data-nosnippet>258</a> </span><span class="kw">let </span>bits = ilog2(radix);
<a href=#259 id=259 data-nosnippet>259</a> v.reverse();
<a href=#260 id=260 data-nosnippet>260</a> <span class="kw">if </span>big_digit::BITS % bits == <span class="number">0 </span>{
<a href=#261 id=261 data-nosnippet>261</a> from_bitwise_digits_le(<span class="kw-2">&amp;</span>v, bits)
<a href=#262 id=262 data-nosnippet>262</a> } <span class="kw">else </span>{
<a href=#263 id=263 data-nosnippet>263</a> from_inexact_bitwise_digits_le(<span class="kw-2">&amp;</span>v, bits)
<a href=#264 id=264 data-nosnippet>264</a> }
<a href=#265 id=265 data-nosnippet>265</a> } <span class="kw">else </span>{
<a href=#266 id=266 data-nosnippet>266</a> from_radix_digits_be(<span class="kw-2">&amp;</span>v, radix)
<a href=#267 id=267 data-nosnippet>267</a> };
<a href=#268 id=268 data-nosnippet>268</a> <span class="prelude-val">Ok</span>(res)
<a href=#269 id=269 data-nosnippet>269</a> }
<a href=#270 id=270 data-nosnippet>270</a>}
<a href=#271 id=271 data-nosnippet>271</a>
<a href=#272 id=272 data-nosnippet>272</a><span class="kw">fn </span>high_bits_to_u64(v: <span class="kw-2">&amp;</span>BigUint) -&gt; u64 {
<a href=#273 id=273 data-nosnippet>273</a> <span class="kw">match </span>v.data.len() {
<a href=#274 id=274 data-nosnippet>274</a> <span class="number">0 </span>=&gt; <span class="number">0</span>,
<a href=#275 id=275 data-nosnippet>275</a> <span class="number">1 </span>=&gt; {
<a href=#276 id=276 data-nosnippet>276</a> <span class="comment">// XXX Conversion is useless if already 64-bit.
<a href=#277 id=277 data-nosnippet>277</a> </span><span class="attr">#[allow(clippy::useless_conversion)]
<a href=#278 id=278 data-nosnippet>278</a> </span><span class="kw">let </span>v0 = u64::from(v.data[<span class="number">0</span>]);
<a href=#279 id=279 data-nosnippet>279</a> v0
<a href=#280 id=280 data-nosnippet>280</a> }
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">_ </span>=&gt; {
<a href=#282 id=282 data-nosnippet>282</a> <span class="kw">let </span><span class="kw-2">mut </span>bits = v.bits();
<a href=#283 id=283 data-nosnippet>283</a> <span class="kw">let </span><span class="kw-2">mut </span>ret = <span class="number">0u64</span>;
<a href=#284 id=284 data-nosnippet>284</a> <span class="kw">let </span><span class="kw-2">mut </span>ret_bits = <span class="number">0</span>;
<a href=#285 id=285 data-nosnippet>285</a>
<a href=#286 id=286 data-nosnippet>286</a> <span class="kw">for </span>d <span class="kw">in </span>v.data.iter().rev() {
<a href=#287 id=287 data-nosnippet>287</a> <span class="kw">let </span>digit_bits = (bits - <span class="number">1</span>) % u64::from(big_digit::BITS) + <span class="number">1</span>;
<a href=#288 id=288 data-nosnippet>288</a> <span class="kw">let </span>bits_want = Ord::min(<span class="number">64 </span>- ret_bits, digit_bits);
<a href=#289 id=289 data-nosnippet>289</a>
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">if </span><span class="macro">bits_want !</span>= <span class="number">0 </span>{
<a href=#291 id=291 data-nosnippet>291</a> <span class="kw">if </span><span class="macro">bits_want !</span>= <span class="number">64 </span>{
<a href=#292 id=292 data-nosnippet>292</a> ret &lt;&lt;= bits_want;
<a href=#293 id=293 data-nosnippet>293</a> }
<a href=#294 id=294 data-nosnippet>294</a> <span class="comment">// XXX Conversion is useless if already 64-bit.
<a href=#295 id=295 data-nosnippet>295</a> </span><span class="attr">#[allow(clippy::useless_conversion)]
<a href=#296 id=296 data-nosnippet>296</a> </span><span class="kw">let </span>d0 = u64::from(<span class="kw-2">*</span>d) &gt;&gt; (digit_bits - bits_want);
<a href=#297 id=297 data-nosnippet>297</a> ret |= d0;
<a href=#298 id=298 data-nosnippet>298</a> }
<a href=#299 id=299 data-nosnippet>299</a>
<a href=#300 id=300 data-nosnippet>300</a> <span class="comment">// Implement round-to-odd: If any lower bits are 1, set LSB to 1
<a href=#301 id=301 data-nosnippet>301</a> // so that rounding again to floating point value using
<a href=#302 id=302 data-nosnippet>302</a> // nearest-ties-to-even is correct.
<a href=#303 id=303 data-nosnippet>303</a> //
<a href=#304 id=304 data-nosnippet>304</a> // See: https://en.wikipedia.org/wiki/Rounding#Rounding_to_prepare_for_shorter_precision
<a href=#305 id=305 data-nosnippet>305</a>
<a href=#306 id=306 data-nosnippet>306</a> </span><span class="kw">if </span>digit_bits - <span class="macro">bits_want !</span>= <span class="number">0 </span>{
<a href=#307 id=307 data-nosnippet>307</a> <span class="comment">// XXX Conversion is useless if already 64-bit.
<a href=#308 id=308 data-nosnippet>308</a> </span><span class="attr">#[allow(clippy::useless_conversion)]
<a href=#309 id=309 data-nosnippet>309</a> </span><span class="kw">let </span>masked = u64::from(<span class="kw-2">*</span>d) &lt;&lt; (<span class="number">64 </span>- (digit_bits - bits_want) <span class="kw">as </span>u32);
<a href=#310 id=310 data-nosnippet>310</a> ret |= (<span class="macro">masked !</span>= <span class="number">0</span>) <span class="kw">as </span>u64;
<a href=#311 id=311 data-nosnippet>311</a> }
<a href=#312 id=312 data-nosnippet>312</a>
<a href=#313 id=313 data-nosnippet>313</a> ret_bits += bits_want;
<a href=#314 id=314 data-nosnippet>314</a> bits -= bits_want;
<a href=#315 id=315 data-nosnippet>315</a> }
<a href=#316 id=316 data-nosnippet>316</a>
<a href=#317 id=317 data-nosnippet>317</a> ret
<a href=#318 id=318 data-nosnippet>318</a> }
<a href=#319 id=319 data-nosnippet>319</a> }
<a href=#320 id=320 data-nosnippet>320</a>}
<a href=#321 id=321 data-nosnippet>321</a>
<a href=#322 id=322 data-nosnippet>322</a><span class="kw">impl </span>ToPrimitive <span class="kw">for </span>BigUint {
<a href=#323 id=323 data-nosnippet>323</a> <span class="attr">#[inline]
<a href=#324 id=324 data-nosnippet>324</a> </span><span class="kw">fn </span>to_i64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;i64&gt; {
<a href=#325 id=325 data-nosnippet>325</a> <span class="self">self</span>.to_u64().as_ref().and_then(u64::to_i64)
<a href=#326 id=326 data-nosnippet>326</a> }
<a href=#327 id=327 data-nosnippet>327</a>
<a href=#328 id=328 data-nosnippet>328</a> <span class="attr">#[inline]
<a href=#329 id=329 data-nosnippet>329</a> </span><span class="kw">fn </span>to_i128(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;i128&gt; {
<a href=#330 id=330 data-nosnippet>330</a> <span class="self">self</span>.to_u128().as_ref().and_then(u128::to_i128)
<a href=#331 id=331 data-nosnippet>331</a> }
<a href=#332 id=332 data-nosnippet>332</a>
<a href=#333 id=333 data-nosnippet>333</a> <span class="attr">#[allow(clippy::useless_conversion)]
<a href=#334 id=334 data-nosnippet>334</a> #[inline]
<a href=#335 id=335 data-nosnippet>335</a> </span><span class="kw">fn </span>to_u64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#336 id=336 data-nosnippet>336</a> <span class="kw">let </span><span class="kw-2">mut </span>ret: u64 = <span class="number">0</span>;
<a href=#337 id=337 data-nosnippet>337</a> <span class="kw">let </span><span class="kw-2">mut </span>bits = <span class="number">0</span>;
<a href=#338 id=338 data-nosnippet>338</a>
<a href=#339 id=339 data-nosnippet>339</a> <span class="kw">for </span>i <span class="kw">in </span><span class="self">self</span>.data.iter() {
<a href=#340 id=340 data-nosnippet>340</a> <span class="kw">if </span>bits &gt;= <span class="number">64 </span>{
<a href=#341 id=341 data-nosnippet>341</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#342 id=342 data-nosnippet>342</a> }
<a href=#343 id=343 data-nosnippet>343</a>
<a href=#344 id=344 data-nosnippet>344</a> <span class="comment">// XXX Conversion is useless if already 64-bit.
<a href=#345 id=345 data-nosnippet>345</a> </span>ret += u64::from(<span class="kw-2">*</span>i) &lt;&lt; bits;
<a href=#346 id=346 data-nosnippet>346</a> bits += big_digit::BITS;
<a href=#347 id=347 data-nosnippet>347</a> }
<a href=#348 id=348 data-nosnippet>348</a>
<a href=#349 id=349 data-nosnippet>349</a> <span class="prelude-val">Some</span>(ret)
<a href=#350 id=350 data-nosnippet>350</a> }
<a href=#351 id=351 data-nosnippet>351</a>
<a href=#352 id=352 data-nosnippet>352</a> <span class="attr">#[inline]
<a href=#353 id=353 data-nosnippet>353</a> </span><span class="kw">fn </span>to_u128(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u128&gt; {
<a href=#354 id=354 data-nosnippet>354</a> <span class="kw">let </span><span class="kw-2">mut </span>ret: u128 = <span class="number">0</span>;
<a href=#355 id=355 data-nosnippet>355</a> <span class="kw">let </span><span class="kw-2">mut </span>bits = <span class="number">0</span>;
<a href=#356 id=356 data-nosnippet>356</a>
<a href=#357 id=357 data-nosnippet>357</a> <span class="kw">for </span>i <span class="kw">in </span><span class="self">self</span>.data.iter() {
<a href=#358 id=358 data-nosnippet>358</a> <span class="kw">if </span>bits &gt;= <span class="number">128 </span>{
<a href=#359 id=359 data-nosnippet>359</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#360 id=360 data-nosnippet>360</a> }
<a href=#361 id=361 data-nosnippet>361</a>
<a href=#362 id=362 data-nosnippet>362</a> ret |= u128::from(<span class="kw-2">*</span>i) &lt;&lt; bits;
<a href=#363 id=363 data-nosnippet>363</a> bits += big_digit::BITS;
<a href=#364 id=364 data-nosnippet>364</a> }
<a href=#365 id=365 data-nosnippet>365</a>
<a href=#366 id=366 data-nosnippet>366</a> <span class="prelude-val">Some</span>(ret)
<a href=#367 id=367 data-nosnippet>367</a> }
<a href=#368 id=368 data-nosnippet>368</a>
<a href=#369 id=369 data-nosnippet>369</a> <span class="attr">#[inline]
<a href=#370 id=370 data-nosnippet>370</a> </span><span class="kw">fn </span>to_f32(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;f32&gt; {
<a href=#371 id=371 data-nosnippet>371</a> <span class="kw">let </span>mantissa = high_bits_to_u64(<span class="self">self</span>);
<a href=#372 id=372 data-nosnippet>372</a> <span class="kw">let </span>exponent = <span class="self">self</span>.bits() - u64::from(fls(mantissa));
<a href=#373 id=373 data-nosnippet>373</a>
<a href=#374 id=374 data-nosnippet>374</a> <span class="kw">if </span>exponent &gt; f32::MAX_EXP <span class="kw">as </span>u64 {
<a href=#375 id=375 data-nosnippet>375</a> <span class="prelude-val">Some</span>(f32::INFINITY)
<a href=#376 id=376 data-nosnippet>376</a> } <span class="kw">else </span>{
<a href=#377 id=377 data-nosnippet>377</a> <span class="prelude-val">Some</span>((mantissa <span class="kw">as </span>f32) * <span class="number">2.0f32</span>.powi(exponent <span class="kw">as </span>i32))
<a href=#378 id=378 data-nosnippet>378</a> }
<a href=#379 id=379 data-nosnippet>379</a> }
<a href=#380 id=380 data-nosnippet>380</a>
<a href=#381 id=381 data-nosnippet>381</a> <span class="attr">#[inline]
<a href=#382 id=382 data-nosnippet>382</a> </span><span class="kw">fn </span>to_f64(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;f64&gt; {
<a href=#383 id=383 data-nosnippet>383</a> <span class="kw">let </span>mantissa = high_bits_to_u64(<span class="self">self</span>);
<a href=#384 id=384 data-nosnippet>384</a> <span class="kw">let </span>exponent = <span class="self">self</span>.bits() - u64::from(fls(mantissa));
<a href=#385 id=385 data-nosnippet>385</a>
<a href=#386 id=386 data-nosnippet>386</a> <span class="kw">if </span>exponent &gt; f64::MAX_EXP <span class="kw">as </span>u64 {
<a href=#387 id=387 data-nosnippet>387</a> <span class="prelude-val">Some</span>(f64::INFINITY)
<a href=#388 id=388 data-nosnippet>388</a> } <span class="kw">else </span>{
<a href=#389 id=389 data-nosnippet>389</a> <span class="prelude-val">Some</span>((mantissa <span class="kw">as </span>f64) * <span class="number">2.0f64</span>.powi(exponent <span class="kw">as </span>i32))
<a href=#390 id=390 data-nosnippet>390</a> }
<a href=#391 id=391 data-nosnippet>391</a> }
<a href=#392 id=392 data-nosnippet>392</a>}
<a href=#393 id=393 data-nosnippet>393</a>
<a href=#394 id=394 data-nosnippet>394</a><span class="macro">macro_rules!</span> impl_try_from_biguint {
<a href=#395 id=395 data-nosnippet>395</a> (<span class="macro-nonterminal">$T</span>:ty, <span class="macro-nonterminal">$to_ty</span>:path) =&gt; {
<a href=#396 id=396 data-nosnippet>396</a> <span class="kw">impl </span>TryFrom&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#397 id=397 data-nosnippet>397</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;()&gt;;
<a href=#398 id=398 data-nosnippet>398</a>
<a href=#399 id=399 data-nosnippet>399</a> <span class="attr">#[inline]
<a href=#400 id=400 data-nosnippet>400</a> </span><span class="kw">fn </span>try_from(value: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Result</span>&lt;<span class="macro-nonterminal">$T</span>, TryFromBigIntError&lt;()&gt;&gt; {
<a href=#401 id=401 data-nosnippet>401</a> <span class="macro-nonterminal">$to_ty</span>(value).ok_or(TryFromBigIntError::new(()))
<a href=#402 id=402 data-nosnippet>402</a> }
<a href=#403 id=403 data-nosnippet>403</a> }
<a href=#404 id=404 data-nosnippet>404</a>
<a href=#405 id=405 data-nosnippet>405</a> <span class="kw">impl </span>TryFrom&lt;BigUint&gt; <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#406 id=406 data-nosnippet>406</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;BigUint&gt;;
<a href=#407 id=407 data-nosnippet>407</a>
<a href=#408 id=408 data-nosnippet>408</a> <span class="attr">#[inline]
<a href=#409 id=409 data-nosnippet>409</a> </span><span class="kw">fn </span>try_from(value: BigUint) -&gt; <span class="prelude-ty">Result</span>&lt;<span class="macro-nonterminal">$T</span>, TryFromBigIntError&lt;BigUint&gt;&gt; {
<a href=#410 id=410 data-nosnippet>410</a> &lt;<span class="macro-nonterminal">$T</span>&gt;::try_from(<span class="kw-2">&amp;</span>value).map_err(|<span class="kw">_</span>| TryFromBigIntError::new(value))
<a href=#411 id=411 data-nosnippet>411</a> }
<a href=#412 id=412 data-nosnippet>412</a> }
<a href=#413 id=413 data-nosnippet>413</a> };
<a href=#414 id=414 data-nosnippet>414</a>}
<a href=#415 id=415 data-nosnippet>415</a>
<a href=#416 id=416 data-nosnippet>416</a><span class="macro">impl_try_from_biguint!</span>(u8, ToPrimitive::to_u8);
<a href=#417 id=417 data-nosnippet>417</a><span class="macro">impl_try_from_biguint!</span>(u16, ToPrimitive::to_u16);
<a href=#418 id=418 data-nosnippet>418</a><span class="macro">impl_try_from_biguint!</span>(u32, ToPrimitive::to_u32);
<a href=#419 id=419 data-nosnippet>419</a><span class="macro">impl_try_from_biguint!</span>(u64, ToPrimitive::to_u64);
<a href=#420 id=420 data-nosnippet>420</a><span class="macro">impl_try_from_biguint!</span>(usize, ToPrimitive::to_usize);
<a href=#421 id=421 data-nosnippet>421</a><span class="macro">impl_try_from_biguint!</span>(u128, ToPrimitive::to_u128);
<a href=#422 id=422 data-nosnippet>422</a>
<a href=#423 id=423 data-nosnippet>423</a><span class="macro">impl_try_from_biguint!</span>(i8, ToPrimitive::to_i8);
<a href=#424 id=424 data-nosnippet>424</a><span class="macro">impl_try_from_biguint!</span>(i16, ToPrimitive::to_i16);
<a href=#425 id=425 data-nosnippet>425</a><span class="macro">impl_try_from_biguint!</span>(i32, ToPrimitive::to_i32);
<a href=#426 id=426 data-nosnippet>426</a><span class="macro">impl_try_from_biguint!</span>(i64, ToPrimitive::to_i64);
<a href=#427 id=427 data-nosnippet>427</a><span class="macro">impl_try_from_biguint!</span>(isize, ToPrimitive::to_isize);
<a href=#428 id=428 data-nosnippet>428</a><span class="macro">impl_try_from_biguint!</span>(i128, ToPrimitive::to_i128);
<a href=#429 id=429 data-nosnippet>429</a>
<a href=#430 id=430 data-nosnippet>430</a><span class="kw">impl </span>FromPrimitive <span class="kw">for </span>BigUint {
<a href=#431 id=431 data-nosnippet>431</a> <span class="attr">#[inline]
<a href=#432 id=432 data-nosnippet>432</a> </span><span class="kw">fn </span>from_i64(n: i64) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#433 id=433 data-nosnippet>433</a> <span class="kw">if </span>n &gt;= <span class="number">0 </span>{
<a href=#434 id=434 data-nosnippet>434</a> <span class="prelude-val">Some</span>(BigUint::from(n <span class="kw">as </span>u64))
<a href=#435 id=435 data-nosnippet>435</a> } <span class="kw">else </span>{
<a href=#436 id=436 data-nosnippet>436</a> <span class="prelude-val">None
<a href=#437 id=437 data-nosnippet>437</a> </span>}
<a href=#438 id=438 data-nosnippet>438</a> }
<a href=#439 id=439 data-nosnippet>439</a>
<a href=#440 id=440 data-nosnippet>440</a> <span class="attr">#[inline]
<a href=#441 id=441 data-nosnippet>441</a> </span><span class="kw">fn </span>from_i128(n: i128) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#442 id=442 data-nosnippet>442</a> <span class="kw">if </span>n &gt;= <span class="number">0 </span>{
<a href=#443 id=443 data-nosnippet>443</a> <span class="prelude-val">Some</span>(BigUint::from(n <span class="kw">as </span>u128))
<a href=#444 id=444 data-nosnippet>444</a> } <span class="kw">else </span>{
<a href=#445 id=445 data-nosnippet>445</a> <span class="prelude-val">None
<a href=#446 id=446 data-nosnippet>446</a> </span>}
<a href=#447 id=447 data-nosnippet>447</a> }
<a href=#448 id=448 data-nosnippet>448</a>
<a href=#449 id=449 data-nosnippet>449</a> <span class="attr">#[inline]
<a href=#450 id=450 data-nosnippet>450</a> </span><span class="kw">fn </span>from_u64(n: u64) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#451 id=451 data-nosnippet>451</a> <span class="prelude-val">Some</span>(BigUint::from(n))
<a href=#452 id=452 data-nosnippet>452</a> }
<a href=#453 id=453 data-nosnippet>453</a>
<a href=#454 id=454 data-nosnippet>454</a> <span class="attr">#[inline]
<a href=#455 id=455 data-nosnippet>455</a> </span><span class="kw">fn </span>from_u128(n: u128) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#456 id=456 data-nosnippet>456</a> <span class="prelude-val">Some</span>(BigUint::from(n))
<a href=#457 id=457 data-nosnippet>457</a> }
<a href=#458 id=458 data-nosnippet>458</a>
<a href=#459 id=459 data-nosnippet>459</a> <span class="attr">#[inline]
<a href=#460 id=460 data-nosnippet>460</a> </span><span class="kw">fn </span>from_f64(<span class="kw-2">mut </span>n: f64) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#461 id=461 data-nosnippet>461</a> <span class="comment">// handle NAN, INFINITY, NEG_INFINITY
<a href=#462 id=462 data-nosnippet>462</a> </span><span class="kw">if </span>!n.is_finite() {
<a href=#463 id=463 data-nosnippet>463</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#464 id=464 data-nosnippet>464</a> }
<a href=#465 id=465 data-nosnippet>465</a>
<a href=#466 id=466 data-nosnippet>466</a> <span class="comment">// match the rounding of casting from float to int
<a href=#467 id=467 data-nosnippet>467</a> </span>n = n.trunc();
<a href=#468 id=468 data-nosnippet>468</a>
<a href=#469 id=469 data-nosnippet>469</a> <span class="comment">// handle 0.x, -0.x
<a href=#470 id=470 data-nosnippet>470</a> </span><span class="kw">if </span>n.is_zero() {
<a href=#471 id=471 data-nosnippet>471</a> <span class="kw">return </span><span class="prelude-val">Some</span>(<span class="self">Self</span>::ZERO);
<a href=#472 id=472 data-nosnippet>472</a> }
<a href=#473 id=473 data-nosnippet>473</a>
<a href=#474 id=474 data-nosnippet>474</a> <span class="kw">let </span>(mantissa, exponent, sign) = FloatCore::integer_decode(n);
<a href=#475 id=475 data-nosnippet>475</a>
<a href=#476 id=476 data-nosnippet>476</a> <span class="kw">if </span>sign == -<span class="number">1 </span>{
<a href=#477 id=477 data-nosnippet>477</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#478 id=478 data-nosnippet>478</a> }
<a href=#479 id=479 data-nosnippet>479</a>
<a href=#480 id=480 data-nosnippet>480</a> <span class="kw">let </span><span class="kw-2">mut </span>ret = BigUint::from(mantissa);
<a href=#481 id=481 data-nosnippet>481</a> <span class="kw">match </span>exponent.cmp(<span class="kw-2">&amp;</span><span class="number">0</span>) {
<a href=#482 id=482 data-nosnippet>482</a> Greater =&gt; ret &lt;&lt;= exponent <span class="kw">as </span>usize,
<a href=#483 id=483 data-nosnippet>483</a> Equal =&gt; {}
<a href=#484 id=484 data-nosnippet>484</a> Less =&gt; ret &gt;&gt;= (-exponent) <span class="kw">as </span>usize,
<a href=#485 id=485 data-nosnippet>485</a> }
<a href=#486 id=486 data-nosnippet>486</a> <span class="prelude-val">Some</span>(ret)
<a href=#487 id=487 data-nosnippet>487</a> }
<a href=#488 id=488 data-nosnippet>488</a>}
<a href=#489 id=489 data-nosnippet>489</a>
<a href=#490 id=490 data-nosnippet>490</a><span class="kw">impl </span>From&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#491 id=491 data-nosnippet>491</a> <span class="attr">#[inline]
<a href=#492 id=492 data-nosnippet>492</a> </span><span class="kw">fn </span>from(<span class="kw-2">mut </span>n: u64) -&gt; <span class="self">Self </span>{
<a href=#493 id=493 data-nosnippet>493</a> <span class="kw">let </span><span class="kw-2">mut </span>ret: BigUint = <span class="self">Self</span>::ZERO;
<a href=#494 id=494 data-nosnippet>494</a>
<a href=#495 id=495 data-nosnippet>495</a> <span class="kw">while </span><span class="macro">n !</span>= <span class="number">0 </span>{
<a href=#496 id=496 data-nosnippet>496</a> ret.data.push(n <span class="kw">as </span>BigDigit);
<a href=#497 id=497 data-nosnippet>497</a> <span class="comment">// don't overflow if BITS is 64:
<a href=#498 id=498 data-nosnippet>498</a> </span>n = (n &gt;&gt; <span class="number">1</span>) &gt;&gt; (big_digit::BITS - <span class="number">1</span>);
<a href=#499 id=499 data-nosnippet>499</a> }
<a href=#500 id=500 data-nosnippet>500</a>
<a href=#501 id=501 data-nosnippet>501</a> ret
<a href=#502 id=502 data-nosnippet>502</a> }
<a href=#503 id=503 data-nosnippet>503</a>}
<a href=#504 id=504 data-nosnippet>504</a>
<a href=#505 id=505 data-nosnippet>505</a><span class="kw">impl </span>From&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#506 id=506 data-nosnippet>506</a> <span class="attr">#[inline]
<a href=#507 id=507 data-nosnippet>507</a> </span><span class="kw">fn </span>from(<span class="kw-2">mut </span>n: u128) -&gt; <span class="self">Self </span>{
<a href=#508 id=508 data-nosnippet>508</a> <span class="kw">let </span><span class="kw-2">mut </span>ret: BigUint = <span class="self">Self</span>::ZERO;
<a href=#509 id=509 data-nosnippet>509</a>
<a href=#510 id=510 data-nosnippet>510</a> <span class="kw">while </span><span class="macro">n !</span>= <span class="number">0 </span>{
<a href=#511 id=511 data-nosnippet>511</a> ret.data.push(n <span class="kw">as </span>BigDigit);
<a href=#512 id=512 data-nosnippet>512</a> n &gt;&gt;= big_digit::BITS;
<a href=#513 id=513 data-nosnippet>513</a> }
<a href=#514 id=514 data-nosnippet>514</a>
<a href=#515 id=515 data-nosnippet>515</a> ret
<a href=#516 id=516 data-nosnippet>516</a> }
<a href=#517 id=517 data-nosnippet>517</a>}
<a href=#518 id=518 data-nosnippet>518</a>
<a href=#519 id=519 data-nosnippet>519</a><span class="macro">macro_rules!</span> impl_biguint_from_uint {
<a href=#520 id=520 data-nosnippet>520</a> (<span class="macro-nonterminal">$T</span>:ty) =&gt; {
<a href=#521 id=521 data-nosnippet>521</a> <span class="kw">impl </span>From&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigUint {
<a href=#522 id=522 data-nosnippet>522</a> <span class="attr">#[inline]
<a href=#523 id=523 data-nosnippet>523</a> </span><span class="kw">fn </span>from(n: <span class="macro-nonterminal">$T</span>) -&gt; <span class="self">Self </span>{
<a href=#524 id=524 data-nosnippet>524</a> BigUint::from(n <span class="kw">as </span>u64)
<a href=#525 id=525 data-nosnippet>525</a> }
<a href=#526 id=526 data-nosnippet>526</a> }
<a href=#527 id=527 data-nosnippet>527</a> };
<a href=#528 id=528 data-nosnippet>528</a>}
<a href=#529 id=529 data-nosnippet>529</a>
<a href=#530 id=530 data-nosnippet>530</a><span class="macro">impl_biguint_from_uint!</span>(u8);
<a href=#531 id=531 data-nosnippet>531</a><span class="macro">impl_biguint_from_uint!</span>(u16);
<a href=#532 id=532 data-nosnippet>532</a><span class="macro">impl_biguint_from_uint!</span>(u32);
<a href=#533 id=533 data-nosnippet>533</a><span class="macro">impl_biguint_from_uint!</span>(usize);
<a href=#534 id=534 data-nosnippet>534</a>
<a href=#535 id=535 data-nosnippet>535</a><span class="macro">macro_rules!</span> impl_biguint_try_from_int {
<a href=#536 id=536 data-nosnippet>536</a> (<span class="macro-nonterminal">$T</span>:ty, <span class="macro-nonterminal">$from_ty</span>:path) =&gt; {
<a href=#537 id=537 data-nosnippet>537</a> <span class="kw">impl </span>TryFrom&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigUint {
<a href=#538 id=538 data-nosnippet>538</a> <span class="kw">type </span>Error = TryFromBigIntError&lt;()&gt;;
<a href=#539 id=539 data-nosnippet>539</a>
<a href=#540 id=540 data-nosnippet>540</a> <span class="attr">#[inline]
<a href=#541 id=541 data-nosnippet>541</a> </span><span class="kw">fn </span>try_from(value: <span class="macro-nonterminal">$T</span>) -&gt; <span class="prelude-ty">Result</span>&lt;BigUint, TryFromBigIntError&lt;()&gt;&gt; {
<a href=#542 id=542 data-nosnippet>542</a> <span class="macro-nonterminal">$from_ty</span>(value).ok_or(TryFromBigIntError::new(()))
<a href=#543 id=543 data-nosnippet>543</a> }
<a href=#544 id=544 data-nosnippet>544</a> }
<a href=#545 id=545 data-nosnippet>545</a> };
<a href=#546 id=546 data-nosnippet>546</a>}
<a href=#547 id=547 data-nosnippet>547</a>
<a href=#548 id=548 data-nosnippet>548</a><span class="macro">impl_biguint_try_from_int!</span>(i8, FromPrimitive::from_i8);
<a href=#549 id=549 data-nosnippet>549</a><span class="macro">impl_biguint_try_from_int!</span>(i16, FromPrimitive::from_i16);
<a href=#550 id=550 data-nosnippet>550</a><span class="macro">impl_biguint_try_from_int!</span>(i32, FromPrimitive::from_i32);
<a href=#551 id=551 data-nosnippet>551</a><span class="macro">impl_biguint_try_from_int!</span>(i64, FromPrimitive::from_i64);
<a href=#552 id=552 data-nosnippet>552</a><span class="macro">impl_biguint_try_from_int!</span>(isize, FromPrimitive::from_isize);
<a href=#553 id=553 data-nosnippet>553</a><span class="macro">impl_biguint_try_from_int!</span>(i128, FromPrimitive::from_i128);
<a href=#554 id=554 data-nosnippet>554</a>
<a href=#555 id=555 data-nosnippet>555</a><span class="kw">impl </span>ToBigUint <span class="kw">for </span>BigUint {
<a href=#556 id=556 data-nosnippet>556</a> <span class="attr">#[inline]
<a href=#557 id=557 data-nosnippet>557</a> </span><span class="kw">fn </span>to_biguint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#558 id=558 data-nosnippet>558</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.clone())
<a href=#559 id=559 data-nosnippet>559</a> }
<a href=#560 id=560 data-nosnippet>560</a>}
<a href=#561 id=561 data-nosnippet>561</a>
<a href=#562 id=562 data-nosnippet>562</a><span class="macro">macro_rules!</span> impl_to_biguint {
<a href=#563 id=563 data-nosnippet>563</a> (<span class="macro-nonterminal">$T</span>:ty, <span class="macro-nonterminal">$from_ty</span>:path) =&gt; {
<a href=#564 id=564 data-nosnippet>564</a> <span class="kw">impl </span>ToBigUint <span class="kw">for </span><span class="macro-nonterminal">$T </span>{
<a href=#565 id=565 data-nosnippet>565</a> <span class="attr">#[inline]
<a href=#566 id=566 data-nosnippet>566</a> </span><span class="kw">fn </span>to_biguint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#567 id=567 data-nosnippet>567</a> <span class="macro-nonterminal">$from_ty</span>(<span class="kw-2">*</span><span class="self">self</span>)
<a href=#568 id=568 data-nosnippet>568</a> }
<a href=#569 id=569 data-nosnippet>569</a> }
<a href=#570 id=570 data-nosnippet>570</a> };
<a href=#571 id=571 data-nosnippet>571</a>}
<a href=#572 id=572 data-nosnippet>572</a>
<a href=#573 id=573 data-nosnippet>573</a><span class="macro">impl_to_biguint!</span>(isize, FromPrimitive::from_isize);
<a href=#574 id=574 data-nosnippet>574</a><span class="macro">impl_to_biguint!</span>(i8, FromPrimitive::from_i8);
<a href=#575 id=575 data-nosnippet>575</a><span class="macro">impl_to_biguint!</span>(i16, FromPrimitive::from_i16);
<a href=#576 id=576 data-nosnippet>576</a><span class="macro">impl_to_biguint!</span>(i32, FromPrimitive::from_i32);
<a href=#577 id=577 data-nosnippet>577</a><span class="macro">impl_to_biguint!</span>(i64, FromPrimitive::from_i64);
<a href=#578 id=578 data-nosnippet>578</a><span class="macro">impl_to_biguint!</span>(i128, FromPrimitive::from_i128);
<a href=#579 id=579 data-nosnippet>579</a>
<a href=#580 id=580 data-nosnippet>580</a><span class="macro">impl_to_biguint!</span>(usize, FromPrimitive::from_usize);
<a href=#581 id=581 data-nosnippet>581</a><span class="macro">impl_to_biguint!</span>(u8, FromPrimitive::from_u8);
<a href=#582 id=582 data-nosnippet>582</a><span class="macro">impl_to_biguint!</span>(u16, FromPrimitive::from_u16);
<a href=#583 id=583 data-nosnippet>583</a><span class="macro">impl_to_biguint!</span>(u32, FromPrimitive::from_u32);
<a href=#584 id=584 data-nosnippet>584</a><span class="macro">impl_to_biguint!</span>(u64, FromPrimitive::from_u64);
<a href=#585 id=585 data-nosnippet>585</a><span class="macro">impl_to_biguint!</span>(u128, FromPrimitive::from_u128);
<a href=#586 id=586 data-nosnippet>586</a>
<a href=#587 id=587 data-nosnippet>587</a><span class="macro">impl_to_biguint!</span>(f32, FromPrimitive::from_f32);
<a href=#588 id=588 data-nosnippet>588</a><span class="macro">impl_to_biguint!</span>(f64, FromPrimitive::from_f64);
<a href=#589 id=589 data-nosnippet>589</a>
<a href=#590 id=590 data-nosnippet>590</a><span class="kw">impl </span>From&lt;bool&gt; <span class="kw">for </span>BigUint {
<a href=#591 id=591 data-nosnippet>591</a> <span class="kw">fn </span>from(x: bool) -&gt; <span class="self">Self </span>{
<a href=#592 id=592 data-nosnippet>592</a> <span class="kw">if </span>x {
<a href=#593 id=593 data-nosnippet>593</a> One::one()
<a href=#594 id=594 data-nosnippet>594</a> } <span class="kw">else </span>{
<a href=#595 id=595 data-nosnippet>595</a> <span class="self">Self</span>::ZERO
<a href=#596 id=596 data-nosnippet>596</a> }
<a href=#597 id=597 data-nosnippet>597</a> }
<a href=#598 id=598 data-nosnippet>598</a>}
<a href=#599 id=599 data-nosnippet>599</a>
<a href=#600 id=600 data-nosnippet>600</a><span class="comment">// Extract bitwise digits that evenly divide BigDigit
<a href=#601 id=601 data-nosnippet>601</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>to_bitwise_digits_le(u: <span class="kw-2">&amp;</span>BigUint, bits: u8) -&gt; Vec&lt;u8&gt; {
<a href=#602 id=602 data-nosnippet>602</a> <span class="macro">debug_assert!</span>(!u.is_zero() &amp;&amp; bits &lt;= <span class="number">8 </span>&amp;&amp; big_digit::BITS % bits == <span class="number">0</span>);
<a href=#603 id=603 data-nosnippet>603</a>
<a href=#604 id=604 data-nosnippet>604</a> <span class="kw">let </span>last_i = u.data.len() - <span class="number">1</span>;
<a href=#605 id=605 data-nosnippet>605</a> <span class="kw">let </span>mask: BigDigit = (<span class="number">1 </span>&lt;&lt; bits) - <span class="number">1</span>;
<a href=#606 id=606 data-nosnippet>606</a> <span class="kw">let </span>digits_per_big_digit = big_digit::BITS / bits;
<a href=#607 id=607 data-nosnippet>607</a> <span class="kw">let </span>digits = Integer::div_ceil(<span class="kw-2">&amp;</span>u.bits(), <span class="kw-2">&amp;</span>u64::from(bits))
<a href=#608 id=608 data-nosnippet>608</a> .to_usize()
<a href=#609 id=609 data-nosnippet>609</a> .unwrap_or(usize::MAX);
<a href=#610 id=610 data-nosnippet>610</a> <span class="kw">let </span><span class="kw-2">mut </span>res = Vec::with_capacity(digits);
<a href=#611 id=611 data-nosnippet>611</a>
<a href=#612 id=612 data-nosnippet>612</a> <span class="kw">for </span><span class="kw-2">mut </span>r <span class="kw">in </span>u.data[..last_i].iter().cloned() {
<a href=#613 id=613 data-nosnippet>613</a> <span class="kw">for _ in </span><span class="number">0</span>..digits_per_big_digit {
<a href=#614 id=614 data-nosnippet>614</a> res.push((r &amp; mask) <span class="kw">as </span>u8);
<a href=#615 id=615 data-nosnippet>615</a> r &gt;&gt;= bits;
<a href=#616 id=616 data-nosnippet>616</a> }
<a href=#617 id=617 data-nosnippet>617</a> }
<a href=#618 id=618 data-nosnippet>618</a>
<a href=#619 id=619 data-nosnippet>619</a> <span class="kw">let </span><span class="kw-2">mut </span>r = u.data[last_i];
<a href=#620 id=620 data-nosnippet>620</a> <span class="kw">while </span><span class="macro">r !</span>= <span class="number">0 </span>{
<a href=#621 id=621 data-nosnippet>621</a> res.push((r &amp; mask) <span class="kw">as </span>u8);
<a href=#622 id=622 data-nosnippet>622</a> r &gt;&gt;= bits;
<a href=#623 id=623 data-nosnippet>623</a> }
<a href=#624 id=624 data-nosnippet>624</a>
<a href=#625 id=625 data-nosnippet>625</a> res
<a href=#626 id=626 data-nosnippet>626</a>}
<a href=#627 id=627 data-nosnippet>627</a>
<a href=#628 id=628 data-nosnippet>628</a><span class="comment">// Extract bitwise digits that don't evenly divide BigDigit
<a href=#629 id=629 data-nosnippet>629</a></span><span class="kw">fn </span>to_inexact_bitwise_digits_le(u: <span class="kw-2">&amp;</span>BigUint, bits: u8) -&gt; Vec&lt;u8&gt; {
<a href=#630 id=630 data-nosnippet>630</a> <span class="macro">debug_assert!</span>(!u.is_zero() &amp;&amp; bits &lt;= <span class="number">8 </span>&amp;&amp; big_digit::BITS % <span class="macro">bits !</span>= <span class="number">0</span>);
<a href=#631 id=631 data-nosnippet>631</a>
<a href=#632 id=632 data-nosnippet>632</a> <span class="kw">let </span>mask: BigDigit = (<span class="number">1 </span>&lt;&lt; bits) - <span class="number">1</span>;
<a href=#633 id=633 data-nosnippet>633</a> <span class="kw">let </span>digits = Integer::div_ceil(<span class="kw-2">&amp;</span>u.bits(), <span class="kw-2">&amp;</span>u64::from(bits))
<a href=#634 id=634 data-nosnippet>634</a> .to_usize()
<a href=#635 id=635 data-nosnippet>635</a> .unwrap_or(usize::MAX);
<a href=#636 id=636 data-nosnippet>636</a> <span class="kw">let </span><span class="kw-2">mut </span>res = Vec::with_capacity(digits);
<a href=#637 id=637 data-nosnippet>637</a>
<a href=#638 id=638 data-nosnippet>638</a> <span class="kw">let </span><span class="kw-2">mut </span>r = <span class="number">0</span>;
<a href=#639 id=639 data-nosnippet>639</a> <span class="kw">let </span><span class="kw-2">mut </span>rbits = <span class="number">0</span>;
<a href=#640 id=640 data-nosnippet>640</a>
<a href=#641 id=641 data-nosnippet>641</a> <span class="kw">for </span>c <span class="kw">in </span><span class="kw-2">&amp;</span>u.data {
<a href=#642 id=642 data-nosnippet>642</a> r |= <span class="kw-2">*</span>c &lt;&lt; rbits;
<a href=#643 id=643 data-nosnippet>643</a> rbits += big_digit::BITS;
<a href=#644 id=644 data-nosnippet>644</a>
<a href=#645 id=645 data-nosnippet>645</a> <span class="kw">while </span>rbits &gt;= bits {
<a href=#646 id=646 data-nosnippet>646</a> res.push((r &amp; mask) <span class="kw">as </span>u8);
<a href=#647 id=647 data-nosnippet>647</a> r &gt;&gt;= bits;
<a href=#648 id=648 data-nosnippet>648</a>
<a href=#649 id=649 data-nosnippet>649</a> <span class="comment">// r had more bits than it could fit - grab the bits we lost
<a href=#650 id=650 data-nosnippet>650</a> </span><span class="kw">if </span>rbits &gt; big_digit::BITS {
<a href=#651 id=651 data-nosnippet>651</a> r = <span class="kw-2">*</span>c &gt;&gt; (big_digit::BITS - (rbits - bits));
<a href=#652 id=652 data-nosnippet>652</a> }
<a href=#653 id=653 data-nosnippet>653</a>
<a href=#654 id=654 data-nosnippet>654</a> rbits -= bits;
<a href=#655 id=655 data-nosnippet>655</a> }
<a href=#656 id=656 data-nosnippet>656</a> }
<a href=#657 id=657 data-nosnippet>657</a>
<a href=#658 id=658 data-nosnippet>658</a> <span class="kw">if </span><span class="macro">rbits !</span>= <span class="number">0 </span>{
<a href=#659 id=659 data-nosnippet>659</a> res.push(r <span class="kw">as </span>u8);
<a href=#660 id=660 data-nosnippet>660</a> }
<a href=#661 id=661 data-nosnippet>661</a>
<a href=#662 id=662 data-nosnippet>662</a> <span class="kw">while let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) = res.last() {
<a href=#663 id=663 data-nosnippet>663</a> res.pop();
<a href=#664 id=664 data-nosnippet>664</a> }
<a href=#665 id=665 data-nosnippet>665</a>
<a href=#666 id=666 data-nosnippet>666</a> res
<a href=#667 id=667 data-nosnippet>667</a>}
<a href=#668 id=668 data-nosnippet>668</a>
<a href=#669 id=669 data-nosnippet>669</a><span class="comment">// Extract little-endian radix digits
<a href=#670 id=670 data-nosnippet>670</a></span><span class="attr">#[inline(always)] </span><span class="comment">// forced inline to get const-prop for radix=10
<a href=#671 id=671 data-nosnippet>671</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>to_radix_digits_le(u: <span class="kw-2">&amp;</span>BigUint, radix: u32) -&gt; Vec&lt;u8&gt; {
<a href=#672 id=672 data-nosnippet>672</a> <span class="macro">debug_assert!</span>(!u.is_zero() &amp;&amp; !radix.is_power_of_two());
<a href=#673 id=673 data-nosnippet>673</a>
<a href=#674 id=674 data-nosnippet>674</a> <span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#675 id=675 data-nosnippet>675</a> </span><span class="kw">let </span>radix_digits = {
<a href=#676 id=676 data-nosnippet>676</a> <span class="kw">let </span>radix_log2 = f64::from(radix).log2();
<a href=#677 id=677 data-nosnippet>677</a> ((u.bits() <span class="kw">as </span>f64) / radix_log2).ceil()
<a href=#678 id=678 data-nosnippet>678</a> };
<a href=#679 id=679 data-nosnippet>679</a> <span class="attr">#[cfg(not(feature = <span class="string">"std"</span>))]
<a href=#680 id=680 data-nosnippet>680</a> </span><span class="kw">let </span>radix_digits = {
<a href=#681 id=681 data-nosnippet>681</a> <span class="kw">let </span>radix_log2 = ilog2(radix) <span class="kw">as </span>usize;
<a href=#682 id=682 data-nosnippet>682</a> ((u.bits() <span class="kw">as </span>usize) / radix_log2) + <span class="number">1
<a href=#683 id=683 data-nosnippet>683</a> </span>};
<a href=#684 id=684 data-nosnippet>684</a>
<a href=#685 id=685 data-nosnippet>685</a> <span class="comment">// Estimate how big the result will be, so we can pre-allocate it.
<a href=#686 id=686 data-nosnippet>686</a> </span><span class="kw">let </span><span class="kw-2">mut </span>res = Vec::with_capacity(radix_digits.to_usize().unwrap_or(<span class="number">0</span>));
<a href=#687 id=687 data-nosnippet>687</a>
<a href=#688 id=688 data-nosnippet>688</a> <span class="kw">let </span><span class="kw-2">mut </span>digits = u.clone();
<a href=#689 id=689 data-nosnippet>689</a>
<a href=#690 id=690 data-nosnippet>690</a> <span class="comment">// X86 DIV can quickly divide by a full digit, otherwise we choose a divisor
<a href=#691 id=691 data-nosnippet>691</a> // that's suitable for `div_half` to avoid slow `DoubleBigDigit` division.
<a href=#692 id=692 data-nosnippet>692</a> </span><span class="kw">let </span>(base, power) = <span class="kw">if </span>FAST_DIV_WIDE {
<a href=#693 id=693 data-nosnippet>693</a> get_radix_base(radix)
<a href=#694 id=694 data-nosnippet>694</a> } <span class="kw">else </span>{
<a href=#695 id=695 data-nosnippet>695</a> get_half_radix_base(radix)
<a href=#696 id=696 data-nosnippet>696</a> };
<a href=#697 id=697 data-nosnippet>697</a> <span class="kw">let </span>radix = radix <span class="kw">as </span>BigDigit;
<a href=#698 id=698 data-nosnippet>698</a>
<a href=#699 id=699 data-nosnippet>699</a> <span class="comment">// For very large numbers, the O(n²) loop of repeated `div_rem_digit` dominates the
<a href=#700 id=700 data-nosnippet>700</a> // performance. We can mitigate this by dividing into chunks of a larger base first.
<a href=#701 id=701 data-nosnippet>701</a> // The threshold for this was chosen by anecdotal performance measurements to
<a href=#702 id=702 data-nosnippet>702</a> // approximate where this starts to make a noticeable difference.
<a href=#703 id=703 data-nosnippet>703</a> </span><span class="kw">if </span>digits.data.len() &gt;= <span class="number">64 </span>{
<a href=#704 id=704 data-nosnippet>704</a> <span class="kw">let </span><span class="kw-2">mut </span>big_base = BigUint::from(base);
<a href=#705 id=705 data-nosnippet>705</a> <span class="kw">let </span><span class="kw-2">mut </span>big_power = <span class="number">1usize</span>;
<a href=#706 id=706 data-nosnippet>706</a>
<a href=#707 id=707 data-nosnippet>707</a> <span class="comment">// Choose a target base length near √n.
<a href=#708 id=708 data-nosnippet>708</a> </span><span class="kw">let </span>target_len = digits.data.len().sqrt();
<a href=#709 id=709 data-nosnippet>709</a> <span class="kw">while </span>big_base.data.len() &lt; target_len {
<a href=#710 id=710 data-nosnippet>710</a> big_base = <span class="kw-2">&amp;</span>big_base * <span class="kw-2">&amp;</span>big_base;
<a href=#711 id=711 data-nosnippet>711</a> big_power <span class="kw-2">*</span>= <span class="number">2</span>;
<a href=#712 id=712 data-nosnippet>712</a> }
<a href=#713 id=713 data-nosnippet>713</a>
<a href=#714 id=714 data-nosnippet>714</a> <span class="comment">// This outer loop will run approximately √n times.
<a href=#715 id=715 data-nosnippet>715</a> </span><span class="kw">while </span>digits &gt; big_base {
<a href=#716 id=716 data-nosnippet>716</a> <span class="comment">// This is still the dominating factor, with n digits divided by √n digits.
<a href=#717 id=717 data-nosnippet>717</a> </span><span class="kw">let </span>(q, <span class="kw-2">mut </span>big_r) = digits.div_rem(<span class="kw-2">&amp;</span>big_base);
<a href=#718 id=718 data-nosnippet>718</a> digits = q;
<a href=#719 id=719 data-nosnippet>719</a>
<a href=#720 id=720 data-nosnippet>720</a> <span class="comment">// This inner loop now has O(√n²)=O(n) behavior altogether.
<a href=#721 id=721 data-nosnippet>721</a> </span><span class="kw">for _ in </span><span class="number">0</span>..big_power {
<a href=#722 id=722 data-nosnippet>722</a> <span class="kw">let </span>(q, <span class="kw-2">mut </span>r) = div_rem_digit(big_r, base);
<a href=#723 id=723 data-nosnippet>723</a> big_r = q;
<a href=#724 id=724 data-nosnippet>724</a> <span class="kw">for _ in </span><span class="number">0</span>..power {
<a href=#725 id=725 data-nosnippet>725</a> res.push((r % radix) <span class="kw">as </span>u8);
<a href=#726 id=726 data-nosnippet>726</a> r /= radix;
<a href=#727 id=727 data-nosnippet>727</a> }
<a href=#728 id=728 data-nosnippet>728</a> }
<a href=#729 id=729 data-nosnippet>729</a> }
<a href=#730 id=730 data-nosnippet>730</a> }
<a href=#731 id=731 data-nosnippet>731</a>
<a href=#732 id=732 data-nosnippet>732</a> <span class="kw">while </span>digits.data.len() &gt; <span class="number">1 </span>{
<a href=#733 id=733 data-nosnippet>733</a> <span class="kw">let </span>(q, <span class="kw-2">mut </span>r) = div_rem_digit(digits, base);
<a href=#734 id=734 data-nosnippet>734</a> <span class="kw">for _ in </span><span class="number">0</span>..power {
<a href=#735 id=735 data-nosnippet>735</a> res.push((r % radix) <span class="kw">as </span>u8);
<a href=#736 id=736 data-nosnippet>736</a> r /= radix;
<a href=#737 id=737 data-nosnippet>737</a> }
<a href=#738 id=738 data-nosnippet>738</a> digits = q;
<a href=#739 id=739 data-nosnippet>739</a> }
<a href=#740 id=740 data-nosnippet>740</a>
<a href=#741 id=741 data-nosnippet>741</a> <span class="kw">let </span><span class="kw-2">mut </span>r = digits.data[<span class="number">0</span>];
<a href=#742 id=742 data-nosnippet>742</a> <span class="kw">while </span><span class="macro">r !</span>= <span class="number">0 </span>{
<a href=#743 id=743 data-nosnippet>743</a> res.push((r % radix) <span class="kw">as </span>u8);
<a href=#744 id=744 data-nosnippet>744</a> r /= radix;
<a href=#745 id=745 data-nosnippet>745</a> }
<a href=#746 id=746 data-nosnippet>746</a>
<a href=#747 id=747 data-nosnippet>747</a> res
<a href=#748 id=748 data-nosnippet>748</a>}
<a href=#749 id=749 data-nosnippet>749</a>
<a href=#750 id=750 data-nosnippet>750</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>to_radix_le(u: <span class="kw-2">&amp;</span>BigUint, radix: u32) -&gt; Vec&lt;u8&gt; {
<a href=#751 id=751 data-nosnippet>751</a> <span class="kw">if </span>u.is_zero() {
<a href=#752 id=752 data-nosnippet>752</a> <span class="macro">vec!</span>[<span class="number">0</span>]
<a href=#753 id=753 data-nosnippet>753</a> } <span class="kw">else if </span>radix.is_power_of_two() {
<a href=#754 id=754 data-nosnippet>754</a> <span class="comment">// Powers of two can use bitwise masks and shifting instead of division
<a href=#755 id=755 data-nosnippet>755</a> </span><span class="kw">let </span>bits = ilog2(radix);
<a href=#756 id=756 data-nosnippet>756</a> <span class="kw">if </span>big_digit::BITS % bits == <span class="number">0 </span>{
<a href=#757 id=757 data-nosnippet>757</a> to_bitwise_digits_le(u, bits)
<a href=#758 id=758 data-nosnippet>758</a> } <span class="kw">else </span>{
<a href=#759 id=759 data-nosnippet>759</a> to_inexact_bitwise_digits_le(u, bits)
<a href=#760 id=760 data-nosnippet>760</a> }
<a href=#761 id=761 data-nosnippet>761</a> } <span class="kw">else if </span>radix == <span class="number">10 </span>{
<a href=#762 id=762 data-nosnippet>762</a> <span class="comment">// 10 is so common that it's worth separating out for const-propagation.
<a href=#763 id=763 data-nosnippet>763</a> // Optimizers can often turn constant division into a faster multiplication.
<a href=#764 id=764 data-nosnippet>764</a> </span>to_radix_digits_le(u, <span class="number">10</span>)
<a href=#765 id=765 data-nosnippet>765</a> } <span class="kw">else </span>{
<a href=#766 id=766 data-nosnippet>766</a> to_radix_digits_le(u, radix)
<a href=#767 id=767 data-nosnippet>767</a> }
<a href=#768 id=768 data-nosnippet>768</a>}
<a href=#769 id=769 data-nosnippet>769</a>
<a href=#770 id=770 data-nosnippet>770</a><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>to_str_radix_reversed(u: <span class="kw-2">&amp;</span>BigUint, radix: u32) -&gt; Vec&lt;u8&gt; {
<a href=#771 id=771 data-nosnippet>771</a> <span class="macro">assert!</span>(<span class="number">2 </span>&lt;= radix &amp;&amp; radix &lt;= <span class="number">36</span>, <span class="string">"The radix must be within 2...36"</span>);
<a href=#772 id=772 data-nosnippet>772</a>
<a href=#773 id=773 data-nosnippet>773</a> <span class="kw">if </span>u.is_zero() {
<a href=#774 id=774 data-nosnippet>774</a> <span class="kw">return </span><span class="macro">vec!</span>[<span class="string">b'0'</span>];
<a href=#775 id=775 data-nosnippet>775</a> }
<a href=#776 id=776 data-nosnippet>776</a>
<a href=#777 id=777 data-nosnippet>777</a> <span class="kw">let </span><span class="kw-2">mut </span>res = to_radix_le(u, radix);
<a href=#778 id=778 data-nosnippet>778</a>
<a href=#779 id=779 data-nosnippet>779</a> <span class="comment">// Now convert everything to ASCII digits.
<a href=#780 id=780 data-nosnippet>780</a> </span><span class="kw">for </span>r <span class="kw">in </span><span class="kw-2">&amp;mut </span>res {
<a href=#781 id=781 data-nosnippet>781</a> <span class="macro">debug_assert!</span>(u32::from(<span class="kw-2">*</span>r) &lt; radix);
<a href=#782 id=782 data-nosnippet>782</a> <span class="kw">if </span><span class="kw-2">*</span>r &lt; <span class="number">10 </span>{
<a href=#783 id=783 data-nosnippet>783</a> <span class="kw-2">*</span>r += <span class="string">b'0'</span>;
<a href=#784 id=784 data-nosnippet>784</a> } <span class="kw">else </span>{
<a href=#785 id=785 data-nosnippet>785</a> <span class="kw-2">*</span>r += <span class="string">b'a' </span>- <span class="number">10</span>;
<a href=#786 id=786 data-nosnippet>786</a> }
<a href=#787 id=787 data-nosnippet>787</a> }
<a href=#788 id=788 data-nosnippet>788</a> res
<a href=#789 id=789 data-nosnippet>789</a>}
<a href=#790 id=790 data-nosnippet>790</a>
<a href=#791 id=791 data-nosnippet>791</a><span class="doccomment">/// Returns the greatest power of the radix for the `BigDigit` bit size
<a href=#792 id=792 data-nosnippet>792</a></span><span class="attr">#[inline]
<a href=#793 id=793 data-nosnippet>793</a></span><span class="kw">fn </span>get_radix_base(radix: u32) -&gt; (BigDigit, usize) {
<a href=#794 id=794 data-nosnippet>794</a> <span class="kw">static </span>BASES: [(BigDigit, usize); <span class="number">257</span>] = generate_radix_bases(big_digit::MAX);
<a href=#795 id=795 data-nosnippet>795</a> <span class="macro">debug_assert!</span>(!radix.is_power_of_two());
<a href=#796 id=796 data-nosnippet>796</a> <span class="macro">debug_assert!</span>((<span class="number">3</span>..<span class="number">256</span>).contains(<span class="kw-2">&amp;</span>radix));
<a href=#797 id=797 data-nosnippet>797</a> BASES[radix <span class="kw">as </span>usize]
<a href=#798 id=798 data-nosnippet>798</a>}
<a href=#799 id=799 data-nosnippet>799</a>
<a href=#800 id=800 data-nosnippet>800</a><span class="doccomment">/// Returns the greatest power of the radix for half the `BigDigit` bit size
<a href=#801 id=801 data-nosnippet>801</a></span><span class="attr">#[inline]
<a href=#802 id=802 data-nosnippet>802</a></span><span class="kw">fn </span>get_half_radix_base(radix: u32) -&gt; (BigDigit, usize) {
<a href=#803 id=803 data-nosnippet>803</a> <span class="kw">static </span>BASES: [(BigDigit, usize); <span class="number">257</span>] = generate_radix_bases(big_digit::HALF);
<a href=#804 id=804 data-nosnippet>804</a> <span class="macro">debug_assert!</span>(!radix.is_power_of_two());
<a href=#805 id=805 data-nosnippet>805</a> <span class="macro">debug_assert!</span>((<span class="number">3</span>..<span class="number">256</span>).contains(<span class="kw-2">&amp;</span>radix));
<a href=#806 id=806 data-nosnippet>806</a> BASES[radix <span class="kw">as </span>usize]
<a href=#807 id=807 data-nosnippet>807</a>}
<a href=#808 id=808 data-nosnippet>808</a>
<a href=#809 id=809 data-nosnippet>809</a><span class="doccomment">/// Generate tables of the greatest power of each radix that is less that the given maximum. These
<a href=#810 id=810 data-nosnippet>810</a>/// are returned from `get_radix_base` to batch the multiplication/division of radix conversions on
<a href=#811 id=811 data-nosnippet>811</a>/// full `BigUint` values, operating on primitive integers as much as possible.
<a href=#812 id=812 data-nosnippet>812</a>///
<a href=#813 id=813 data-nosnippet>813</a>/// e.g. BASES_16[3] = (59049, 10) // 3¹⁰ fits in u16, but 3¹¹ is too big
<a href=#814 id=814 data-nosnippet>814</a>/// BASES_32[3] = (3486784401, 20)
<a href=#815 id=815 data-nosnippet>815</a>/// BASES_64[3] = (12157665459056928801, 40)
<a href=#816 id=816 data-nosnippet>816</a>///
<a href=#817 id=817 data-nosnippet>817</a>/// Powers of two are not included, just zeroed, as they're implemented with shifts.
<a href=#818 id=818 data-nosnippet>818</a></span><span class="kw">const fn </span>generate_radix_bases(max: BigDigit) -&gt; [(BigDigit, usize); <span class="number">257</span>] {
<a href=#819 id=819 data-nosnippet>819</a> <span class="kw">let </span><span class="kw-2">mut </span>bases = [(<span class="number">0</span>, <span class="number">0</span>); <span class="number">257</span>];
<a href=#820 id=820 data-nosnippet>820</a>
<a href=#821 id=821 data-nosnippet>821</a> <span class="kw">let </span><span class="kw-2">mut </span>radix: BigDigit = <span class="number">3</span>;
<a href=#822 id=822 data-nosnippet>822</a> <span class="kw">while </span>radix &lt; <span class="number">256 </span>{
<a href=#823 id=823 data-nosnippet>823</a> <span class="kw">if </span>!radix.is_power_of_two() {
<a href=#824 id=824 data-nosnippet>824</a> <span class="kw">let </span><span class="kw-2">mut </span>power = <span class="number">1</span>;
<a href=#825 id=825 data-nosnippet>825</a> <span class="kw">let </span><span class="kw-2">mut </span>base = radix;
<a href=#826 id=826 data-nosnippet>826</a>
<a href=#827 id=827 data-nosnippet>827</a> <span class="kw">while let </span><span class="prelude-val">Some</span>(b) = base.checked_mul(radix) {
<a href=#828 id=828 data-nosnippet>828</a> <span class="kw">if </span>b &gt; max {
<a href=#829 id=829 data-nosnippet>829</a> <span class="kw">break</span>;
<a href=#830 id=830 data-nosnippet>830</a> }
<a href=#831 id=831 data-nosnippet>831</a> base = b;
<a href=#832 id=832 data-nosnippet>832</a> power += <span class="number">1</span>;
<a href=#833 id=833 data-nosnippet>833</a> }
<a href=#834 id=834 data-nosnippet>834</a> bases[radix <span class="kw">as </span>usize] = (base, power)
<a href=#835 id=835 data-nosnippet>835</a> }
<a href=#836 id=836 data-nosnippet>836</a> radix += <span class="number">1</span>;
<a href=#837 id=837 data-nosnippet>837</a> }
<a href=#838 id=838 data-nosnippet>838</a>
<a href=#839 id=839 data-nosnippet>839</a> bases
<a href=#840 id=840 data-nosnippet>840</a>}
<a href=#841 id=841 data-nosnippet>841</a>
<a href=#842 id=842 data-nosnippet>842</a><span class="attr">#[test]
<a href=#843 id=843 data-nosnippet>843</a></span><span class="kw">fn </span>test_radix_bases() {
<a href=#844 id=844 data-nosnippet>844</a> <span class="kw">for </span>radix <span class="kw">in </span><span class="number">3u32</span>..<span class="number">256 </span>{
<a href=#845 id=845 data-nosnippet>845</a> <span class="kw">if </span>!radix.is_power_of_two() {
<a href=#846 id=846 data-nosnippet>846</a> <span class="kw">let </span>(base, power) = get_radix_base(radix);
<a href=#847 id=847 data-nosnippet>847</a> <span class="kw">let </span>radix = BigDigit::from(radix);
<a href=#848 id=848 data-nosnippet>848</a> <span class="kw">let </span>power = u32::try_from(power).unwrap();
<a href=#849 id=849 data-nosnippet>849</a> <span class="macro">assert_eq!</span>(base, radix.pow(power));
<a href=#850 id=850 data-nosnippet>850</a> <span class="macro">assert!</span>(radix.checked_pow(power + <span class="number">1</span>).is_none());
<a href=#851 id=851 data-nosnippet>851</a> }
<a href=#852 id=852 data-nosnippet>852</a> }
<a href=#853 id=853 data-nosnippet>853</a>}
<a href=#854 id=854 data-nosnippet>854</a>
<a href=#855 id=855 data-nosnippet>855</a><span class="attr">#[test]
<a href=#856 id=856 data-nosnippet>856</a></span><span class="kw">fn </span>test_half_radix_bases() {
<a href=#857 id=857 data-nosnippet>857</a> <span class="kw">for </span>radix <span class="kw">in </span><span class="number">3u32</span>..<span class="number">256 </span>{
<a href=#858 id=858 data-nosnippet>858</a> <span class="kw">if </span>!radix.is_power_of_two() {
<a href=#859 id=859 data-nosnippet>859</a> <span class="kw">let </span>(base, power) = get_half_radix_base(radix);
<a href=#860 id=860 data-nosnippet>860</a> <span class="kw">let </span>radix = BigDigit::from(radix);
<a href=#861 id=861 data-nosnippet>861</a> <span class="kw">let </span>power = u32::try_from(power).unwrap();
<a href=#862 id=862 data-nosnippet>862</a> <span class="macro">assert_eq!</span>(base, radix.pow(power));
<a href=#863 id=863 data-nosnippet>863</a> <span class="macro">assert!</span>(radix.pow(power + <span class="number">1</span>) &gt; big_digit::HALF);
<a href=#864 id=864 data-nosnippet>864</a> }
<a href=#865 id=865 data-nosnippet>865</a> }
<a href=#866 id=866 data-nosnippet>866</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,705 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/division.rs`."><title>division.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>division.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::addition::__add2;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use super</span>::{cmp_slice, BigUint};
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit, DoubleBigDigit};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::UsizePromotion;
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::mem;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::ops::{Div, DivAssign, Rem, RemAssign};
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>num_integer::Integer;
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span>num_traits::{CheckedDiv, CheckedEuclid, Euclid, One, ToPrimitive, Zero};
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">const </span>FAST_DIV_WIDE: bool = <span class="macro">cfg!</span>(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>));
<a href=#14 id=14 data-nosnippet>14</a>
<a href=#15 id=15 data-nosnippet>15</a><span class="doccomment">/// Divide a two digit numerator by a one digit divisor, returns quotient and remainder:
<a href=#16 id=16 data-nosnippet>16</a>///
<a href=#17 id=17 data-nosnippet>17</a>/// Note: the caller must ensure that both the quotient and remainder will fit into a single digit.
<a href=#18 id=18 data-nosnippet>18</a>/// This is _not_ true for an arbitrary numerator/denominator.
<a href=#19 id=19 data-nosnippet>19</a>///
<a href=#20 id=20 data-nosnippet>20</a>/// (This function also matches what the x86 divide instruction does).
<a href=#21 id=21 data-nosnippet>21</a></span><span class="attr">#[cfg(any(miri, not(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>))))]
<a href=#22 id=22 data-nosnippet>22</a>#[inline]
<a href=#23 id=23 data-nosnippet>23</a></span><span class="kw">fn </span>div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#24 id=24 data-nosnippet>24</a> <span class="macro">debug_assert!</span>(hi &lt; divisor);
<a href=#25 id=25 data-nosnippet>25</a>
<a href=#26 id=26 data-nosnippet>26</a> <span class="kw">let </span>lhs = big_digit::to_doublebigdigit(hi, lo);
<a href=#27 id=27 data-nosnippet>27</a> <span class="kw">let </span>rhs = DoubleBigDigit::from(divisor);
<a href=#28 id=28 data-nosnippet>28</a> ((lhs / rhs) <span class="kw">as </span>BigDigit, (lhs % rhs) <span class="kw">as </span>BigDigit)
<a href=#29 id=29 data-nosnippet>29</a>}
<a href=#30 id=30 data-nosnippet>30</a>
<a href=#31 id=31 data-nosnippet>31</a><span class="doccomment">/// x86 and x86_64 can use a real `div` instruction.
<a href=#32 id=32 data-nosnippet>32</a></span><span class="attr">#[cfg(all(not(miri), any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>)))]
<a href=#33 id=33 data-nosnippet>33</a>#[inline]
<a href=#34 id=34 data-nosnippet>34</a></span><span class="kw">fn </span>div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#35 id=35 data-nosnippet>35</a> <span class="comment">// This debug assertion covers the potential #DE for divisor==0 or a quotient too large for one
<a href=#36 id=36 data-nosnippet>36</a> // register, otherwise in release mode it will become a target-specific fault like SIGFPE.
<a href=#37 id=37 data-nosnippet>37</a> // This should never occur with the inputs from our few `div_wide` callers.
<a href=#38 id=38 data-nosnippet>38</a> </span><span class="macro">debug_assert!</span>(hi &lt; divisor);
<a href=#39 id=39 data-nosnippet>39</a>
<a href=#40 id=40 data-nosnippet>40</a> <span class="comment">// SAFETY: The `div` instruction only affects registers, reading the explicit operand as the
<a href=#41 id=41 data-nosnippet>41</a> // divisor, and implicitly reading RDX:RAX or EDX:EAX as the dividend. The result is implicitly
<a href=#42 id=42 data-nosnippet>42</a> // written back to RAX or EAX for the quotient and RDX or EDX for the remainder. No memory is
<a href=#43 id=43 data-nosnippet>43</a> // used, and flags are not preserved.
<a href=#44 id=44 data-nosnippet>44</a> </span><span class="kw">unsafe </span>{
<a href=#45 id=45 data-nosnippet>45</a> <span class="kw">let </span>(div, rem);
<a href=#46 id=46 data-nosnippet>46</a>
<a href=#47 id=47 data-nosnippet>47</a> <span class="macro">cfg_digit!</span>(
<a href=#48 id=48 data-nosnippet>48</a> <span class="macro">macro_rules!</span> div {
<a href=#49 id=49 data-nosnippet>49</a> () =&gt; {
<a href=#50 id=50 data-nosnippet>50</a> <span class="string">"div {0:e}"
<a href=#51 id=51 data-nosnippet>51</a> </span>};
<a href=#52 id=52 data-nosnippet>52</a> }
<a href=#53 id=53 data-nosnippet>53</a> <span class="macro">macro_rules!</span> div {
<a href=#54 id=54 data-nosnippet>54</a> () =&gt; {
<a href=#55 id=55 data-nosnippet>55</a> <span class="string">"div {0:r}"
<a href=#56 id=56 data-nosnippet>56</a> </span>};
<a href=#57 id=57 data-nosnippet>57</a> }
<a href=#58 id=58 data-nosnippet>58</a> );
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a> <span class="macro">core::arch::asm!</span>(
<a href=#61 id=61 data-nosnippet>61</a> <span class="macro">div!</span>(),
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">in</span>(reg) divisor,
<a href=#63 id=63 data-nosnippet>63</a> inout(<span class="string">"dx"</span>) hi =&gt; rem,
<a href=#64 id=64 data-nosnippet>64</a> inout(<span class="string">"ax"</span>) lo =&gt; div,
<a href=#65 id=65 data-nosnippet>65</a> options(pure, nomem, nostack),
<a href=#66 id=66 data-nosnippet>66</a> );
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a> (div, rem)
<a href=#69 id=69 data-nosnippet>69</a> }
<a href=#70 id=70 data-nosnippet>70</a>}
<a href=#71 id=71 data-nosnippet>71</a>
<a href=#72 id=72 data-nosnippet>72</a><span class="doccomment">/// For small divisors, we can divide without promoting to `DoubleBigDigit` by
<a href=#73 id=73 data-nosnippet>73</a>/// using half-size pieces of digit, like long-division.
<a href=#74 id=74 data-nosnippet>74</a></span><span class="attr">#[inline]
<a href=#75 id=75 data-nosnippet>75</a></span><span class="kw">fn </span>div_half(rem: BigDigit, digit: BigDigit, divisor: BigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#76 id=76 data-nosnippet>76</a> <span class="kw">use </span><span class="kw">crate</span>::big_digit::{HALF, HALF_BITS};
<a href=#77 id=77 data-nosnippet>77</a>
<a href=#78 id=78 data-nosnippet>78</a> <span class="macro">debug_assert!</span>(rem &lt; divisor &amp;&amp; divisor &lt;= HALF);
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">let </span>(hi, rem) = ((rem &lt;&lt; HALF_BITS) | (digit &gt;&gt; HALF_BITS)).div_rem(<span class="kw-2">&amp;</span>divisor);
<a href=#80 id=80 data-nosnippet>80</a> <span class="kw">let </span>(lo, rem) = ((rem &lt;&lt; HALF_BITS) | (digit &amp; HALF)).div_rem(<span class="kw-2">&amp;</span>divisor);
<a href=#81 id=81 data-nosnippet>81</a> ((hi &lt;&lt; HALF_BITS) | lo, rem)
<a href=#82 id=82 data-nosnippet>82</a>}
<a href=#83 id=83 data-nosnippet>83</a>
<a href=#84 id=84 data-nosnippet>84</a><span class="attr">#[inline]
<a href=#85 id=85 data-nosnippet>85</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>div_rem_digit(<span class="kw-2">mut </span>a: BigUint, b: BigDigit) -&gt; (BigUint, BigDigit) {
<a href=#86 id=86 data-nosnippet>86</a> <span class="kw">if </span>b == <span class="number">0 </span>{
<a href=#87 id=87 data-nosnippet>87</a> <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>)
<a href=#88 id=88 data-nosnippet>88</a> }
<a href=#89 id=89 data-nosnippet>89</a>
<a href=#90 id=90 data-nosnippet>90</a> <span class="kw">let </span><span class="kw-2">mut </span>rem = <span class="number">0</span>;
<a href=#91 id=91 data-nosnippet>91</a>
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">if </span>!FAST_DIV_WIDE &amp;&amp; b &lt;= big_digit::HALF {
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">for </span>d <span class="kw">in </span>a.data.iter_mut().rev() {
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">let </span>(q, r) = div_half(rem, <span class="kw-2">*</span>d, b);
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw-2">*</span>d = q;
<a href=#96 id=96 data-nosnippet>96</a> rem = r;
<a href=#97 id=97 data-nosnippet>97</a> }
<a href=#98 id=98 data-nosnippet>98</a> } <span class="kw">else </span>{
<a href=#99 id=99 data-nosnippet>99</a> <span class="kw">for </span>d <span class="kw">in </span>a.data.iter_mut().rev() {
<a href=#100 id=100 data-nosnippet>100</a> <span class="kw">let </span>(q, r) = div_wide(rem, <span class="kw-2">*</span>d, b);
<a href=#101 id=101 data-nosnippet>101</a> <span class="kw-2">*</span>d = q;
<a href=#102 id=102 data-nosnippet>102</a> rem = r;
<a href=#103 id=103 data-nosnippet>103</a> }
<a href=#104 id=104 data-nosnippet>104</a> }
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a> (a.normalized(), rem)
<a href=#107 id=107 data-nosnippet>107</a>}
<a href=#108 id=108 data-nosnippet>108</a>
<a href=#109 id=109 data-nosnippet>109</a><span class="attr">#[inline]
<a href=#110 id=110 data-nosnippet>110</a></span><span class="kw">fn </span>rem_digit(a: <span class="kw-2">&amp;</span>BigUint, b: BigDigit) -&gt; BigDigit {
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">if </span>b == <span class="number">0 </span>{
<a href=#112 id=112 data-nosnippet>112</a> <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>)
<a href=#113 id=113 data-nosnippet>113</a> }
<a href=#114 id=114 data-nosnippet>114</a>
<a href=#115 id=115 data-nosnippet>115</a> <span class="kw">let </span><span class="kw-2">mut </span>rem = <span class="number">0</span>;
<a href=#116 id=116 data-nosnippet>116</a>
<a href=#117 id=117 data-nosnippet>117</a> <span class="kw">if </span>!FAST_DIV_WIDE &amp;&amp; b &lt;= big_digit::HALF {
<a href=#118 id=118 data-nosnippet>118</a> <span class="kw">for </span><span class="kw-2">&amp;</span>digit <span class="kw">in </span>a.data.iter().rev() {
<a href=#119 id=119 data-nosnippet>119</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = div_half(rem, digit, b);
<a href=#120 id=120 data-nosnippet>120</a> rem = r;
<a href=#121 id=121 data-nosnippet>121</a> }
<a href=#122 id=122 data-nosnippet>122</a> } <span class="kw">else </span>{
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">for </span><span class="kw-2">&amp;</span>digit <span class="kw">in </span>a.data.iter().rev() {
<a href=#124 id=124 data-nosnippet>124</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = div_wide(rem, digit, b);
<a href=#125 id=125 data-nosnippet>125</a> rem = r;
<a href=#126 id=126 data-nosnippet>126</a> }
<a href=#127 id=127 data-nosnippet>127</a> }
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a> rem
<a href=#130 id=130 data-nosnippet>130</a>}
<a href=#131 id=131 data-nosnippet>131</a>
<a href=#132 id=132 data-nosnippet>132</a><span class="doccomment">/// Subtract a multiple.
<a href=#133 id=133 data-nosnippet>133</a>/// a -= b * c
<a href=#134 id=134 data-nosnippet>134</a>/// Returns a borrow (if a &lt; b then borrow &gt; 0).
<a href=#135 id=135 data-nosnippet>135</a></span><span class="kw">fn </span>sub_mul_digit_same_len(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit], c: BigDigit) -&gt; BigDigit {
<a href=#136 id=136 data-nosnippet>136</a> <span class="macro">debug_assert!</span>(a.len() == b.len());
<a href=#137 id=137 data-nosnippet>137</a>
<a href=#138 id=138 data-nosnippet>138</a> <span class="comment">// carry is between -big_digit::MAX and 0, so to avoid overflow we store
<a href=#139 id=139 data-nosnippet>139</a> // offset_carry = carry + big_digit::MAX
<a href=#140 id=140 data-nosnippet>140</a> </span><span class="kw">let </span><span class="kw-2">mut </span>offset_carry = big_digit::MAX;
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">for </span>(x, y) <span class="kw">in </span>a.iter_mut().zip(b) {
<a href=#143 id=143 data-nosnippet>143</a> <span class="comment">// We want to calculate sum = x - y * c + carry.
<a href=#144 id=144 data-nosnippet>144</a> // sum &gt;= -(big_digit::MAX * big_digit::MAX) - big_digit::MAX
<a href=#145 id=145 data-nosnippet>145</a> // sum &lt;= big_digit::MAX
<a href=#146 id=146 data-nosnippet>146</a> // Offsetting sum by (big_digit::MAX &lt;&lt; big_digit::BITS) puts it in DoubleBigDigit range.
<a href=#147 id=147 data-nosnippet>147</a> </span><span class="kw">let </span>offset_sum = big_digit::to_doublebigdigit(big_digit::MAX, <span class="kw-2">*</span>x)
<a href=#148 id=148 data-nosnippet>148</a> - big_digit::MAX <span class="kw">as </span>DoubleBigDigit
<a href=#149 id=149 data-nosnippet>149</a> + offset_carry <span class="kw">as </span>DoubleBigDigit
<a href=#150 id=150 data-nosnippet>150</a> - <span class="kw-2">*</span>y <span class="kw">as </span>DoubleBigDigit * c <span class="kw">as </span>DoubleBigDigit;
<a href=#151 id=151 data-nosnippet>151</a>
<a href=#152 id=152 data-nosnippet>152</a> <span class="kw">let </span>(new_offset_carry, new_x) = big_digit::from_doublebigdigit(offset_sum);
<a href=#153 id=153 data-nosnippet>153</a> offset_carry = new_offset_carry;
<a href=#154 id=154 data-nosnippet>154</a> <span class="kw-2">*</span>x = new_x;
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a>
<a href=#157 id=157 data-nosnippet>157</a> <span class="comment">// Return the borrow.
<a href=#158 id=158 data-nosnippet>158</a> </span>big_digit::MAX - offset_carry
<a href=#159 id=159 data-nosnippet>159</a>}
<a href=#160 id=160 data-nosnippet>160</a>
<a href=#161 id=161 data-nosnippet>161</a><span class="kw">fn </span>div_rem(<span class="kw-2">mut </span>u: BigUint, <span class="kw-2">mut </span>d: BigUint) -&gt; (BigUint, BigUint) {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">if </span>d.is_zero() {
<a href=#163 id=163 data-nosnippet>163</a> <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>)
<a href=#164 id=164 data-nosnippet>164</a> }
<a href=#165 id=165 data-nosnippet>165</a> <span class="kw">if </span>u.is_zero() {
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">return </span>(BigUint::ZERO, BigUint::ZERO);
<a href=#167 id=167 data-nosnippet>167</a> }
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">if </span>d.data.len() == <span class="number">1 </span>{
<a href=#170 id=170 data-nosnippet>170</a> <span class="kw">if </span>d.data == [<span class="number">1</span>] {
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">return </span>(u, BigUint::ZERO);
<a href=#172 id=172 data-nosnippet>172</a> }
<a href=#173 id=173 data-nosnippet>173</a> <span class="kw">let </span>(div, rem) = div_rem_digit(u, d.data[<span class="number">0</span>]);
<a href=#174 id=174 data-nosnippet>174</a> <span class="comment">// reuse d
<a href=#175 id=175 data-nosnippet>175</a> </span>d.data.clear();
<a href=#176 id=176 data-nosnippet>176</a> d += rem;
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">return </span>(div, d);
<a href=#178 id=178 data-nosnippet>178</a> }
<a href=#179 id=179 data-nosnippet>179</a>
<a href=#180 id=180 data-nosnippet>180</a> <span class="comment">// Required or the q_len calculation below can underflow:
<a href=#181 id=181 data-nosnippet>181</a> </span><span class="kw">match </span>u.cmp(<span class="kw-2">&amp;</span>d) {
<a href=#182 id=182 data-nosnippet>182</a> Less =&gt; <span class="kw">return </span>(BigUint::ZERO, u),
<a href=#183 id=183 data-nosnippet>183</a> Equal =&gt; {
<a href=#184 id=184 data-nosnippet>184</a> u.set_one();
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">return </span>(u, BigUint::ZERO);
<a href=#186 id=186 data-nosnippet>186</a> }
<a href=#187 id=187 data-nosnippet>187</a> Greater =&gt; {} <span class="comment">// Do nothing
<a href=#188 id=188 data-nosnippet>188</a> </span>}
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a> <span class="comment">// This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D:
<a href=#191 id=191 data-nosnippet>191</a> //
<a href=#192 id=192 data-nosnippet>192</a> // First, normalize the arguments so the highest bit in the highest digit of the divisor is
<a href=#193 id=193 data-nosnippet>193</a> // set: the main loop uses the highest digit of the divisor for generating guesses, so we
<a href=#194 id=194 data-nosnippet>194</a> // want it to be the largest number we can efficiently divide by.
<a href=#195 id=195 data-nosnippet>195</a> //
<a href=#196 id=196 data-nosnippet>196</a> </span><span class="kw">let </span>shift = d.data.last().unwrap().leading_zeros() <span class="kw">as </span>usize;
<a href=#197 id=197 data-nosnippet>197</a>
<a href=#198 id=198 data-nosnippet>198</a> <span class="kw">if </span>shift == <span class="number">0 </span>{
<a href=#199 id=199 data-nosnippet>199</a> <span class="comment">// no need to clone d
<a href=#200 id=200 data-nosnippet>200</a> </span>div_rem_core(u, <span class="kw-2">&amp;</span>d.data)
<a href=#201 id=201 data-nosnippet>201</a> } <span class="kw">else </span>{
<a href=#202 id=202 data-nosnippet>202</a> <span class="kw">let </span>(q, r) = div_rem_core(u &lt;&lt; shift, <span class="kw-2">&amp;</span>(d &lt;&lt; shift).data);
<a href=#203 id=203 data-nosnippet>203</a> <span class="comment">// renormalize the remainder
<a href=#204 id=204 data-nosnippet>204</a> </span>(q, r &gt;&gt; shift)
<a href=#205 id=205 data-nosnippet>205</a> }
<a href=#206 id=206 data-nosnippet>206</a>}
<a href=#207 id=207 data-nosnippet>207</a>
<a href=#208 id=208 data-nosnippet>208</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>div_rem_ref(u: <span class="kw-2">&amp;</span>BigUint, d: <span class="kw-2">&amp;</span>BigUint) -&gt; (BigUint, BigUint) {
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">if </span>d.is_zero() {
<a href=#210 id=210 data-nosnippet>210</a> <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>)
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a> <span class="kw">if </span>u.is_zero() {
<a href=#213 id=213 data-nosnippet>213</a> <span class="kw">return </span>(BigUint::ZERO, BigUint::ZERO);
<a href=#214 id=214 data-nosnippet>214</a> }
<a href=#215 id=215 data-nosnippet>215</a>
<a href=#216 id=216 data-nosnippet>216</a> <span class="kw">if </span>d.data.len() == <span class="number">1 </span>{
<a href=#217 id=217 data-nosnippet>217</a> <span class="kw">if </span>d.data == [<span class="number">1</span>] {
<a href=#218 id=218 data-nosnippet>218</a> <span class="kw">return </span>(u.clone(), BigUint::ZERO);
<a href=#219 id=219 data-nosnippet>219</a> }
<a href=#220 id=220 data-nosnippet>220</a>
<a href=#221 id=221 data-nosnippet>221</a> <span class="kw">let </span>(div, rem) = div_rem_digit(u.clone(), d.data[<span class="number">0</span>]);
<a href=#222 id=222 data-nosnippet>222</a> <span class="kw">return </span>(div, rem.into());
<a href=#223 id=223 data-nosnippet>223</a> }
<a href=#224 id=224 data-nosnippet>224</a>
<a href=#225 id=225 data-nosnippet>225</a> <span class="comment">// Required or the q_len calculation below can underflow:
<a href=#226 id=226 data-nosnippet>226</a> </span><span class="kw">match </span>u.cmp(d) {
<a href=#227 id=227 data-nosnippet>227</a> Less =&gt; <span class="kw">return </span>(BigUint::ZERO, u.clone()),
<a href=#228 id=228 data-nosnippet>228</a> Equal =&gt; <span class="kw">return </span>(One::one(), BigUint::ZERO),
<a href=#229 id=229 data-nosnippet>229</a> Greater =&gt; {} <span class="comment">// Do nothing
<a href=#230 id=230 data-nosnippet>230</a> </span>}
<a href=#231 id=231 data-nosnippet>231</a>
<a href=#232 id=232 data-nosnippet>232</a> <span class="comment">// This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D:
<a href=#233 id=233 data-nosnippet>233</a> //
<a href=#234 id=234 data-nosnippet>234</a> // First, normalize the arguments so the highest bit in the highest digit of the divisor is
<a href=#235 id=235 data-nosnippet>235</a> // set: the main loop uses the highest digit of the divisor for generating guesses, so we
<a href=#236 id=236 data-nosnippet>236</a> // want it to be the largest number we can efficiently divide by.
<a href=#237 id=237 data-nosnippet>237</a> //
<a href=#238 id=238 data-nosnippet>238</a> </span><span class="kw">let </span>shift = d.data.last().unwrap().leading_zeros() <span class="kw">as </span>usize;
<a href=#239 id=239 data-nosnippet>239</a>
<a href=#240 id=240 data-nosnippet>240</a> <span class="kw">if </span>shift == <span class="number">0 </span>{
<a href=#241 id=241 data-nosnippet>241</a> <span class="comment">// no need to clone d
<a href=#242 id=242 data-nosnippet>242</a> </span>div_rem_core(u.clone(), <span class="kw-2">&amp;</span>d.data)
<a href=#243 id=243 data-nosnippet>243</a> } <span class="kw">else </span>{
<a href=#244 id=244 data-nosnippet>244</a> <span class="kw">let </span>(q, r) = div_rem_core(u &lt;&lt; shift, <span class="kw-2">&amp;</span>(d &lt;&lt; shift).data);
<a href=#245 id=245 data-nosnippet>245</a> <span class="comment">// renormalize the remainder
<a href=#246 id=246 data-nosnippet>246</a> </span>(q, r &gt;&gt; shift)
<a href=#247 id=247 data-nosnippet>247</a> }
<a href=#248 id=248 data-nosnippet>248</a>}
<a href=#249 id=249 data-nosnippet>249</a>
<a href=#250 id=250 data-nosnippet>250</a><span class="doccomment">/// An implementation of the base division algorithm.
<a href=#251 id=251 data-nosnippet>251</a>/// Knuth, TAOCP vol 2 section 4.3.1, algorithm D, with an improvement from exercises 19-21.
<a href=#252 id=252 data-nosnippet>252</a></span><span class="kw">fn </span>div_rem_core(<span class="kw-2">mut </span>a: BigUint, b: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; (BigUint, BigUint) {
<a href=#253 id=253 data-nosnippet>253</a> <span class="macro">debug_assert!</span>(a.data.len() &gt;= b.len() &amp;&amp; b.len() &gt; <span class="number">1</span>);
<a href=#254 id=254 data-nosnippet>254</a> <span class="macro">debug_assert!</span>(b.last().unwrap().leading_zeros() == <span class="number">0</span>);
<a href=#255 id=255 data-nosnippet>255</a>
<a href=#256 id=256 data-nosnippet>256</a> <span class="comment">// The algorithm works by incrementally calculating "guesses", q0, for the next digit of the
<a href=#257 id=257 data-nosnippet>257</a> // quotient. Once we have any number q0 such that (q0 &lt;&lt; j) * b &lt;= a, we can set
<a href=#258 id=258 data-nosnippet>258</a> //
<a href=#259 id=259 data-nosnippet>259</a> // q += q0 &lt;&lt; j
<a href=#260 id=260 data-nosnippet>260</a> // a -= (q0 &lt;&lt; j) * b
<a href=#261 id=261 data-nosnippet>261</a> //
<a href=#262 id=262 data-nosnippet>262</a> // and then iterate until a &lt; b. Then, (q, a) will be our desired quotient and remainder.
<a href=#263 id=263 data-nosnippet>263</a> //
<a href=#264 id=264 data-nosnippet>264</a> // q0, our guess, is calculated by dividing the last three digits of a by the last two digits of
<a href=#265 id=265 data-nosnippet>265</a> // b - this will give us a guess that is close to the actual quotient, but is possibly greater.
<a href=#266 id=266 data-nosnippet>266</a> // It can only be greater by 1 and only in rare cases, with probability at most
<a href=#267 id=267 data-nosnippet>267</a> // 2^-(big_digit::BITS-1) for random a, see TAOCP 4.3.1 exercise 21.
<a href=#268 id=268 data-nosnippet>268</a> //
<a href=#269 id=269 data-nosnippet>269</a> // If the quotient turns out to be too large, we adjust it by 1:
<a href=#270 id=270 data-nosnippet>270</a> // q -= 1 &lt;&lt; j
<a href=#271 id=271 data-nosnippet>271</a> // a += b &lt;&lt; j
<a href=#272 id=272 data-nosnippet>272</a>
<a href=#273 id=273 data-nosnippet>273</a> // a0 stores an additional extra most significant digit of the dividend, not stored in a.
<a href=#274 id=274 data-nosnippet>274</a> </span><span class="kw">let </span><span class="kw-2">mut </span>a0 = <span class="number">0</span>;
<a href=#275 id=275 data-nosnippet>275</a>
<a href=#276 id=276 data-nosnippet>276</a> <span class="comment">// [b1, b0] are the two most significant digits of the divisor. They never change.
<a href=#277 id=277 data-nosnippet>277</a> </span><span class="kw">let </span>b0 = b[b.len() - <span class="number">1</span>];
<a href=#278 id=278 data-nosnippet>278</a> <span class="kw">let </span>b1 = b[b.len() - <span class="number">2</span>];
<a href=#279 id=279 data-nosnippet>279</a>
<a href=#280 id=280 data-nosnippet>280</a> <span class="kw">let </span>q_len = a.data.len() - b.len() + <span class="number">1</span>;
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">let </span><span class="kw-2">mut </span>q = BigUint {
<a href=#282 id=282 data-nosnippet>282</a> data: <span class="macro">vec!</span>[<span class="number">0</span>; q_len],
<a href=#283 id=283 data-nosnippet>283</a> };
<a href=#284 id=284 data-nosnippet>284</a>
<a href=#285 id=285 data-nosnippet>285</a> <span class="kw">for </span>j <span class="kw">in </span>(<span class="number">0</span>..q_len).rev() {
<a href=#286 id=286 data-nosnippet>286</a> <span class="macro">debug_assert!</span>(a.data.len() == b.len() + j);
<a href=#287 id=287 data-nosnippet>287</a>
<a href=#288 id=288 data-nosnippet>288</a> <span class="kw">let </span>a1 = <span class="kw-2">*</span>a.data.last().unwrap();
<a href=#289 id=289 data-nosnippet>289</a> <span class="kw">let </span>a2 = a.data[a.data.len() - <span class="number">2</span>];
<a href=#290 id=290 data-nosnippet>290</a>
<a href=#291 id=291 data-nosnippet>291</a> <span class="comment">// The first q0 estimate is [a1,a0] / b0. It will never be too small, it may be too large
<a href=#292 id=292 data-nosnippet>292</a> // by at most 2.
<a href=#293 id=293 data-nosnippet>293</a> </span><span class="kw">let </span>(<span class="kw-2">mut </span>q0, <span class="kw-2">mut </span>r) = <span class="kw">if </span>a0 &lt; b0 {
<a href=#294 id=294 data-nosnippet>294</a> <span class="kw">let </span>(q0, r) = div_wide(a0, a1, b0);
<a href=#295 id=295 data-nosnippet>295</a> (q0, r <span class="kw">as </span>DoubleBigDigit)
<a href=#296 id=296 data-nosnippet>296</a> } <span class="kw">else </span>{
<a href=#297 id=297 data-nosnippet>297</a> <span class="macro">debug_assert!</span>(a0 == b0);
<a href=#298 id=298 data-nosnippet>298</a> <span class="comment">// Avoid overflowing q0, we know the quotient fits in BigDigit.
<a href=#299 id=299 data-nosnippet>299</a> // [a1,a0] = b0 * (1&lt;&lt;BITS - 1) + (a0 + a1)
<a href=#300 id=300 data-nosnippet>300</a> </span>(big_digit::MAX, a0 <span class="kw">as </span>DoubleBigDigit + a1 <span class="kw">as </span>DoubleBigDigit)
<a href=#301 id=301 data-nosnippet>301</a> };
<a href=#302 id=302 data-nosnippet>302</a>
<a href=#303 id=303 data-nosnippet>303</a> <span class="comment">// r = [a1,a0] - q0 * b0
<a href=#304 id=304 data-nosnippet>304</a> //
<a href=#305 id=305 data-nosnippet>305</a> // Now we want to compute a more precise estimate [a2,a1,a0] / [b1,b0] which can only be
<a href=#306 id=306 data-nosnippet>306</a> // less or equal to the current q0.
<a href=#307 id=307 data-nosnippet>307</a> //
<a href=#308 id=308 data-nosnippet>308</a> // q0 is too large if:
<a href=#309 id=309 data-nosnippet>309</a> // [a2,a1,a0] &lt; q0 * [b1,b0]
<a href=#310 id=310 data-nosnippet>310</a> // (r &lt;&lt; BITS) + a2 &lt; q0 * b1
<a href=#311 id=311 data-nosnippet>311</a> </span><span class="kw">while </span>r &lt;= big_digit::MAX <span class="kw">as </span>DoubleBigDigit
<a href=#312 id=312 data-nosnippet>312</a> &amp;&amp; big_digit::to_doublebigdigit(r <span class="kw">as </span>BigDigit, a2)
<a href=#313 id=313 data-nosnippet>313</a> &lt; q0 <span class="kw">as </span>DoubleBigDigit * b1 <span class="kw">as </span>DoubleBigDigit
<a href=#314 id=314 data-nosnippet>314</a> {
<a href=#315 id=315 data-nosnippet>315</a> q0 -= <span class="number">1</span>;
<a href=#316 id=316 data-nosnippet>316</a> r += b0 <span class="kw">as </span>DoubleBigDigit;
<a href=#317 id=317 data-nosnippet>317</a> }
<a href=#318 id=318 data-nosnippet>318</a>
<a href=#319 id=319 data-nosnippet>319</a> <span class="comment">// q0 is now either the correct quotient digit, or in rare cases 1 too large.
<a href=#320 id=320 data-nosnippet>320</a> // Subtract (q0 &lt;&lt; j) from a. This may overflow, in which case we will have to correct.
<a href=#321 id=321 data-nosnippet>321</a>
<a href=#322 id=322 data-nosnippet>322</a> </span><span class="kw">let </span><span class="kw-2">mut </span>borrow = sub_mul_digit_same_len(<span class="kw-2">&amp;mut </span>a.data[j..], b, q0);
<a href=#323 id=323 data-nosnippet>323</a> <span class="kw">if </span>borrow &gt; a0 {
<a href=#324 id=324 data-nosnippet>324</a> <span class="comment">// q0 is too large. We need to add back one multiple of b.
<a href=#325 id=325 data-nosnippet>325</a> </span>q0 -= <span class="number">1</span>;
<a href=#326 id=326 data-nosnippet>326</a> borrow -= __add2(<span class="kw-2">&amp;mut </span>a.data[j..], b);
<a href=#327 id=327 data-nosnippet>327</a> }
<a href=#328 id=328 data-nosnippet>328</a> <span class="comment">// The top digit of a, stored in a0, has now been zeroed.
<a href=#329 id=329 data-nosnippet>329</a> </span><span class="macro">debug_assert!</span>(borrow == a0);
<a href=#330 id=330 data-nosnippet>330</a>
<a href=#331 id=331 data-nosnippet>331</a> q.data[j] = q0;
<a href=#332 id=332 data-nosnippet>332</a>
<a href=#333 id=333 data-nosnippet>333</a> <span class="comment">// Pop off the next top digit of a.
<a href=#334 id=334 data-nosnippet>334</a> </span>a0 = a.data.pop().unwrap();
<a href=#335 id=335 data-nosnippet>335</a> }
<a href=#336 id=336 data-nosnippet>336</a>
<a href=#337 id=337 data-nosnippet>337</a> a.data.push(a0);
<a href=#338 id=338 data-nosnippet>338</a> a.normalize();
<a href=#339 id=339 data-nosnippet>339</a>
<a href=#340 id=340 data-nosnippet>340</a> <span class="macro">debug_assert_eq!</span>(cmp_slice(<span class="kw-2">&amp;</span>a.data, b), Less);
<a href=#341 id=341 data-nosnippet>341</a>
<a href=#342 id=342 data-nosnippet>342</a> (q.normalized(), a)
<a href=#343 id=343 data-nosnippet>343</a>}
<a href=#344 id=344 data-nosnippet>344</a>
<a href=#345 id=345 data-nosnippet>345</a><span class="macro">forward_val_ref_binop!</span>(<span class="kw">impl </span>Div <span class="kw">for </span>BigUint, div);
<a href=#346 id=346 data-nosnippet>346</a><span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span>Div <span class="kw">for </span>BigUint, div);
<a href=#347 id=347 data-nosnippet>347</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>DivAssign <span class="kw">for </span>BigUint, div_assign);
<a href=#348 id=348 data-nosnippet>348</a>
<a href=#349 id=349 data-nosnippet>349</a><span class="kw">impl </span>Div&lt;BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#350 id=350 data-nosnippet>350</a> <span class="kw">type </span>Output = BigUint;
<a href=#351 id=351 data-nosnippet>351</a>
<a href=#352 id=352 data-nosnippet>352</a> <span class="attr">#[inline]
<a href=#353 id=353 data-nosnippet>353</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#354 id=354 data-nosnippet>354</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = div_rem(<span class="self">self</span>, other);
<a href=#355 id=355 data-nosnippet>355</a> q
<a href=#356 id=356 data-nosnippet>356</a> }
<a href=#357 id=357 data-nosnippet>357</a>}
<a href=#358 id=358 data-nosnippet>358</a>
<a href=#359 id=359 data-nosnippet>359</a><span class="kw">impl </span>Div&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#360 id=360 data-nosnippet>360</a> <span class="kw">type </span>Output = BigUint;
<a href=#361 id=361 data-nosnippet>361</a>
<a href=#362 id=362 data-nosnippet>362</a> <span class="attr">#[inline]
<a href=#363 id=363 data-nosnippet>363</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#364 id=364 data-nosnippet>364</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = <span class="self">self</span>.div_rem(other);
<a href=#365 id=365 data-nosnippet>365</a> q
<a href=#366 id=366 data-nosnippet>366</a> }
<a href=#367 id=367 data-nosnippet>367</a>}
<a href=#368 id=368 data-nosnippet>368</a><span class="kw">impl </span>DivAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#369 id=369 data-nosnippet>369</a> <span class="attr">#[inline]
<a href=#370 id=370 data-nosnippet>370</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#371 id=371 data-nosnippet>371</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>/ other;
<a href=#372 id=372 data-nosnippet>372</a> }
<a href=#373 id=373 data-nosnippet>373</a>}
<a href=#374 id=374 data-nosnippet>374</a>
<a href=#375 id=375 data-nosnippet>375</a><span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span>Div <span class="kw">for </span>BigUint, div);
<a href=#376 id=376 data-nosnippet>376</a><span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span>DivAssign <span class="kw">for </span>BigUint, div_assign);
<a href=#377 id=377 data-nosnippet>377</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u32&gt; <span class="kw">for </span>BigUint, div);
<a href=#378 id=378 data-nosnippet>378</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u64&gt; <span class="kw">for </span>BigUint, div);
<a href=#379 id=379 data-nosnippet>379</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Div&lt;u128&gt; <span class="kw">for </span>BigUint, div);
<a href=#380 id=380 data-nosnippet>380</a>
<a href=#381 id=381 data-nosnippet>381</a><span class="kw">impl </span>Div&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#382 id=382 data-nosnippet>382</a> <span class="kw">type </span>Output = BigUint;
<a href=#383 id=383 data-nosnippet>383</a>
<a href=#384 id=384 data-nosnippet>384</a> <span class="attr">#[inline]
<a href=#385 id=385 data-nosnippet>385</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u32) -&gt; BigUint {
<a href=#386 id=386 data-nosnippet>386</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = div_rem_digit(<span class="self">self</span>, other <span class="kw">as </span>BigDigit);
<a href=#387 id=387 data-nosnippet>387</a> q
<a href=#388 id=388 data-nosnippet>388</a> }
<a href=#389 id=389 data-nosnippet>389</a>}
<a href=#390 id=390 data-nosnippet>390</a><span class="kw">impl </span>DivAssign&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#391 id=391 data-nosnippet>391</a> <span class="attr">#[inline]
<a href=#392 id=392 data-nosnippet>392</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#393 id=393 data-nosnippet>393</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>/ other;
<a href=#394 id=394 data-nosnippet>394</a> }
<a href=#395 id=395 data-nosnippet>395</a>}
<a href=#396 id=396 data-nosnippet>396</a>
<a href=#397 id=397 data-nosnippet>397</a><span class="kw">impl </span>Div&lt;BigUint&gt; <span class="kw">for </span>u32 {
<a href=#398 id=398 data-nosnippet>398</a> <span class="kw">type </span>Output = BigUint;
<a href=#399 id=399 data-nosnippet>399</a>
<a href=#400 id=400 data-nosnippet>400</a> <span class="attr">#[inline]
<a href=#401 id=401 data-nosnippet>401</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#402 id=402 data-nosnippet>402</a> <span class="kw">match </span>other.data.len() {
<a href=#403 id=403 data-nosnippet>403</a> <span class="number">0 </span>=&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#404 id=404 data-nosnippet>404</a> <span class="number">1 </span>=&gt; From::from(<span class="self">self </span><span class="kw">as </span>BigDigit / other.data[<span class="number">0</span>]),
<a href=#405 id=405 data-nosnippet>405</a> <span class="kw">_ </span>=&gt; BigUint::ZERO,
<a href=#406 id=406 data-nosnippet>406</a> }
<a href=#407 id=407 data-nosnippet>407</a> }
<a href=#408 id=408 data-nosnippet>408</a>}
<a href=#409 id=409 data-nosnippet>409</a>
<a href=#410 id=410 data-nosnippet>410</a><span class="kw">impl </span>Div&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#411 id=411 data-nosnippet>411</a> <span class="kw">type </span>Output = BigUint;
<a href=#412 id=412 data-nosnippet>412</a>
<a href=#413 id=413 data-nosnippet>413</a> <span class="attr">#[inline]
<a href=#414 id=414 data-nosnippet>414</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u64) -&gt; BigUint {
<a href=#415 id=415 data-nosnippet>415</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = div_rem(<span class="self">self</span>, From::from(other));
<a href=#416 id=416 data-nosnippet>416</a> q
<a href=#417 id=417 data-nosnippet>417</a> }
<a href=#418 id=418 data-nosnippet>418</a>}
<a href=#419 id=419 data-nosnippet>419</a><span class="kw">impl </span>DivAssign&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#420 id=420 data-nosnippet>420</a> <span class="attr">#[inline]
<a href=#421 id=421 data-nosnippet>421</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#422 id=422 data-nosnippet>422</a> <span class="comment">// a vec of size 0 does not allocate, so this is fairly cheap
<a href=#423 id=423 data-nosnippet>423</a> </span><span class="kw">let </span>temp = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#424 id=424 data-nosnippet>424</a> <span class="kw-2">*</span><span class="self">self </span>= temp / other;
<a href=#425 id=425 data-nosnippet>425</a> }
<a href=#426 id=426 data-nosnippet>426</a>}
<a href=#427 id=427 data-nosnippet>427</a>
<a href=#428 id=428 data-nosnippet>428</a><span class="kw">impl </span>Div&lt;BigUint&gt; <span class="kw">for </span>u64 {
<a href=#429 id=429 data-nosnippet>429</a> <span class="kw">type </span>Output = BigUint;
<a href=#430 id=430 data-nosnippet>430</a>
<a href=#431 id=431 data-nosnippet>431</a> <span class="macro">cfg_digit!</span>(
<a href=#432 id=432 data-nosnippet>432</a> <span class="attr">#[inline]
<a href=#433 id=433 data-nosnippet>433</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#434 id=434 data-nosnippet>434</a> <span class="kw">match </span>other.data.len() {
<a href=#435 id=435 data-nosnippet>435</a> <span class="number">0 </span>=&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#436 id=436 data-nosnippet>436</a> <span class="number">1 </span>=&gt; From::from(<span class="self">self </span>/ u64::from(other.data[<span class="number">0</span>])),
<a href=#437 id=437 data-nosnippet>437</a> <span class="number">2 </span>=&gt; From::from(<span class="self">self </span>/ big_digit::to_doublebigdigit(other.data[<span class="number">1</span>], other.data[<span class="number">0</span>])),
<a href=#438 id=438 data-nosnippet>438</a> <span class="kw">_ </span>=&gt; BigUint::ZERO,
<a href=#439 id=439 data-nosnippet>439</a> }
<a href=#440 id=440 data-nosnippet>440</a> }
<a href=#441 id=441 data-nosnippet>441</a>
<a href=#442 id=442 data-nosnippet>442</a> <span class="attr">#[inline]
<a href=#443 id=443 data-nosnippet>443</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#444 id=444 data-nosnippet>444</a> <span class="kw">match </span>other.data.len() {
<a href=#445 id=445 data-nosnippet>445</a> <span class="number">0 </span>=&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#446 id=446 data-nosnippet>446</a> <span class="number">1 </span>=&gt; From::from(<span class="self">self </span>/ other.data[<span class="number">0</span>]),
<a href=#447 id=447 data-nosnippet>447</a> <span class="kw">_ </span>=&gt; BigUint::ZERO,
<a href=#448 id=448 data-nosnippet>448</a> }
<a href=#449 id=449 data-nosnippet>449</a> }
<a href=#450 id=450 data-nosnippet>450</a> );
<a href=#451 id=451 data-nosnippet>451</a>}
<a href=#452 id=452 data-nosnippet>452</a>
<a href=#453 id=453 data-nosnippet>453</a><span class="kw">impl </span>Div&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#454 id=454 data-nosnippet>454</a> <span class="kw">type </span>Output = BigUint;
<a href=#455 id=455 data-nosnippet>455</a>
<a href=#456 id=456 data-nosnippet>456</a> <span class="attr">#[inline]
<a href=#457 id=457 data-nosnippet>457</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: u128) -&gt; BigUint {
<a href=#458 id=458 data-nosnippet>458</a> <span class="kw">let </span>(q, <span class="kw">_</span>) = div_rem(<span class="self">self</span>, From::from(other));
<a href=#459 id=459 data-nosnippet>459</a> q
<a href=#460 id=460 data-nosnippet>460</a> }
<a href=#461 id=461 data-nosnippet>461</a>}
<a href=#462 id=462 data-nosnippet>462</a>
<a href=#463 id=463 data-nosnippet>463</a><span class="kw">impl </span>DivAssign&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#464 id=464 data-nosnippet>464</a> <span class="attr">#[inline]
<a href=#465 id=465 data-nosnippet>465</a> </span><span class="kw">fn </span>div_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#466 id=466 data-nosnippet>466</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>/ other;
<a href=#467 id=467 data-nosnippet>467</a> }
<a href=#468 id=468 data-nosnippet>468</a>}
<a href=#469 id=469 data-nosnippet>469</a>
<a href=#470 id=470 data-nosnippet>470</a><span class="kw">impl </span>Div&lt;BigUint&gt; <span class="kw">for </span>u128 {
<a href=#471 id=471 data-nosnippet>471</a> <span class="kw">type </span>Output = BigUint;
<a href=#472 id=472 data-nosnippet>472</a>
<a href=#473 id=473 data-nosnippet>473</a> <span class="macro">cfg_digit!</span>(
<a href=#474 id=474 data-nosnippet>474</a> <span class="attr">#[inline]
<a href=#475 id=475 data-nosnippet>475</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#476 id=476 data-nosnippet>476</a> <span class="kw">use </span><span class="kw">super</span>::u32_to_u128;
<a href=#477 id=477 data-nosnippet>477</a> <span class="kw">match </span>other.data.len() {
<a href=#478 id=478 data-nosnippet>478</a> <span class="number">0 </span>=&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#479 id=479 data-nosnippet>479</a> <span class="number">1 </span>=&gt; From::from(<span class="self">self </span>/ u128::from(other.data[<span class="number">0</span>])),
<a href=#480 id=480 data-nosnippet>480</a> <span class="number">2 </span>=&gt; From::from(
<a href=#481 id=481 data-nosnippet>481</a> <span class="self">self </span>/ u128::from(big_digit::to_doublebigdigit(other.data[<span class="number">1</span>], other.data[<span class="number">0</span>])),
<a href=#482 id=482 data-nosnippet>482</a> ),
<a href=#483 id=483 data-nosnippet>483</a> <span class="number">3 </span>=&gt; From::from(<span class="self">self </span>/ u32_to_u128(<span class="number">0</span>, other.data[<span class="number">2</span>], other.data[<span class="number">1</span>], other.data[<span class="number">0</span>])),
<a href=#484 id=484 data-nosnippet>484</a> <span class="number">4 </span>=&gt; From::from(
<a href=#485 id=485 data-nosnippet>485</a> <span class="self">self </span>/ u32_to_u128(other.data[<span class="number">3</span>], other.data[<span class="number">2</span>], other.data[<span class="number">1</span>], other.data[<span class="number">0</span>]),
<a href=#486 id=486 data-nosnippet>486</a> ),
<a href=#487 id=487 data-nosnippet>487</a> <span class="kw">_ </span>=&gt; BigUint::ZERO,
<a href=#488 id=488 data-nosnippet>488</a> }
<a href=#489 id=489 data-nosnippet>489</a> }
<a href=#490 id=490 data-nosnippet>490</a>
<a href=#491 id=491 data-nosnippet>491</a> <span class="attr">#[inline]
<a href=#492 id=492 data-nosnippet>492</a> </span><span class="kw">fn </span>div(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#493 id=493 data-nosnippet>493</a> <span class="kw">match </span>other.data.len() {
<a href=#494 id=494 data-nosnippet>494</a> <span class="number">0 </span>=&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#495 id=495 data-nosnippet>495</a> <span class="number">1 </span>=&gt; From::from(<span class="self">self </span>/ other.data[<span class="number">0</span>] <span class="kw">as </span>u128),
<a href=#496 id=496 data-nosnippet>496</a> <span class="number">2 </span>=&gt; From::from(<span class="self">self </span>/ big_digit::to_doublebigdigit(other.data[<span class="number">1</span>], other.data[<span class="number">0</span>])),
<a href=#497 id=497 data-nosnippet>497</a> <span class="kw">_ </span>=&gt; BigUint::ZERO,
<a href=#498 id=498 data-nosnippet>498</a> }
<a href=#499 id=499 data-nosnippet>499</a> }
<a href=#500 id=500 data-nosnippet>500</a> );
<a href=#501 id=501 data-nosnippet>501</a>}
<a href=#502 id=502 data-nosnippet>502</a>
<a href=#503 id=503 data-nosnippet>503</a><span class="macro">forward_val_ref_binop!</span>(<span class="kw">impl </span>Rem <span class="kw">for </span>BigUint, rem);
<a href=#504 id=504 data-nosnippet>504</a><span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span>Rem <span class="kw">for </span>BigUint, rem);
<a href=#505 id=505 data-nosnippet>505</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>RemAssign <span class="kw">for </span>BigUint, rem_assign);
<a href=#506 id=506 data-nosnippet>506</a>
<a href=#507 id=507 data-nosnippet>507</a><span class="kw">impl </span>Rem&lt;BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#508 id=508 data-nosnippet>508</a> <span class="kw">type </span>Output = BigUint;
<a href=#509 id=509 data-nosnippet>509</a>
<a href=#510 id=510 data-nosnippet>510</a> <span class="attr">#[inline]
<a href=#511 id=511 data-nosnippet>511</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#512 id=512 data-nosnippet>512</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = other.to_u32() {
<a href=#513 id=513 data-nosnippet>513</a> <span class="kw-2">&amp;</span><span class="self">self </span>% other
<a href=#514 id=514 data-nosnippet>514</a> } <span class="kw">else </span>{
<a href=#515 id=515 data-nosnippet>515</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = div_rem(<span class="self">self</span>, other);
<a href=#516 id=516 data-nosnippet>516</a> r
<a href=#517 id=517 data-nosnippet>517</a> }
<a href=#518 id=518 data-nosnippet>518</a> }
<a href=#519 id=519 data-nosnippet>519</a>}
<a href=#520 id=520 data-nosnippet>520</a>
<a href=#521 id=521 data-nosnippet>521</a><span class="kw">impl </span>Rem&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#522 id=522 data-nosnippet>522</a> <span class="kw">type </span>Output = BigUint;
<a href=#523 id=523 data-nosnippet>523</a>
<a href=#524 id=524 data-nosnippet>524</a> <span class="attr">#[inline]
<a href=#525 id=525 data-nosnippet>525</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#526 id=526 data-nosnippet>526</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = other.to_u32() {
<a href=#527 id=527 data-nosnippet>527</a> <span class="self">self </span>% other
<a href=#528 id=528 data-nosnippet>528</a> } <span class="kw">else </span>{
<a href=#529 id=529 data-nosnippet>529</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = <span class="self">self</span>.div_rem(other);
<a href=#530 id=530 data-nosnippet>530</a> r
<a href=#531 id=531 data-nosnippet>531</a> }
<a href=#532 id=532 data-nosnippet>532</a> }
<a href=#533 id=533 data-nosnippet>533</a>}
<a href=#534 id=534 data-nosnippet>534</a><span class="kw">impl </span>RemAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#535 id=535 data-nosnippet>535</a> <span class="attr">#[inline]
<a href=#536 id=536 data-nosnippet>536</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#537 id=537 data-nosnippet>537</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>% other;
<a href=#538 id=538 data-nosnippet>538</a> }
<a href=#539 id=539 data-nosnippet>539</a>}
<a href=#540 id=540 data-nosnippet>540</a>
<a href=#541 id=541 data-nosnippet>541</a><span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span>Rem <span class="kw">for </span>BigUint, rem);
<a href=#542 id=542 data-nosnippet>542</a><span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span>RemAssign <span class="kw">for </span>BigUint, rem_assign);
<a href=#543 id=543 data-nosnippet>543</a><span class="macro">forward_all_scalar_binop_to_ref_val!</span>(<span class="kw">impl </span>Rem&lt;u32&gt; <span class="kw">for </span>BigUint, rem);
<a href=#544 id=544 data-nosnippet>544</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;u64&gt; <span class="kw">for </span>BigUint, rem);
<a href=#545 id=545 data-nosnippet>545</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Rem&lt;u128&gt; <span class="kw">for </span>BigUint, rem);
<a href=#546 id=546 data-nosnippet>546</a>
<a href=#547 id=547 data-nosnippet>547</a><span class="kw">impl </span>Rem&lt;u32&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#548 id=548 data-nosnippet>548</a> <span class="kw">type </span>Output = BigUint;
<a href=#549 id=549 data-nosnippet>549</a>
<a href=#550 id=550 data-nosnippet>550</a> <span class="attr">#[inline]
<a href=#551 id=551 data-nosnippet>551</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u32) -&gt; BigUint {
<a href=#552 id=552 data-nosnippet>552</a> rem_digit(<span class="self">self</span>, other <span class="kw">as </span>BigDigit).into()
<a href=#553 id=553 data-nosnippet>553</a> }
<a href=#554 id=554 data-nosnippet>554</a>}
<a href=#555 id=555 data-nosnippet>555</a><span class="kw">impl </span>RemAssign&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#556 id=556 data-nosnippet>556</a> <span class="attr">#[inline]
<a href=#557 id=557 data-nosnippet>557</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#558 id=558 data-nosnippet>558</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>% other;
<a href=#559 id=559 data-nosnippet>559</a> }
<a href=#560 id=560 data-nosnippet>560</a>}
<a href=#561 id=561 data-nosnippet>561</a>
<a href=#562 id=562 data-nosnippet>562</a><span class="kw">impl </span>Rem&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>u32 {
<a href=#563 id=563 data-nosnippet>563</a> <span class="kw">type </span>Output = BigUint;
<a href=#564 id=564 data-nosnippet>564</a>
<a href=#565 id=565 data-nosnippet>565</a> <span class="attr">#[inline]
<a href=#566 id=566 data-nosnippet>566</a> </span><span class="kw">fn </span>rem(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#567 id=567 data-nosnippet>567</a> <span class="self">self </span>%= other;
<a href=#568 id=568 data-nosnippet>568</a> From::from(<span class="self">self</span>)
<a href=#569 id=569 data-nosnippet>569</a> }
<a href=#570 id=570 data-nosnippet>570</a>}
<a href=#571 id=571 data-nosnippet>571</a>
<a href=#572 id=572 data-nosnippet>572</a><span class="macro">macro_rules!</span> impl_rem_assign_scalar {
<a href=#573 id=573 data-nosnippet>573</a> (<span class="macro-nonterminal">$scalar</span>:ty, <span class="macro-nonterminal">$to_scalar</span>:ident) =&gt; {
<a href=#574 id=574 data-nosnippet>574</a> <span class="macro">forward_val_assign_scalar!</span>(<span class="kw">impl </span>RemAssign <span class="kw">for </span>BigUint, <span class="macro-nonterminal">$scalar</span>, rem_assign);
<a href=#575 id=575 data-nosnippet>575</a> <span class="kw">impl </span>RemAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#576 id=576 data-nosnippet>576</a> <span class="attr">#[inline]
<a href=#577 id=577 data-nosnippet>577</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#578 id=578 data-nosnippet>578</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw">match </span>other.<span class="macro-nonterminal">$to_scalar</span>() {
<a href=#579 id=579 data-nosnippet>579</a> <span class="prelude-val">None </span>=&gt; <span class="kw-2">*</span><span class="self">self</span>,
<a href=#580 id=580 data-nosnippet>580</a> <span class="prelude-val">Some</span>(<span class="number">0</span>) =&gt; <span class="macro">panic!</span>(<span class="string">"attempt to divide by zero"</span>),
<a href=#581 id=581 data-nosnippet>581</a> <span class="prelude-val">Some</span>(v) =&gt; <span class="kw-2">*</span><span class="self">self </span>% v
<a href=#582 id=582 data-nosnippet>582</a> };
<a href=#583 id=583 data-nosnippet>583</a> }
<a href=#584 id=584 data-nosnippet>584</a> }
<a href=#585 id=585 data-nosnippet>585</a> }
<a href=#586 id=586 data-nosnippet>586</a>}
<a href=#587 id=587 data-nosnippet>587</a>
<a href=#588 id=588 data-nosnippet>588</a><span class="comment">// we can scalar %= BigUint for any scalar, including signed types
<a href=#589 id=589 data-nosnippet>589</a></span><span class="macro">impl_rem_assign_scalar!</span>(u128, to_u128);
<a href=#590 id=590 data-nosnippet>590</a><span class="macro">impl_rem_assign_scalar!</span>(usize, to_usize);
<a href=#591 id=591 data-nosnippet>591</a><span class="macro">impl_rem_assign_scalar!</span>(u64, to_u64);
<a href=#592 id=592 data-nosnippet>592</a><span class="macro">impl_rem_assign_scalar!</span>(u32, to_u32);
<a href=#593 id=593 data-nosnippet>593</a><span class="macro">impl_rem_assign_scalar!</span>(u16, to_u16);
<a href=#594 id=594 data-nosnippet>594</a><span class="macro">impl_rem_assign_scalar!</span>(u8, to_u8);
<a href=#595 id=595 data-nosnippet>595</a><span class="macro">impl_rem_assign_scalar!</span>(i128, to_i128);
<a href=#596 id=596 data-nosnippet>596</a><span class="macro">impl_rem_assign_scalar!</span>(isize, to_isize);
<a href=#597 id=597 data-nosnippet>597</a><span class="macro">impl_rem_assign_scalar!</span>(i64, to_i64);
<a href=#598 id=598 data-nosnippet>598</a><span class="macro">impl_rem_assign_scalar!</span>(i32, to_i32);
<a href=#599 id=599 data-nosnippet>599</a><span class="macro">impl_rem_assign_scalar!</span>(i16, to_i16);
<a href=#600 id=600 data-nosnippet>600</a><span class="macro">impl_rem_assign_scalar!</span>(i8, to_i8);
<a href=#601 id=601 data-nosnippet>601</a>
<a href=#602 id=602 data-nosnippet>602</a><span class="kw">impl </span>Rem&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#603 id=603 data-nosnippet>603</a> <span class="kw">type </span>Output = BigUint;
<a href=#604 id=604 data-nosnippet>604</a>
<a href=#605 id=605 data-nosnippet>605</a> <span class="attr">#[inline]
<a href=#606 id=606 data-nosnippet>606</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u64) -&gt; BigUint {
<a href=#607 id=607 data-nosnippet>607</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = div_rem(<span class="self">self</span>, From::from(other));
<a href=#608 id=608 data-nosnippet>608</a> r
<a href=#609 id=609 data-nosnippet>609</a> }
<a href=#610 id=610 data-nosnippet>610</a>}
<a href=#611 id=611 data-nosnippet>611</a><span class="kw">impl </span>RemAssign&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#612 id=612 data-nosnippet>612</a> <span class="attr">#[inline]
<a href=#613 id=613 data-nosnippet>613</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#614 id=614 data-nosnippet>614</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>% other;
<a href=#615 id=615 data-nosnippet>615</a> }
<a href=#616 id=616 data-nosnippet>616</a>}
<a href=#617 id=617 data-nosnippet>617</a>
<a href=#618 id=618 data-nosnippet>618</a><span class="kw">impl </span>Rem&lt;BigUint&gt; <span class="kw">for </span>u64 {
<a href=#619 id=619 data-nosnippet>619</a> <span class="kw">type </span>Output = BigUint;
<a href=#620 id=620 data-nosnippet>620</a>
<a href=#621 id=621 data-nosnippet>621</a> <span class="attr">#[inline]
<a href=#622 id=622 data-nosnippet>622</a> </span><span class="kw">fn </span>rem(<span class="kw-2">mut </span><span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#623 id=623 data-nosnippet>623</a> <span class="self">self </span>%= other;
<a href=#624 id=624 data-nosnippet>624</a> From::from(<span class="self">self</span>)
<a href=#625 id=625 data-nosnippet>625</a> }
<a href=#626 id=626 data-nosnippet>626</a>}
<a href=#627 id=627 data-nosnippet>627</a>
<a href=#628 id=628 data-nosnippet>628</a><span class="kw">impl </span>Rem&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#629 id=629 data-nosnippet>629</a> <span class="kw">type </span>Output = BigUint;
<a href=#630 id=630 data-nosnippet>630</a>
<a href=#631 id=631 data-nosnippet>631</a> <span class="attr">#[inline]
<a href=#632 id=632 data-nosnippet>632</a> </span><span class="kw">fn </span>rem(<span class="self">self</span>, other: u128) -&gt; BigUint {
<a href=#633 id=633 data-nosnippet>633</a> <span class="kw">let </span>(<span class="kw">_</span>, r) = div_rem(<span class="self">self</span>, From::from(other));
<a href=#634 id=634 data-nosnippet>634</a> r
<a href=#635 id=635 data-nosnippet>635</a> }
<a href=#636 id=636 data-nosnippet>636</a>}
<a href=#637 id=637 data-nosnippet>637</a>
<a href=#638 id=638 data-nosnippet>638</a><span class="kw">impl </span>RemAssign&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#639 id=639 data-nosnippet>639</a> <span class="attr">#[inline]
<a href=#640 id=640 data-nosnippet>640</a> </span><span class="kw">fn </span>rem_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#641 id=641 data-nosnippet>641</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw-2">&amp;*</span><span class="self">self </span>% other;
<a href=#642 id=642 data-nosnippet>642</a> }
<a href=#643 id=643 data-nosnippet>643</a>}
<a href=#644 id=644 data-nosnippet>644</a>
<a href=#645 id=645 data-nosnippet>645</a><span class="kw">impl </span>Rem&lt;BigUint&gt; <span class="kw">for </span>u128 {
<a href=#646 id=646 data-nosnippet>646</a> <span class="kw">type </span>Output = BigUint;
<a href=#647 id=647 data-nosnippet>647</a>
<a href=#648 id=648 data-nosnippet>648</a> <span class="attr">#[inline]
<a href=#649 id=649 data-nosnippet>649</a> </span><span class="kw">fn </span>rem(<span class="kw-2">mut </span><span class="self">self</span>, other: BigUint) -&gt; BigUint {
<a href=#650 id=650 data-nosnippet>650</a> <span class="self">self </span>%= other;
<a href=#651 id=651 data-nosnippet>651</a> From::from(<span class="self">self</span>)
<a href=#652 id=652 data-nosnippet>652</a> }
<a href=#653 id=653 data-nosnippet>653</a>}
<a href=#654 id=654 data-nosnippet>654</a>
<a href=#655 id=655 data-nosnippet>655</a><span class="kw">impl </span>CheckedDiv <span class="kw">for </span>BigUint {
<a href=#656 id=656 data-nosnippet>656</a> <span class="attr">#[inline]
<a href=#657 id=657 data-nosnippet>657</a> </span><span class="kw">fn </span>checked_div(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#658 id=658 data-nosnippet>658</a> <span class="kw">if </span>v.is_zero() {
<a href=#659 id=659 data-nosnippet>659</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#660 id=660 data-nosnippet>660</a> }
<a href=#661 id=661 data-nosnippet>661</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div(v))
<a href=#662 id=662 data-nosnippet>662</a> }
<a href=#663 id=663 data-nosnippet>663</a>}
<a href=#664 id=664 data-nosnippet>664</a>
<a href=#665 id=665 data-nosnippet>665</a><span class="kw">impl </span>CheckedEuclid <span class="kw">for </span>BigUint {
<a href=#666 id=666 data-nosnippet>666</a> <span class="attr">#[inline]
<a href=#667 id=667 data-nosnippet>667</a> </span><span class="kw">fn </span>checked_div_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#668 id=668 data-nosnippet>668</a> <span class="kw">if </span>v.is_zero() {
<a href=#669 id=669 data-nosnippet>669</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#670 id=670 data-nosnippet>670</a> }
<a href=#671 id=671 data-nosnippet>671</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div_euclid(v))
<a href=#672 id=672 data-nosnippet>672</a> }
<a href=#673 id=673 data-nosnippet>673</a>
<a href=#674 id=674 data-nosnippet>674</a> <span class="attr">#[inline]
<a href=#675 id=675 data-nosnippet>675</a> </span><span class="kw">fn </span>checked_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#676 id=676 data-nosnippet>676</a> <span class="kw">if </span>v.is_zero() {
<a href=#677 id=677 data-nosnippet>677</a> <span class="kw">return </span><span class="prelude-val">None</span>;
<a href=#678 id=678 data-nosnippet>678</a> }
<a href=#679 id=679 data-nosnippet>679</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.rem_euclid(v))
<a href=#680 id=680 data-nosnippet>680</a> }
<a href=#681 id=681 data-nosnippet>681</a>
<a href=#682 id=682 data-nosnippet>682</a> <span class="kw">fn </span>checked_div_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span><span class="self">Self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;(<span class="self">Self</span>, <span class="self">Self</span>)&gt; {
<a href=#683 id=683 data-nosnippet>683</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.div_rem_euclid(v))
<a href=#684 id=684 data-nosnippet>684</a> }
<a href=#685 id=685 data-nosnippet>685</a>}
<a href=#686 id=686 data-nosnippet>686</a>
<a href=#687 id=687 data-nosnippet>687</a><span class="kw">impl </span>Euclid <span class="kw">for </span>BigUint {
<a href=#688 id=688 data-nosnippet>688</a> <span class="attr">#[inline]
<a href=#689 id=689 data-nosnippet>689</a> </span><span class="kw">fn </span>div_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#690 id=690 data-nosnippet>690</a> <span class="comment">// trivially same as regular division
<a href=#691 id=691 data-nosnippet>691</a> </span><span class="self">self </span>/ v
<a href=#692 id=692 data-nosnippet>692</a> }
<a href=#693 id=693 data-nosnippet>693</a>
<a href=#694 id=694 data-nosnippet>694</a> <span class="attr">#[inline]
<a href=#695 id=695 data-nosnippet>695</a> </span><span class="kw">fn </span>rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#696 id=696 data-nosnippet>696</a> <span class="comment">// trivially same as regular remainder
<a href=#697 id=697 data-nosnippet>697</a> </span><span class="self">self </span>% v
<a href=#698 id=698 data-nosnippet>698</a> }
<a href=#699 id=699 data-nosnippet>699</a>
<a href=#700 id=700 data-nosnippet>700</a> <span class="kw">fn </span>div_rem_euclid(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span><span class="self">Self</span>) -&gt; (<span class="self">Self</span>, <span class="self">Self</span>) {
<a href=#701 id=701 data-nosnippet>701</a> <span class="comment">// trivially same as regular division and remainder
<a href=#702 id=702 data-nosnippet>702</a> </span><span class="self">self</span>.div_rem(v)
<a href=#703 id=703 data-nosnippet>703</a> }
<a href=#704 id=704 data-nosnippet>704</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,362 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/iter.rs`."><title>iter.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>iter.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span>core::iter::FusedIterator;
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a><span class="macro">cfg_digit!</span>(
<a href=#4 id=4 data-nosnippet>4</a> <span class="doccomment">/// An iterator of `u32` digits representation of a `BigUint` or `BigInt`,
<a href=#5 id=5 data-nosnippet>5</a> /// ordered least significant digit first.
<a href=#6 id=6 data-nosnippet>6</a> </span><span class="kw">pub struct </span>U32Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#7 id=7 data-nosnippet>7</a> it: core::slice::Iter&lt;<span class="lifetime">'a</span>, u32&gt;,
<a href=#8 id=8 data-nosnippet>8</a> }
<a href=#9 id=9 data-nosnippet>9</a>
<a href=#10 id=10 data-nosnippet>10</a> <span class="doccomment">/// An iterator of `u32` digits representation of a `BigUint` or `BigInt`,
<a href=#11 id=11 data-nosnippet>11</a> /// ordered least significant digit first.
<a href=#12 id=12 data-nosnippet>12</a> </span><span class="kw">pub struct </span>U32Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#13 id=13 data-nosnippet>13</a> data: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u64],
<a href=#14 id=14 data-nosnippet>14</a> next_is_lo: bool,
<a href=#15 id=15 data-nosnippet>15</a> last_hi_is_zero: bool,
<a href=#16 id=16 data-nosnippet>16</a> }
<a href=#17 id=17 data-nosnippet>17</a>);
<a href=#18 id=18 data-nosnippet>18</a>
<a href=#19 id=19 data-nosnippet>19</a><span class="macro">cfg_digit!</span>(
<a href=#20 id=20 data-nosnippet>20</a> <span class="kw">const _</span>: () = {
<a href=#21 id=21 data-nosnippet>21</a> <span class="kw">impl</span>&lt;<span class="lifetime">'a</span>&gt; U32Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#22 id=22 data-nosnippet>22</a> <span class="attr">#[inline]
<a href=#23 id=23 data-nosnippet>23</a> </span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>new(data: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u32]) -&gt; <span class="self">Self </span>{
<a href=#24 id=24 data-nosnippet>24</a> <span class="self">Self </span>{ it: data.iter() }
<a href=#25 id=25 data-nosnippet>25</a> }
<a href=#26 id=26 data-nosnippet>26</a> }
<a href=#27 id=27 data-nosnippet>27</a>
<a href=#28 id=28 data-nosnippet>28</a> <span class="kw">impl </span>Iterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#29 id=29 data-nosnippet>29</a> <span class="kw">type </span>Item = u32;
<a href=#30 id=30 data-nosnippet>30</a> <span class="attr">#[inline]
<a href=#31 id=31 data-nosnippet>31</a> </span><span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<a href=#32 id=32 data-nosnippet>32</a> <span class="self">self</span>.it.next().cloned()
<a href=#33 id=33 data-nosnippet>33</a> }
<a href=#34 id=34 data-nosnippet>34</a>
<a href=#35 id=35 data-nosnippet>35</a> <span class="attr">#[inline]
<a href=#36 id=36 data-nosnippet>36</a> </span><span class="kw">fn </span>size_hint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; (usize, <span class="prelude-ty">Option</span>&lt;usize&gt;) {
<a href=#37 id=37 data-nosnippet>37</a> <span class="self">self</span>.it.size_hint()
<a href=#38 id=38 data-nosnippet>38</a> }
<a href=#39 id=39 data-nosnippet>39</a>
<a href=#40 id=40 data-nosnippet>40</a> <span class="attr">#[inline]
<a href=#41 id=41 data-nosnippet>41</a> </span><span class="kw">fn </span>nth(<span class="kw-2">&amp;mut </span><span class="self">self</span>, n: usize) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<a href=#42 id=42 data-nosnippet>42</a> <span class="self">self</span>.it.nth(n).cloned()
<a href=#43 id=43 data-nosnippet>43</a> }
<a href=#44 id=44 data-nosnippet>44</a>
<a href=#45 id=45 data-nosnippet>45</a> <span class="attr">#[inline]
<a href=#46 id=46 data-nosnippet>46</a> </span><span class="kw">fn </span>last(<span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<a href=#47 id=47 data-nosnippet>47</a> <span class="self">self</span>.it.last().cloned()
<a href=#48 id=48 data-nosnippet>48</a> }
<a href=#49 id=49 data-nosnippet>49</a>
<a href=#50 id=50 data-nosnippet>50</a> <span class="attr">#[inline]
<a href=#51 id=51 data-nosnippet>51</a> </span><span class="kw">fn </span>count(<span class="self">self</span>) -&gt; usize {
<a href=#52 id=52 data-nosnippet>52</a> <span class="self">self</span>.it.count()
<a href=#53 id=53 data-nosnippet>53</a> }
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a>
<a href=#56 id=56 data-nosnippet>56</a> <span class="kw">impl </span>DoubleEndedIterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#57 id=57 data-nosnippet>57</a> <span class="kw">fn </span>next_back(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="self">Self</span>::Item&gt; {
<a href=#58 id=58 data-nosnippet>58</a> <span class="self">self</span>.it.next_back().cloned()
<a href=#59 id=59 data-nosnippet>59</a> }
<a href=#60 id=60 data-nosnippet>60</a> }
<a href=#61 id=61 data-nosnippet>61</a>
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">impl </span>ExactSizeIterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#63 id=63 data-nosnippet>63</a> <span class="attr">#[inline]
<a href=#64 id=64 data-nosnippet>64</a> </span><span class="kw">fn </span>len(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
<a href=#65 id=65 data-nosnippet>65</a> <span class="self">self</span>.it.len()
<a href=#66 id=66 data-nosnippet>66</a> }
<a href=#67 id=67 data-nosnippet>67</a> }
<a href=#68 id=68 data-nosnippet>68</a> };
<a href=#69 id=69 data-nosnippet>69</a>
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">const _</span>: () = {
<a href=#71 id=71 data-nosnippet>71</a> <span class="kw">impl</span>&lt;<span class="lifetime">'a</span>&gt; U32Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#72 id=72 data-nosnippet>72</a> <span class="attr">#[inline]
<a href=#73 id=73 data-nosnippet>73</a> </span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>new(data: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u64]) -&gt; <span class="self">Self </span>{
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">let </span>last_hi_is_zero = data
<a href=#75 id=75 data-nosnippet>75</a> .last()
<a href=#76 id=76 data-nosnippet>76</a> .map(|<span class="kw-2">&amp;</span>last| {
<a href=#77 id=77 data-nosnippet>77</a> <span class="kw">let </span>last_hi = (last &gt;&gt; <span class="number">32</span>) <span class="kw">as </span>u32;
<a href=#78 id=78 data-nosnippet>78</a> last_hi == <span class="number">0
<a href=#79 id=79 data-nosnippet>79</a> </span>})
<a href=#80 id=80 data-nosnippet>80</a> .unwrap_or(<span class="bool-val">false</span>);
<a href=#81 id=81 data-nosnippet>81</a> U32Digits {
<a href=#82 id=82 data-nosnippet>82</a> data,
<a href=#83 id=83 data-nosnippet>83</a> next_is_lo: <span class="bool-val">true</span>,
<a href=#84 id=84 data-nosnippet>84</a> last_hi_is_zero,
<a href=#85 id=85 data-nosnippet>85</a> }
<a href=#86 id=86 data-nosnippet>86</a> }
<a href=#87 id=87 data-nosnippet>87</a> }
<a href=#88 id=88 data-nosnippet>88</a>
<a href=#89 id=89 data-nosnippet>89</a> <span class="kw">impl </span>Iterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#90 id=90 data-nosnippet>90</a> <span class="kw">type </span>Item = u32;
<a href=#91 id=91 data-nosnippet>91</a> <span class="attr">#[inline]
<a href=#92 id=92 data-nosnippet>92</a> </span><span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">match </span><span class="self">self</span>.data.split_first() {
<a href=#94 id=94 data-nosnippet>94</a> <span class="prelude-val">Some</span>((<span class="kw-2">&amp;</span>first, data)) =&gt; {
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw">let </span>next_is_lo = <span class="self">self</span>.next_is_lo;
<a href=#96 id=96 data-nosnippet>96</a> <span class="self">self</span>.next_is_lo = !next_is_lo;
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw">if </span>next_is_lo {
<a href=#98 id=98 data-nosnippet>98</a> <span class="prelude-val">Some</span>(first <span class="kw">as </span>u32)
<a href=#99 id=99 data-nosnippet>99</a> } <span class="kw">else </span>{
<a href=#100 id=100 data-nosnippet>100</a> <span class="self">self</span>.data = data;
<a href=#101 id=101 data-nosnippet>101</a> <span class="kw">if </span>data.is_empty() &amp;&amp; <span class="self">self</span>.last_hi_is_zero {
<a href=#102 id=102 data-nosnippet>102</a> <span class="self">self</span>.last_hi_is_zero = <span class="bool-val">false</span>;
<a href=#103 id=103 data-nosnippet>103</a> <span class="prelude-val">None
<a href=#104 id=104 data-nosnippet>104</a> </span>} <span class="kw">else </span>{
<a href=#105 id=105 data-nosnippet>105</a> <span class="prelude-val">Some</span>((first &gt;&gt; <span class="number">32</span>) <span class="kw">as </span>u32)
<a href=#106 id=106 data-nosnippet>106</a> }
<a href=#107 id=107 data-nosnippet>107</a> }
<a href=#108 id=108 data-nosnippet>108</a> }
<a href=#109 id=109 data-nosnippet>109</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">None</span>,
<a href=#110 id=110 data-nosnippet>110</a> }
<a href=#111 id=111 data-nosnippet>111</a> }
<a href=#112 id=112 data-nosnippet>112</a>
<a href=#113 id=113 data-nosnippet>113</a> <span class="attr">#[inline]
<a href=#114 id=114 data-nosnippet>114</a> </span><span class="kw">fn </span>size_hint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; (usize, <span class="prelude-ty">Option</span>&lt;usize&gt;) {
<a href=#115 id=115 data-nosnippet>115</a> <span class="kw">let </span>len = <span class="self">self</span>.len();
<a href=#116 id=116 data-nosnippet>116</a> (len, <span class="prelude-val">Some</span>(len))
<a href=#117 id=117 data-nosnippet>117</a> }
<a href=#118 id=118 data-nosnippet>118</a>
<a href=#119 id=119 data-nosnippet>119</a> <span class="attr">#[inline]
<a href=#120 id=120 data-nosnippet>120</a> </span><span class="kw">fn </span>last(<span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<a href=#121 id=121 data-nosnippet>121</a> <span class="self">self</span>.data.last().map(|<span class="kw-2">&amp;</span>last| {
<a href=#122 id=122 data-nosnippet>122</a> <span class="kw">if </span><span class="self">self</span>.last_hi_is_zero {
<a href=#123 id=123 data-nosnippet>123</a> last <span class="kw">as </span>u32
<a href=#124 id=124 data-nosnippet>124</a> } <span class="kw">else </span>{
<a href=#125 id=125 data-nosnippet>125</a> (last &gt;&gt; <span class="number">32</span>) <span class="kw">as </span>u32
<a href=#126 id=126 data-nosnippet>126</a> }
<a href=#127 id=127 data-nosnippet>127</a> })
<a href=#128 id=128 data-nosnippet>128</a> }
<a href=#129 id=129 data-nosnippet>129</a>
<a href=#130 id=130 data-nosnippet>130</a> <span class="attr">#[inline]
<a href=#131 id=131 data-nosnippet>131</a> </span><span class="kw">fn </span>count(<span class="self">self</span>) -&gt; usize {
<a href=#132 id=132 data-nosnippet>132</a> <span class="self">self</span>.len()
<a href=#133 id=133 data-nosnippet>133</a> }
<a href=#134 id=134 data-nosnippet>134</a> }
<a href=#135 id=135 data-nosnippet>135</a>
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">impl </span>DoubleEndedIterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#137 id=137 data-nosnippet>137</a> <span class="kw">fn </span>next_back(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="self">Self</span>::Item&gt; {
<a href=#138 id=138 data-nosnippet>138</a> <span class="kw">match </span><span class="self">self</span>.data.split_last() {
<a href=#139 id=139 data-nosnippet>139</a> <span class="prelude-val">Some</span>((<span class="kw-2">&amp;</span>last, data)) =&gt; {
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span>last_is_lo = <span class="self">self</span>.last_hi_is_zero;
<a href=#141 id=141 data-nosnippet>141</a> <span class="self">self</span>.last_hi_is_zero = !last_is_lo;
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">if </span>last_is_lo {
<a href=#143 id=143 data-nosnippet>143</a> <span class="self">self</span>.data = data;
<a href=#144 id=144 data-nosnippet>144</a> <span class="kw">if </span>data.is_empty() &amp;&amp; !<span class="self">self</span>.next_is_lo {
<a href=#145 id=145 data-nosnippet>145</a> <span class="self">self</span>.next_is_lo = <span class="bool-val">true</span>;
<a href=#146 id=146 data-nosnippet>146</a> <span class="prelude-val">None
<a href=#147 id=147 data-nosnippet>147</a> </span>} <span class="kw">else </span>{
<a href=#148 id=148 data-nosnippet>148</a> <span class="prelude-val">Some</span>(last <span class="kw">as </span>u32)
<a href=#149 id=149 data-nosnippet>149</a> }
<a href=#150 id=150 data-nosnippet>150</a> } <span class="kw">else </span>{
<a href=#151 id=151 data-nosnippet>151</a> <span class="prelude-val">Some</span>((last &gt;&gt; <span class="number">32</span>) <span class="kw">as </span>u32)
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a> }
<a href=#154 id=154 data-nosnippet>154</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">None</span>,
<a href=#155 id=155 data-nosnippet>155</a> }
<a href=#156 id=156 data-nosnippet>156</a> }
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a>
<a href=#159 id=159 data-nosnippet>159</a> <span class="kw">impl </span>ExactSizeIterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#160 id=160 data-nosnippet>160</a> <span class="attr">#[inline]
<a href=#161 id=161 data-nosnippet>161</a> </span><span class="kw">fn </span>len(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
<a href=#162 id=162 data-nosnippet>162</a> <span class="self">self</span>.data.len() * <span class="number">2
<a href=#163 id=163 data-nosnippet>163</a> </span>- usize::from(<span class="self">self</span>.last_hi_is_zero)
<a href=#164 id=164 data-nosnippet>164</a> - usize::from(!<span class="self">self</span>.next_is_lo)
<a href=#165 id=165 data-nosnippet>165</a> }
<a href=#166 id=166 data-nosnippet>166</a> }
<a href=#167 id=167 data-nosnippet>167</a> };
<a href=#168 id=168 data-nosnippet>168</a>);
<a href=#169 id=169 data-nosnippet>169</a>
<a href=#170 id=170 data-nosnippet>170</a><span class="kw">impl </span>FusedIterator <span class="kw">for </span>U32Digits&lt;<span class="lifetime">'_</span>&gt; {}
<a href=#171 id=171 data-nosnippet>171</a>
<a href=#172 id=172 data-nosnippet>172</a><span class="macro">cfg_digit!</span>(
<a href=#173 id=173 data-nosnippet>173</a> <span class="doccomment">/// An iterator of `u64` digits representation of a `BigUint` or `BigInt`,
<a href=#174 id=174 data-nosnippet>174</a> /// ordered least significant digit first.
<a href=#175 id=175 data-nosnippet>175</a> </span><span class="kw">pub struct </span>U64Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#176 id=176 data-nosnippet>176</a> it: core::slice::Chunks&lt;<span class="lifetime">'a</span>, u32&gt;,
<a href=#177 id=177 data-nosnippet>177</a> }
<a href=#178 id=178 data-nosnippet>178</a>
<a href=#179 id=179 data-nosnippet>179</a> <span class="doccomment">/// An iterator of `u64` digits representation of a `BigUint` or `BigInt`,
<a href=#180 id=180 data-nosnippet>180</a> /// ordered least significant digit first.
<a href=#181 id=181 data-nosnippet>181</a> </span><span class="kw">pub struct </span>U64Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#182 id=182 data-nosnippet>182</a> it: core::slice::Iter&lt;<span class="lifetime">'a</span>, u64&gt;,
<a href=#183 id=183 data-nosnippet>183</a> }
<a href=#184 id=184 data-nosnippet>184</a>);
<a href=#185 id=185 data-nosnippet>185</a>
<a href=#186 id=186 data-nosnippet>186</a><span class="macro">cfg_digit!</span>(
<a href=#187 id=187 data-nosnippet>187</a> <span class="kw">const _</span>: () = {
<a href=#188 id=188 data-nosnippet>188</a> <span class="kw">impl</span>&lt;<span class="lifetime">'a</span>&gt; U64Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#189 id=189 data-nosnippet>189</a> <span class="attr">#[inline]
<a href=#190 id=190 data-nosnippet>190</a> </span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>new(data: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u32]) -&gt; <span class="self">Self </span>{
<a href=#191 id=191 data-nosnippet>191</a> U64Digits { it: data.chunks(<span class="number">2</span>) }
<a href=#192 id=192 data-nosnippet>192</a> }
<a href=#193 id=193 data-nosnippet>193</a> }
<a href=#194 id=194 data-nosnippet>194</a>
<a href=#195 id=195 data-nosnippet>195</a> <span class="kw">impl </span>Iterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#196 id=196 data-nosnippet>196</a> <span class="kw">type </span>Item = u64;
<a href=#197 id=197 data-nosnippet>197</a> <span class="attr">#[inline]
<a href=#198 id=198 data-nosnippet>198</a> </span><span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#199 id=199 data-nosnippet>199</a> <span class="self">self</span>.it.next().map(<span class="kw">super</span>::u32_chunk_to_u64)
<a href=#200 id=200 data-nosnippet>200</a> }
<a href=#201 id=201 data-nosnippet>201</a>
<a href=#202 id=202 data-nosnippet>202</a> <span class="attr">#[inline]
<a href=#203 id=203 data-nosnippet>203</a> </span><span class="kw">fn </span>size_hint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; (usize, <span class="prelude-ty">Option</span>&lt;usize&gt;) {
<a href=#204 id=204 data-nosnippet>204</a> <span class="kw">let </span>len = <span class="self">self</span>.len();
<a href=#205 id=205 data-nosnippet>205</a> (len, <span class="prelude-val">Some</span>(len))
<a href=#206 id=206 data-nosnippet>206</a> }
<a href=#207 id=207 data-nosnippet>207</a>
<a href=#208 id=208 data-nosnippet>208</a> <span class="attr">#[inline]
<a href=#209 id=209 data-nosnippet>209</a> </span><span class="kw">fn </span>last(<span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#210 id=210 data-nosnippet>210</a> <span class="self">self</span>.it.last().map(<span class="kw">super</span>::u32_chunk_to_u64)
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a>
<a href=#213 id=213 data-nosnippet>213</a> <span class="attr">#[inline]
<a href=#214 id=214 data-nosnippet>214</a> </span><span class="kw">fn </span>count(<span class="self">self</span>) -&gt; usize {
<a href=#215 id=215 data-nosnippet>215</a> <span class="self">self</span>.len()
<a href=#216 id=216 data-nosnippet>216</a> }
<a href=#217 id=217 data-nosnippet>217</a> }
<a href=#218 id=218 data-nosnippet>218</a>
<a href=#219 id=219 data-nosnippet>219</a> <span class="kw">impl </span>DoubleEndedIterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#220 id=220 data-nosnippet>220</a> <span class="kw">fn </span>next_back(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="self">Self</span>::Item&gt; {
<a href=#221 id=221 data-nosnippet>221</a> <span class="self">self</span>.it.next_back().map(<span class="kw">super</span>::u32_chunk_to_u64)
<a href=#222 id=222 data-nosnippet>222</a> }
<a href=#223 id=223 data-nosnippet>223</a> }
<a href=#224 id=224 data-nosnippet>224</a> };
<a href=#225 id=225 data-nosnippet>225</a>
<a href=#226 id=226 data-nosnippet>226</a> <span class="kw">const _</span>: () = {
<a href=#227 id=227 data-nosnippet>227</a> <span class="kw">impl</span>&lt;<span class="lifetime">'a</span>&gt; U64Digits&lt;<span class="lifetime">'a</span>&gt; {
<a href=#228 id=228 data-nosnippet>228</a> <span class="attr">#[inline]
<a href=#229 id=229 data-nosnippet>229</a> </span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>new(data: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u64]) -&gt; <span class="self">Self </span>{
<a href=#230 id=230 data-nosnippet>230</a> <span class="self">Self </span>{ it: data.iter() }
<a href=#231 id=231 data-nosnippet>231</a> }
<a href=#232 id=232 data-nosnippet>232</a> }
<a href=#233 id=233 data-nosnippet>233</a>
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw">impl </span>Iterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#235 id=235 data-nosnippet>235</a> <span class="kw">type </span>Item = u64;
<a href=#236 id=236 data-nosnippet>236</a> <span class="attr">#[inline]
<a href=#237 id=237 data-nosnippet>237</a> </span><span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#238 id=238 data-nosnippet>238</a> <span class="self">self</span>.it.next().cloned()
<a href=#239 id=239 data-nosnippet>239</a> }
<a href=#240 id=240 data-nosnippet>240</a>
<a href=#241 id=241 data-nosnippet>241</a> <span class="attr">#[inline]
<a href=#242 id=242 data-nosnippet>242</a> </span><span class="kw">fn </span>size_hint(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; (usize, <span class="prelude-ty">Option</span>&lt;usize&gt;) {
<a href=#243 id=243 data-nosnippet>243</a> <span class="self">self</span>.it.size_hint()
<a href=#244 id=244 data-nosnippet>244</a> }
<a href=#245 id=245 data-nosnippet>245</a>
<a href=#246 id=246 data-nosnippet>246</a> <span class="attr">#[inline]
<a href=#247 id=247 data-nosnippet>247</a> </span><span class="kw">fn </span>nth(<span class="kw-2">&amp;mut </span><span class="self">self</span>, n: usize) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#248 id=248 data-nosnippet>248</a> <span class="self">self</span>.it.nth(n).cloned()
<a href=#249 id=249 data-nosnippet>249</a> }
<a href=#250 id=250 data-nosnippet>250</a>
<a href=#251 id=251 data-nosnippet>251</a> <span class="attr">#[inline]
<a href=#252 id=252 data-nosnippet>252</a> </span><span class="kw">fn </span>last(<span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<a href=#253 id=253 data-nosnippet>253</a> <span class="self">self</span>.it.last().cloned()
<a href=#254 id=254 data-nosnippet>254</a> }
<a href=#255 id=255 data-nosnippet>255</a>
<a href=#256 id=256 data-nosnippet>256</a> <span class="attr">#[inline]
<a href=#257 id=257 data-nosnippet>257</a> </span><span class="kw">fn </span>count(<span class="self">self</span>) -&gt; usize {
<a href=#258 id=258 data-nosnippet>258</a> <span class="self">self</span>.it.count()
<a href=#259 id=259 data-nosnippet>259</a> }
<a href=#260 id=260 data-nosnippet>260</a> }
<a href=#261 id=261 data-nosnippet>261</a>
<a href=#262 id=262 data-nosnippet>262</a> <span class="kw">impl </span>DoubleEndedIterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#263 id=263 data-nosnippet>263</a> <span class="kw">fn </span>next_back(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="self">Self</span>::Item&gt; {
<a href=#264 id=264 data-nosnippet>264</a> <span class="self">self</span>.it.next_back().cloned()
<a href=#265 id=265 data-nosnippet>265</a> }
<a href=#266 id=266 data-nosnippet>266</a> }
<a href=#267 id=267 data-nosnippet>267</a> };
<a href=#268 id=268 data-nosnippet>268</a>);
<a href=#269 id=269 data-nosnippet>269</a>
<a href=#270 id=270 data-nosnippet>270</a><span class="kw">impl </span>ExactSizeIterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {
<a href=#271 id=271 data-nosnippet>271</a> <span class="attr">#[inline]
<a href=#272 id=272 data-nosnippet>272</a> </span><span class="kw">fn </span>len(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
<a href=#273 id=273 data-nosnippet>273</a> <span class="self">self</span>.it.len()
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a>}
<a href=#276 id=276 data-nosnippet>276</a>
<a href=#277 id=277 data-nosnippet>277</a><span class="kw">impl </span>FusedIterator <span class="kw">for </span>U64Digits&lt;<span class="lifetime">'_</span>&gt; {}
<a href=#278 id=278 data-nosnippet>278</a>
<a href=#279 id=279 data-nosnippet>279</a><span class="attr">#[test]
<a href=#280 id=280 data-nosnippet>280</a></span><span class="kw">fn </span>test_iter_u32_digits() {
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">5u8</span>);
<a href=#282 id=282 data-nosnippet>282</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u32_digits();
<a href=#283 id=283 data-nosnippet>283</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#284 id=284 data-nosnippet>284</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
<a href=#285 id=285 data-nosnippet>285</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#286 id=286 data-nosnippet>286</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#287 id=287 data-nosnippet>287</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#288 id=288 data-nosnippet>288</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#289 id=289 data-nosnippet>289</a>
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">112500000000u64</span>);
<a href=#291 id=291 data-nosnippet>291</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u32_digits();
<a href=#292 id=292 data-nosnippet>292</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">2</span>);
<a href=#293 id=293 data-nosnippet>293</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">830850304</span>));
<a href=#294 id=294 data-nosnippet>294</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#295 id=295 data-nosnippet>295</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">26</span>));
<a href=#296 id=296 data-nosnippet>296</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#297 id=297 data-nosnippet>297</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#298 id=298 data-nosnippet>298</a>}
<a href=#299 id=299 data-nosnippet>299</a>
<a href=#300 id=300 data-nosnippet>300</a><span class="attr">#[test]
<a href=#301 id=301 data-nosnippet>301</a></span><span class="kw">fn </span>test_iter_u64_digits() {
<a href=#302 id=302 data-nosnippet>302</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">5u8</span>);
<a href=#303 id=303 data-nosnippet>303</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u64_digits();
<a href=#304 id=304 data-nosnippet>304</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#305 id=305 data-nosnippet>305</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
<a href=#306 id=306 data-nosnippet>306</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#307 id=307 data-nosnippet>307</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#308 id=308 data-nosnippet>308</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#309 id=309 data-nosnippet>309</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#310 id=310 data-nosnippet>310</a>
<a href=#311 id=311 data-nosnippet>311</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">18_446_744_073_709_551_616u128</span>);
<a href=#312 id=312 data-nosnippet>312</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u64_digits();
<a href=#313 id=313 data-nosnippet>313</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">2</span>);
<a href=#314 id=314 data-nosnippet>314</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">0</span>));
<a href=#315 id=315 data-nosnippet>315</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#316 id=316 data-nosnippet>316</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
<a href=#317 id=317 data-nosnippet>317</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#318 id=318 data-nosnippet>318</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#319 id=319 data-nosnippet>319</a>}
<a href=#320 id=320 data-nosnippet>320</a>
<a href=#321 id=321 data-nosnippet>321</a><span class="attr">#[test]
<a href=#322 id=322 data-nosnippet>322</a></span><span class="kw">fn </span>test_iter_u32_digits_be() {
<a href=#323 id=323 data-nosnippet>323</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">5u8</span>);
<a href=#324 id=324 data-nosnippet>324</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u32_digits();
<a href=#325 id=325 data-nosnippet>325</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#326 id=326 data-nosnippet>326</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
<a href=#327 id=327 data-nosnippet>327</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#328 id=328 data-nosnippet>328</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#329 id=329 data-nosnippet>329</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#330 id=330 data-nosnippet>330</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#331 id=331 data-nosnippet>331</a>
<a href=#332 id=332 data-nosnippet>332</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">112500000000u64</span>);
<a href=#333 id=333 data-nosnippet>333</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u32_digits();
<a href=#334 id=334 data-nosnippet>334</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">2</span>);
<a href=#335 id=335 data-nosnippet>335</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">830850304</span>));
<a href=#336 id=336 data-nosnippet>336</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#337 id=337 data-nosnippet>337</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">26</span>));
<a href=#338 id=338 data-nosnippet>338</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#339 id=339 data-nosnippet>339</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#340 id=340 data-nosnippet>340</a>}
<a href=#341 id=341 data-nosnippet>341</a>
<a href=#342 id=342 data-nosnippet>342</a><span class="attr">#[test]
<a href=#343 id=343 data-nosnippet>343</a></span><span class="kw">fn </span>test_iter_u64_digits_be() {
<a href=#344 id=344 data-nosnippet>344</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">5u8</span>);
<a href=#345 id=345 data-nosnippet>345</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u64_digits();
<a href=#346 id=346 data-nosnippet>346</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#347 id=347 data-nosnippet>347</a> <span class="macro">assert_eq!</span>(it.next_back(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
<a href=#348 id=348 data-nosnippet>348</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#349 id=349 data-nosnippet>349</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#350 id=350 data-nosnippet>350</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#351 id=351 data-nosnippet>351</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#352 id=352 data-nosnippet>352</a>
<a href=#353 id=353 data-nosnippet>353</a> <span class="kw">let </span>n = <span class="kw">super</span>::BigUint::from(<span class="number">18_446_744_073_709_551_616u128</span>);
<a href=#354 id=354 data-nosnippet>354</a> <span class="kw">let </span><span class="kw-2">mut </span>it = n.iter_u64_digits();
<a href=#355 id=355 data-nosnippet>355</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">2</span>);
<a href=#356 id=356 data-nosnippet>356</a> <span class="macro">assert_eq!</span>(it.next_back(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
<a href=#357 id=357 data-nosnippet>357</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">1</span>);
<a href=#358 id=358 data-nosnippet>358</a> <span class="macro">assert_eq!</span>(it.next_back(), <span class="prelude-val">Some</span>(<span class="number">0</span>));
<a href=#359 id=359 data-nosnippet>359</a> <span class="macro">assert_eq!</span>(it.len(), <span class="number">0</span>);
<a href=#360 id=360 data-nosnippet>360</a> <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">None</span>);
<a href=#361 id=361 data-nosnippet>361</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,227 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/monty.rs`."><title>monty.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>monty.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span>alloc::vec::Vec;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span>core::mem;
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use </span>core::ops::Shl;
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span>num_traits::One;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit, DoubleBigDigit};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::biguint::BigUint;
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">struct </span>MontyReducer {
<a href=#10 id=10 data-nosnippet>10</a> n0inv: BigDigit,
<a href=#11 id=11 data-nosnippet>11</a>}
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="comment">// k0 = -m**-1 mod 2**BITS. Algorithm from: Dumas, J.G. "On Newton–Raphson
<a href=#14 id=14 data-nosnippet>14</a>// Iteration for Multiplicative Inverses Modulo Prime Powers".
<a href=#15 id=15 data-nosnippet>15</a></span><span class="kw">fn </span>inv_mod_alt(b: BigDigit) -&gt; BigDigit {
<a href=#16 id=16 data-nosnippet>16</a> <span class="macro">assert_ne!</span>(b &amp; <span class="number">1</span>, <span class="number">0</span>);
<a href=#17 id=17 data-nosnippet>17</a>
<a href=#18 id=18 data-nosnippet>18</a> <span class="kw">let </span><span class="kw-2">mut </span>k0 = BigDigit::wrapping_sub(<span class="number">2</span>, b);
<a href=#19 id=19 data-nosnippet>19</a> <span class="kw">let </span><span class="kw-2">mut </span>t = b - <span class="number">1</span>;
<a href=#20 id=20 data-nosnippet>20</a> <span class="kw">let </span><span class="kw-2">mut </span>i = <span class="number">1</span>;
<a href=#21 id=21 data-nosnippet>21</a> <span class="kw">while </span>i &lt; big_digit::BITS {
<a href=#22 id=22 data-nosnippet>22</a> t = t.wrapping_mul(t);
<a href=#23 id=23 data-nosnippet>23</a> k0 = k0.wrapping_mul(t + <span class="number">1</span>);
<a href=#24 id=24 data-nosnippet>24</a>
<a href=#25 id=25 data-nosnippet>25</a> i &lt;&lt;= <span class="number">1</span>;
<a href=#26 id=26 data-nosnippet>26</a> }
<a href=#27 id=27 data-nosnippet>27</a> <span class="macro">debug_assert_eq!</span>(k0.wrapping_mul(b), <span class="number">1</span>);
<a href=#28 id=28 data-nosnippet>28</a> k0.wrapping_neg()
<a href=#29 id=29 data-nosnippet>29</a>}
<a href=#30 id=30 data-nosnippet>30</a>
<a href=#31 id=31 data-nosnippet>31</a><span class="kw">impl </span>MontyReducer {
<a href=#32 id=32 data-nosnippet>32</a> <span class="kw">fn </span>new(n: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="self">Self </span>{
<a href=#33 id=33 data-nosnippet>33</a> <span class="kw">let </span>n0inv = inv_mod_alt(n.data[<span class="number">0</span>]);
<a href=#34 id=34 data-nosnippet>34</a> MontyReducer { n0inv }
<a href=#35 id=35 data-nosnippet>35</a> }
<a href=#36 id=36 data-nosnippet>36</a>}
<a href=#37 id=37 data-nosnippet>37</a>
<a href=#38 id=38 data-nosnippet>38</a><span class="doccomment">/// Computes z mod m = x * y * 2 ** (-n*_W) mod m
<a href=#39 id=39 data-nosnippet>39</a>/// assuming k = -1/m mod 2**_W
<a href=#40 id=40 data-nosnippet>40</a>/// See Gueron, "Efficient Software Implementations of Modular Exponentiation".
<a href=#41 id=41 data-nosnippet>41</a>/// &lt;https://eprint.iacr.org/2011/239.pdf&gt;
<a href=#42 id=42 data-nosnippet>42</a>/// In the terminology of that paper, this is an "Almost Montgomery Multiplication":
<a href=#43 id=43 data-nosnippet>43</a>/// x and y are required to satisfy 0 &lt;= z &lt; 2**(n*_W) and then the result
<a href=#44 id=44 data-nosnippet>44</a>/// z is guaranteed to satisfy 0 &lt;= z &lt; 2**(n*_W), but it may not be &lt; m.
<a href=#45 id=45 data-nosnippet>45</a></span><span class="attr">#[allow(clippy::many_single_char_names)]
<a href=#46 id=46 data-nosnippet>46</a></span><span class="kw">fn </span>montgomery(x: <span class="kw-2">&amp;</span>BigUint, y: <span class="kw-2">&amp;</span>BigUint, m: <span class="kw-2">&amp;</span>BigUint, k: BigDigit, n: usize) -&gt; BigUint {
<a href=#47 id=47 data-nosnippet>47</a> <span class="comment">// This code assumes x, y, m are all the same length, n.
<a href=#48 id=48 data-nosnippet>48</a> // (required by addMulVVW and the for loop).
<a href=#49 id=49 data-nosnippet>49</a> // It also assumes that x, y are already reduced mod m,
<a href=#50 id=50 data-nosnippet>50</a> // or else the result will not be properly reduced.
<a href=#51 id=51 data-nosnippet>51</a> </span><span class="macro">assert!</span>(
<a href=#52 id=52 data-nosnippet>52</a> x.data.len() == n &amp;&amp; y.data.len() == n &amp;&amp; m.data.len() == n,
<a href=#53 id=53 data-nosnippet>53</a> <span class="string">"{:?} {:?} {:?} {}"</span>,
<a href=#54 id=54 data-nosnippet>54</a> x,
<a href=#55 id=55 data-nosnippet>55</a> y,
<a href=#56 id=56 data-nosnippet>56</a> m,
<a href=#57 id=57 data-nosnippet>57</a> n
<a href=#58 id=58 data-nosnippet>58</a> );
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a> <span class="kw">let </span><span class="kw-2">mut </span>z = BigUint::ZERO;
<a href=#61 id=61 data-nosnippet>61</a> z.data.resize(n * <span class="number">2</span>, <span class="number">0</span>);
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a> <span class="kw">let </span><span class="kw-2">mut </span>c: BigDigit = <span class="number">0</span>;
<a href=#64 id=64 data-nosnippet>64</a> <span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..n {
<a href=#65 id=65 data-nosnippet>65</a> <span class="kw">let </span>c2 = add_mul_vvw(<span class="kw-2">&amp;mut </span>z.data[i..n + i], <span class="kw-2">&amp;</span>x.data, y.data[i]);
<a href=#66 id=66 data-nosnippet>66</a> <span class="kw">let </span>t = z.data[i].wrapping_mul(k);
<a href=#67 id=67 data-nosnippet>67</a> <span class="kw">let </span>c3 = add_mul_vvw(<span class="kw-2">&amp;mut </span>z.data[i..n + i], <span class="kw-2">&amp;</span>m.data, t);
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">let </span>cx = c.wrapping_add(c2);
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">let </span>cy = cx.wrapping_add(c3);
<a href=#70 id=70 data-nosnippet>70</a> z.data[n + i] = cy;
<a href=#71 id=71 data-nosnippet>71</a> <span class="kw">if </span>cx &lt; c2 || cy &lt; c3 {
<a href=#72 id=72 data-nosnippet>72</a> c = <span class="number">1</span>;
<a href=#73 id=73 data-nosnippet>73</a> } <span class="kw">else </span>{
<a href=#74 id=74 data-nosnippet>74</a> c = <span class="number">0</span>;
<a href=#75 id=75 data-nosnippet>75</a> }
<a href=#76 id=76 data-nosnippet>76</a> }
<a href=#77 id=77 data-nosnippet>77</a>
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">if </span>c == <span class="number">0 </span>{
<a href=#79 id=79 data-nosnippet>79</a> z.data = z.data[n..].to_vec();
<a href=#80 id=80 data-nosnippet>80</a> } <span class="kw">else </span>{
<a href=#81 id=81 data-nosnippet>81</a> {
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">let </span>(first, second) = z.data.split_at_mut(n);
<a href=#83 id=83 data-nosnippet>83</a> sub_vv(first, second, <span class="kw-2">&amp;</span>m.data);
<a href=#84 id=84 data-nosnippet>84</a> }
<a href=#85 id=85 data-nosnippet>85</a> z.data = z.data[..n].to_vec();
<a href=#86 id=86 data-nosnippet>86</a> }
<a href=#87 id=87 data-nosnippet>87</a>
<a href=#88 id=88 data-nosnippet>88</a> z
<a href=#89 id=89 data-nosnippet>89</a>}
<a href=#90 id=90 data-nosnippet>90</a>
<a href=#91 id=91 data-nosnippet>91</a><span class="attr">#[inline(always)]
<a href=#92 id=92 data-nosnippet>92</a></span><span class="kw">fn </span>add_mul_vvw(z: <span class="kw-2">&amp;mut </span>[BigDigit], x: <span class="kw-2">&amp;</span>[BigDigit], y: BigDigit) -&gt; BigDigit {
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">let </span><span class="kw-2">mut </span>c = <span class="number">0</span>;
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">for </span>(zi, xi) <span class="kw">in </span>z.iter_mut().zip(x.iter()) {
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw">let </span>(z1, z0) = mul_add_www(<span class="kw-2">*</span>xi, y, <span class="kw-2">*</span>zi);
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">let </span>(c_, zi_) = add_ww(z0, c, <span class="number">0</span>);
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw-2">*</span>zi = zi_;
<a href=#98 id=98 data-nosnippet>98</a> c = c_ + z1;
<a href=#99 id=99 data-nosnippet>99</a> }
<a href=#100 id=100 data-nosnippet>100</a>
<a href=#101 id=101 data-nosnippet>101</a> c
<a href=#102 id=102 data-nosnippet>102</a>}
<a href=#103 id=103 data-nosnippet>103</a>
<a href=#104 id=104 data-nosnippet>104</a><span class="doccomment">/// The resulting carry c is either 0 or 1.
<a href=#105 id=105 data-nosnippet>105</a></span><span class="attr">#[inline(always)]
<a href=#106 id=106 data-nosnippet>106</a></span><span class="kw">fn </span>sub_vv(z: <span class="kw-2">&amp;mut </span>[BigDigit], x: <span class="kw-2">&amp;</span>[BigDigit], y: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; BigDigit {
<a href=#107 id=107 data-nosnippet>107</a> <span class="kw">let </span><span class="kw-2">mut </span>c = <span class="number">0</span>;
<a href=#108 id=108 data-nosnippet>108</a> <span class="kw">for </span>(i, (xi, yi)) <span class="kw">in </span>x.iter().zip(y.iter()).enumerate().take(z.len()) {
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">let </span>zi = xi.wrapping_sub(<span class="kw-2">*</span>yi).wrapping_sub(c);
<a href=#110 id=110 data-nosnippet>110</a> z[i] = zi;
<a href=#111 id=111 data-nosnippet>111</a> <span class="comment">// see "Hacker's Delight", section 2-12 (overflow detection)
<a href=#112 id=112 data-nosnippet>112</a> </span>c = ((yi &amp; !xi) | ((yi | !xi) &amp; zi)) &gt;&gt; (big_digit::BITS - <span class="number">1</span>)
<a href=#113 id=113 data-nosnippet>113</a> }
<a href=#114 id=114 data-nosnippet>114</a>
<a href=#115 id=115 data-nosnippet>115</a> c
<a href=#116 id=116 data-nosnippet>116</a>}
<a href=#117 id=117 data-nosnippet>117</a>
<a href=#118 id=118 data-nosnippet>118</a><span class="doccomment">/// z1&lt;&lt;_W + z0 = x+y+c, with c == 0 or 1
<a href=#119 id=119 data-nosnippet>119</a></span><span class="attr">#[inline(always)]
<a href=#120 id=120 data-nosnippet>120</a></span><span class="kw">fn </span>add_ww(x: BigDigit, y: BigDigit, c: BigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#121 id=121 data-nosnippet>121</a> <span class="kw">let </span>yc = y.wrapping_add(c);
<a href=#122 id=122 data-nosnippet>122</a> <span class="kw">let </span>z0 = x.wrapping_add(yc);
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">let </span>z1 = <span class="kw">if </span>z0 &lt; x || yc &lt; y { <span class="number">1 </span>} <span class="kw">else </span>{ <span class="number">0 </span>};
<a href=#124 id=124 data-nosnippet>124</a>
<a href=#125 id=125 data-nosnippet>125</a> (z1, z0)
<a href=#126 id=126 data-nosnippet>126</a>}
<a href=#127 id=127 data-nosnippet>127</a>
<a href=#128 id=128 data-nosnippet>128</a><span class="doccomment">/// z1 &lt;&lt; _W + z0 = x * y + c
<a href=#129 id=129 data-nosnippet>129</a></span><span class="attr">#[inline(always)]
<a href=#130 id=130 data-nosnippet>130</a></span><span class="kw">fn </span>mul_add_www(x: BigDigit, y: BigDigit, c: BigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#131 id=131 data-nosnippet>131</a> <span class="kw">let </span>z = x <span class="kw">as </span>DoubleBigDigit * y <span class="kw">as </span>DoubleBigDigit + c <span class="kw">as </span>DoubleBigDigit;
<a href=#132 id=132 data-nosnippet>132</a> ((z &gt;&gt; big_digit::BITS) <span class="kw">as </span>BigDigit, z <span class="kw">as </span>BigDigit)
<a href=#133 id=133 data-nosnippet>133</a>}
<a href=#134 id=134 data-nosnippet>134</a>
<a href=#135 id=135 data-nosnippet>135</a><span class="doccomment">/// Calculates x ** y mod m using a fixed, 4-bit window.
<a href=#136 id=136 data-nosnippet>136</a></span><span class="attr">#[allow(clippy::many_single_char_names)]
<a href=#137 id=137 data-nosnippet>137</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>monty_modpow(x: <span class="kw-2">&amp;</span>BigUint, y: <span class="kw-2">&amp;</span>BigUint, m: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#138 id=138 data-nosnippet>138</a> <span class="macro">assert!</span>(m.data[<span class="number">0</span>] &amp; <span class="number">1 </span>== <span class="number">1</span>);
<a href=#139 id=139 data-nosnippet>139</a> <span class="kw">let </span>mr = MontyReducer::new(m);
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span>num_words = m.data.len();
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">let </span><span class="kw-2">mut </span>x = x.clone();
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a> <span class="comment">// We want the lengths of x and m to be equal.
<a href=#145 id=145 data-nosnippet>145</a> // It is OK if x &gt;= m as long as len(x) == len(m).
<a href=#146 id=146 data-nosnippet>146</a> </span><span class="kw">if </span>x.data.len() &gt; num_words {
<a href=#147 id=147 data-nosnippet>147</a> x %= m;
<a href=#148 id=148 data-nosnippet>148</a> <span class="comment">// Note: now len(x) &lt;= numWords, not guaranteed ==.
<a href=#149 id=149 data-nosnippet>149</a> </span>}
<a href=#150 id=150 data-nosnippet>150</a> <span class="kw">if </span>x.data.len() &lt; num_words {
<a href=#151 id=151 data-nosnippet>151</a> x.data.resize(num_words, <span class="number">0</span>);
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a>
<a href=#154 id=154 data-nosnippet>154</a> <span class="comment">// rr = 2**(2*_W*len(m)) mod m
<a href=#155 id=155 data-nosnippet>155</a> </span><span class="kw">let </span><span class="kw-2">mut </span>rr = BigUint::one();
<a href=#156 id=156 data-nosnippet>156</a> rr = (rr.shl(<span class="number">2 </span>* num_words <span class="kw">as </span>u64 * u64::from(big_digit::BITS))) % m;
<a href=#157 id=157 data-nosnippet>157</a> <span class="kw">if </span>rr.data.len() &lt; num_words {
<a href=#158 id=158 data-nosnippet>158</a> rr.data.resize(num_words, <span class="number">0</span>);
<a href=#159 id=159 data-nosnippet>159</a> }
<a href=#160 id=160 data-nosnippet>160</a> <span class="comment">// one = 1, with equal length to that of m
<a href=#161 id=161 data-nosnippet>161</a> </span><span class="kw">let </span><span class="kw-2">mut </span>one = BigUint::one();
<a href=#162 id=162 data-nosnippet>162</a> one.data.resize(num_words, <span class="number">0</span>);
<a href=#163 id=163 data-nosnippet>163</a>
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">let </span>n = <span class="number">4</span>;
<a href=#165 id=165 data-nosnippet>165</a> <span class="comment">// powers[i] contains x^i
<a href=#166 id=166 data-nosnippet>166</a> </span><span class="kw">let </span><span class="kw-2">mut </span>powers = Vec::with_capacity(<span class="number">1 </span>&lt;&lt; n);
<a href=#167 id=167 data-nosnippet>167</a> powers.push(montgomery(<span class="kw-2">&amp;</span>one, <span class="kw-2">&amp;</span>rr, m, mr.n0inv, num_words));
<a href=#168 id=168 data-nosnippet>168</a> powers.push(montgomery(<span class="kw-2">&amp;</span>x, <span class="kw-2">&amp;</span>rr, m, mr.n0inv, num_words));
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">for </span>i <span class="kw">in </span><span class="number">2</span>..<span class="number">1 </span>&lt;&lt; n {
<a href=#170 id=170 data-nosnippet>170</a> <span class="kw">let </span>r = montgomery(<span class="kw-2">&amp;</span>powers[i - <span class="number">1</span>], <span class="kw-2">&amp;</span>powers[<span class="number">1</span>], m, mr.n0inv, num_words);
<a href=#171 id=171 data-nosnippet>171</a> powers.push(r);
<a href=#172 id=172 data-nosnippet>172</a> }
<a href=#173 id=173 data-nosnippet>173</a>
<a href=#174 id=174 data-nosnippet>174</a> <span class="comment">// initialize z = 1 (Montgomery 1)
<a href=#175 id=175 data-nosnippet>175</a> </span><span class="kw">let </span><span class="kw-2">mut </span>z = powers[<span class="number">0</span>].clone();
<a href=#176 id=176 data-nosnippet>176</a> z.data.resize(num_words, <span class="number">0</span>);
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">let </span><span class="kw-2">mut </span>zz = BigUint::ZERO;
<a href=#178 id=178 data-nosnippet>178</a> zz.data.resize(num_words, <span class="number">0</span>);
<a href=#179 id=179 data-nosnippet>179</a>
<a href=#180 id=180 data-nosnippet>180</a> <span class="comment">// same windowed exponent, but with Montgomery multiplications
<a href=#181 id=181 data-nosnippet>181</a> </span><span class="kw">for </span>i <span class="kw">in </span>(<span class="number">0</span>..y.data.len()).rev() {
<a href=#182 id=182 data-nosnippet>182</a> <span class="kw">let </span><span class="kw-2">mut </span>yi = y.data[i];
<a href=#183 id=183 data-nosnippet>183</a> <span class="kw">let </span><span class="kw-2">mut </span>j = <span class="number">0</span>;
<a href=#184 id=184 data-nosnippet>184</a> <span class="kw">while </span>j &lt; big_digit::BITS {
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">if </span><span class="macro">i !</span>= y.data.len() - <span class="number">1 </span>|| <span class="macro">j !</span>= <span class="number">0 </span>{
<a href=#186 id=186 data-nosnippet>186</a> zz = montgomery(<span class="kw-2">&amp;</span>z, <span class="kw-2">&amp;</span>z, m, mr.n0inv, num_words);
<a href=#187 id=187 data-nosnippet>187</a> z = montgomery(<span class="kw-2">&amp;</span>zz, <span class="kw-2">&amp;</span>zz, m, mr.n0inv, num_words);
<a href=#188 id=188 data-nosnippet>188</a> zz = montgomery(<span class="kw-2">&amp;</span>z, <span class="kw-2">&amp;</span>z, m, mr.n0inv, num_words);
<a href=#189 id=189 data-nosnippet>189</a> z = montgomery(<span class="kw-2">&amp;</span>zz, <span class="kw-2">&amp;</span>zz, m, mr.n0inv, num_words);
<a href=#190 id=190 data-nosnippet>190</a> }
<a href=#191 id=191 data-nosnippet>191</a> zz = montgomery(
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw-2">&amp;</span>z,
<a href=#193 id=193 data-nosnippet>193</a> <span class="kw-2">&amp;</span>powers[(yi &gt;&gt; (big_digit::BITS - n)) <span class="kw">as </span>usize],
<a href=#194 id=194 data-nosnippet>194</a> m,
<a href=#195 id=195 data-nosnippet>195</a> mr.n0inv,
<a href=#196 id=196 data-nosnippet>196</a> num_words,
<a href=#197 id=197 data-nosnippet>197</a> );
<a href=#198 id=198 data-nosnippet>198</a> mem::swap(<span class="kw-2">&amp;mut </span>z, <span class="kw-2">&amp;mut </span>zz);
<a href=#199 id=199 data-nosnippet>199</a> yi &lt;&lt;= n;
<a href=#200 id=200 data-nosnippet>200</a> j += n;
<a href=#201 id=201 data-nosnippet>201</a> }
<a href=#202 id=202 data-nosnippet>202</a> }
<a href=#203 id=203 data-nosnippet>203</a>
<a href=#204 id=204 data-nosnippet>204</a> <span class="comment">// convert to regular number
<a href=#205 id=205 data-nosnippet>205</a> </span>zz = montgomery(<span class="kw-2">&amp;</span>z, <span class="kw-2">&amp;</span>one, m, mr.n0inv, num_words);
<a href=#206 id=206 data-nosnippet>206</a>
<a href=#207 id=207 data-nosnippet>207</a> zz.normalize();
<a href=#208 id=208 data-nosnippet>208</a> <span class="comment">// One last reduction, just in case.
<a href=#209 id=209 data-nosnippet>209</a> // See golang.org/issue/13907.
<a href=#210 id=210 data-nosnippet>210</a> </span><span class="kw">if </span>zz &gt;= <span class="kw-2">*</span>m {
<a href=#211 id=211 data-nosnippet>211</a> <span class="comment">// Common case is m has high bit set; in that case,
<a href=#212 id=212 data-nosnippet>212</a> // since zz is the same length as m, there can be just
<a href=#213 id=213 data-nosnippet>213</a> // one multiple of m to remove. Just subtract.
<a href=#214 id=214 data-nosnippet>214</a> // We think that the subtract should be sufficient in general,
<a href=#215 id=215 data-nosnippet>215</a> // so do that unconditionally, but double-check,
<a href=#216 id=216 data-nosnippet>216</a> // in case our beliefs are wrong.
<a href=#217 id=217 data-nosnippet>217</a> // The div is not expected to be reached.
<a href=#218 id=218 data-nosnippet>218</a> </span>zz -= m;
<a href=#219 id=219 data-nosnippet>219</a> <span class="kw">if </span>zz &gt;= <span class="kw-2">*</span>m {
<a href=#220 id=220 data-nosnippet>220</a> zz %= m;
<a href=#221 id=221 data-nosnippet>221</a> }
<a href=#222 id=222 data-nosnippet>222</a> }
<a href=#223 id=223 data-nosnippet>223</a>
<a href=#224 id=224 data-nosnippet>224</a> zz.normalize();
<a href=#225 id=225 data-nosnippet>225</a> zz
<a href=#226 id=226 data-nosnippet>226</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,627 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/multiplication.rs`."><title>multiplication.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>multiplication.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::addition::{__add2, add2};
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::subtraction::sub2;
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use super</span>::{biguint_from_vec, cmp_slice, BigUint, IntDigits};
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit, DoubleBigDigit};
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::Sign::{<span class="self">self</span>, Minus, NoSign, Plus};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use crate</span>::{BigInt, UsizePromotion};
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>core::cmp::Ordering;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span>core::iter::Product;
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span>core::ops::{Mul, MulAssign};
<a href=#12 id=12 data-nosnippet>12</a><span class="kw">use </span>num_traits::{CheckedMul, FromPrimitive, One, Zero};
<a href=#13 id=13 data-nosnippet>13</a>
<a href=#14 id=14 data-nosnippet>14</a><span class="attr">#[inline]
<a href=#15 id=15 data-nosnippet>15</a></span><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>mac_with_carry(
<a href=#16 id=16 data-nosnippet>16</a> a: BigDigit,
<a href=#17 id=17 data-nosnippet>17</a> b: BigDigit,
<a href=#18 id=18 data-nosnippet>18</a> c: BigDigit,
<a href=#19 id=19 data-nosnippet>19</a> acc: <span class="kw-2">&amp;mut </span>DoubleBigDigit,
<a href=#20 id=20 data-nosnippet>20</a>) -&gt; BigDigit {
<a href=#21 id=21 data-nosnippet>21</a> <span class="kw-2">*</span>acc += DoubleBigDigit::from(a);
<a href=#22 id=22 data-nosnippet>22</a> <span class="kw-2">*</span>acc += DoubleBigDigit::from(b) * DoubleBigDigit::from(c);
<a href=#23 id=23 data-nosnippet>23</a> <span class="kw">let </span>lo = <span class="kw-2">*</span>acc <span class="kw">as </span>BigDigit;
<a href=#24 id=24 data-nosnippet>24</a> <span class="kw-2">*</span>acc &gt;&gt;= big_digit::BITS;
<a href=#25 id=25 data-nosnippet>25</a> lo
<a href=#26 id=26 data-nosnippet>26</a>}
<a href=#27 id=27 data-nosnippet>27</a>
<a href=#28 id=28 data-nosnippet>28</a><span class="attr">#[inline]
<a href=#29 id=29 data-nosnippet>29</a></span><span class="kw">fn </span>mul_with_carry(a: BigDigit, b: BigDigit, acc: <span class="kw-2">&amp;mut </span>DoubleBigDigit) -&gt; BigDigit {
<a href=#30 id=30 data-nosnippet>30</a> <span class="kw-2">*</span>acc += DoubleBigDigit::from(a) * DoubleBigDigit::from(b);
<a href=#31 id=31 data-nosnippet>31</a> <span class="kw">let </span>lo = <span class="kw-2">*</span>acc <span class="kw">as </span>BigDigit;
<a href=#32 id=32 data-nosnippet>32</a> <span class="kw-2">*</span>acc &gt;&gt;= big_digit::BITS;
<a href=#33 id=33 data-nosnippet>33</a> lo
<a href=#34 id=34 data-nosnippet>34</a>}
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a><span class="doccomment">/// Three argument multiply accumulate:
<a href=#37 id=37 data-nosnippet>37</a>/// acc += b * c
<a href=#38 id=38 data-nosnippet>38</a></span><span class="kw">fn </span>mac_digit(acc: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit], c: BigDigit) {
<a href=#39 id=39 data-nosnippet>39</a> <span class="kw">if </span>c == <span class="number">0 </span>{
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">return</span>;
<a href=#41 id=41 data-nosnippet>41</a> }
<a href=#42 id=42 data-nosnippet>42</a>
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="number">0</span>;
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw">let </span>(a_lo, a_hi) = acc.split_at_mut(b.len());
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a> <span class="kw">for </span>(a, <span class="kw-2">&amp;</span>b) <span class="kw">in </span>a_lo.iter_mut().zip(b) {
<a href=#47 id=47 data-nosnippet>47</a> <span class="kw-2">*</span>a = mac_with_carry(<span class="kw-2">*</span>a, b, c, <span class="kw-2">&amp;mut </span>carry);
<a href=#48 id=48 data-nosnippet>48</a> }
<a href=#49 id=49 data-nosnippet>49</a>
<a href=#50 id=50 data-nosnippet>50</a> <span class="kw">let </span>(carry_hi, carry_lo) = big_digit::from_doublebigdigit(carry);
<a href=#51 id=51 data-nosnippet>51</a>
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">let </span>final_carry = <span class="kw">if </span>carry_hi == <span class="number">0 </span>{
<a href=#53 id=53 data-nosnippet>53</a> __add2(a_hi, <span class="kw-2">&amp;</span>[carry_lo])
<a href=#54 id=54 data-nosnippet>54</a> } <span class="kw">else </span>{
<a href=#55 id=55 data-nosnippet>55</a> __add2(a_hi, <span class="kw-2">&amp;</span>[carry_hi, carry_lo])
<a href=#56 id=56 data-nosnippet>56</a> };
<a href=#57 id=57 data-nosnippet>57</a> <span class="macro">assert_eq!</span>(final_carry, <span class="number">0</span>, <span class="string">"carry overflow during multiplication!"</span>);
<a href=#58 id=58 data-nosnippet>58</a>}
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a><span class="kw">fn </span>bigint_from_slice(slice: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; BigInt {
<a href=#61 id=61 data-nosnippet>61</a> BigInt::from(biguint_from_vec(slice.to_vec()))
<a href=#62 id=62 data-nosnippet>62</a>}
<a href=#63 id=63 data-nosnippet>63</a>
<a href=#64 id=64 data-nosnippet>64</a><span class="doccomment">/// Three argument multiply accumulate:
<a href=#65 id=65 data-nosnippet>65</a>/// acc += b * c
<a href=#66 id=66 data-nosnippet>66</a></span><span class="attr">#[allow(clippy::many_single_char_names)]
<a href=#67 id=67 data-nosnippet>67</a></span><span class="kw">fn </span>mac3(<span class="kw-2">mut </span>acc: <span class="kw-2">&amp;mut </span>[BigDigit], <span class="kw-2">mut </span>b: <span class="kw-2">&amp;</span>[BigDigit], <span class="kw-2">mut </span>c: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#68 id=68 data-nosnippet>68</a> <span class="comment">// Least-significant zeros have no effect on the output.
<a href=#69 id=69 data-nosnippet>69</a> </span><span class="kw">if let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) = b.first() {
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(nz) = b.iter().position(|<span class="kw-2">&amp;</span>d| <span class="macro">d !</span>= <span class="number">0</span>) {
<a href=#71 id=71 data-nosnippet>71</a> b = <span class="kw-2">&amp;</span>b[nz..];
<a href=#72 id=72 data-nosnippet>72</a> acc = <span class="kw-2">&amp;mut </span>acc[nz..];
<a href=#73 id=73 data-nosnippet>73</a> } <span class="kw">else </span>{
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">return</span>;
<a href=#75 id=75 data-nosnippet>75</a> }
<a href=#76 id=76 data-nosnippet>76</a> }
<a href=#77 id=77 data-nosnippet>77</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) = c.first() {
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(nz) = c.iter().position(|<span class="kw-2">&amp;</span>d| <span class="macro">d !</span>= <span class="number">0</span>) {
<a href=#79 id=79 data-nosnippet>79</a> c = <span class="kw-2">&amp;</span>c[nz..];
<a href=#80 id=80 data-nosnippet>80</a> acc = <span class="kw-2">&amp;mut </span>acc[nz..];
<a href=#81 id=81 data-nosnippet>81</a> } <span class="kw">else </span>{
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">return</span>;
<a href=#83 id=83 data-nosnippet>83</a> }
<a href=#84 id=84 data-nosnippet>84</a> }
<a href=#85 id=85 data-nosnippet>85</a>
<a href=#86 id=86 data-nosnippet>86</a> <span class="kw">let </span>acc = acc;
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw">let </span>(x, y) = <span class="kw">if </span>b.len() &lt; c.len() { (b, c) } <span class="kw">else </span>{ (c, b) };
<a href=#88 id=88 data-nosnippet>88</a>
<a href=#89 id=89 data-nosnippet>89</a> <span class="comment">// We use four algorithms for different input sizes.
<a href=#90 id=90 data-nosnippet>90</a> //
<a href=#91 id=91 data-nosnippet>91</a> // - For small inputs, long multiplication is fastest.
<a href=#92 id=92 data-nosnippet>92</a> // - If y is at least least twice as long as x, split using Half-Karatsuba.
<a href=#93 id=93 data-nosnippet>93</a> // - Next we use Karatsuba multiplication (Toom-2), which we have optimized
<a href=#94 id=94 data-nosnippet>94</a> // to avoid unnecessary allocations for intermediate values.
<a href=#95 id=95 data-nosnippet>95</a> // - For the largest inputs we use Toom-3, which better optimizes the
<a href=#96 id=96 data-nosnippet>96</a> // number of operations, but uses more temporary allocations.
<a href=#97 id=97 data-nosnippet>97</a> //
<a href=#98 id=98 data-nosnippet>98</a> // The thresholds are somewhat arbitrary, chosen by evaluating the results
<a href=#99 id=99 data-nosnippet>99</a> // of `cargo bench --bench bigint multiply`.
<a href=#100 id=100 data-nosnippet>100</a>
<a href=#101 id=101 data-nosnippet>101</a> </span><span class="kw">if </span>x.len() &lt;= <span class="number">32 </span>{
<a href=#102 id=102 data-nosnippet>102</a> <span class="comment">// Long multiplication:
<a href=#103 id=103 data-nosnippet>103</a> </span><span class="kw">for </span>(i, xi) <span class="kw">in </span>x.iter().enumerate() {
<a href=#104 id=104 data-nosnippet>104</a> mac_digit(<span class="kw-2">&amp;mut </span>acc[i..], y, <span class="kw-2">*</span>xi);
<a href=#105 id=105 data-nosnippet>105</a> }
<a href=#106 id=106 data-nosnippet>106</a> } <span class="kw">else if </span>x.len() * <span class="number">2 </span>&lt;= y.len() {
<a href=#107 id=107 data-nosnippet>107</a> <span class="comment">// Karatsuba Multiplication for factors with significant length disparity.
<a href=#108 id=108 data-nosnippet>108</a> //
<a href=#109 id=109 data-nosnippet>109</a> // The Half-Karatsuba Multiplication Algorithm is a specialized case of
<a href=#110 id=110 data-nosnippet>110</a> // the normal Karatsuba multiplication algorithm, designed for the scenario
<a href=#111 id=111 data-nosnippet>111</a> // where y has at least twice as many base digits as x.
<a href=#112 id=112 data-nosnippet>112</a> //
<a href=#113 id=113 data-nosnippet>113</a> // In this case y (the longer input) is split into high2 and low2,
<a href=#114 id=114 data-nosnippet>114</a> // at m2 (half the length of y) and x (the shorter input),
<a href=#115 id=115 data-nosnippet>115</a> // is used directly without splitting.
<a href=#116 id=116 data-nosnippet>116</a> //
<a href=#117 id=117 data-nosnippet>117</a> // The algorithm then proceeds as follows:
<a href=#118 id=118 data-nosnippet>118</a> //
<a href=#119 id=119 data-nosnippet>119</a> // 1. Compute the product z0 = x * low2.
<a href=#120 id=120 data-nosnippet>120</a> // 2. Compute the product temp = x * high2.
<a href=#121 id=121 data-nosnippet>121</a> // 3. Adjust the weight of temp by adding m2 (* NBASE ^ m2)
<a href=#122 id=122 data-nosnippet>122</a> // 4. Add temp and z0 to obtain the final result.
<a href=#123 id=123 data-nosnippet>123</a> //
<a href=#124 id=124 data-nosnippet>124</a> // Proof:
<a href=#125 id=125 data-nosnippet>125</a> //
<a href=#126 id=126 data-nosnippet>126</a> // The algorithm can be derived from the original Karatsuba algorithm by
<a href=#127 id=127 data-nosnippet>127</a> // simplifying the formula when the shorter factor x is not split into
<a href=#128 id=128 data-nosnippet>128</a> // high and low parts, as shown below.
<a href=#129 id=129 data-nosnippet>129</a> //
<a href=#130 id=130 data-nosnippet>130</a> // Original Karatsuba formula:
<a href=#131 id=131 data-nosnippet>131</a> //
<a href=#132 id=132 data-nosnippet>132</a> // result = (z2 * NBASE ^ (m2 × 2)) + ((z1 - z2 - z0) * NBASE ^ m2) + z0
<a href=#133 id=133 data-nosnippet>133</a> //
<a href=#134 id=134 data-nosnippet>134</a> // Substitutions:
<a href=#135 id=135 data-nosnippet>135</a> //
<a href=#136 id=136 data-nosnippet>136</a> // low1 = x
<a href=#137 id=137 data-nosnippet>137</a> // high1 = 0
<a href=#138 id=138 data-nosnippet>138</a> //
<a href=#139 id=139 data-nosnippet>139</a> // Applying substitutions:
<a href=#140 id=140 data-nosnippet>140</a> //
<a href=#141 id=141 data-nosnippet>141</a> // z0 = (low1 * low2)
<a href=#142 id=142 data-nosnippet>142</a> // = (x * low2)
<a href=#143 id=143 data-nosnippet>143</a> //
<a href=#144 id=144 data-nosnippet>144</a> // z1 = ((low1 + high1) * (low2 + high2))
<a href=#145 id=145 data-nosnippet>145</a> // = ((x + 0) * (low2 + high2))
<a href=#146 id=146 data-nosnippet>146</a> // = (x * low2) + (x * high2)
<a href=#147 id=147 data-nosnippet>147</a> //
<a href=#148 id=148 data-nosnippet>148</a> // z2 = (high1 * high2)
<a href=#149 id=149 data-nosnippet>149</a> // = (0 * high2)
<a href=#150 id=150 data-nosnippet>150</a> // = 0
<a href=#151 id=151 data-nosnippet>151</a> //
<a href=#152 id=152 data-nosnippet>152</a> // Simplified using the above substitutions:
<a href=#153 id=153 data-nosnippet>153</a> //
<a href=#154 id=154 data-nosnippet>154</a> // result = (z2 * NBASE ^ (m2 × 2)) + ((z1 - z2 - z0) * NBASE ^ m2) + z0
<a href=#155 id=155 data-nosnippet>155</a> // = (0 * NBASE ^ (m2 × 2)) + ((z1 - 0 - z0) * NBASE ^ m2) + z0
<a href=#156 id=156 data-nosnippet>156</a> // = ((z1 - z0) * NBASE ^ m2) + z0
<a href=#157 id=157 data-nosnippet>157</a> // = ((z1 - z0) * NBASE ^ m2) + z0
<a href=#158 id=158 data-nosnippet>158</a> // = (x * high2) * NBASE ^ m2 + z0
<a href=#159 id=159 data-nosnippet>159</a> </span><span class="kw">let </span>m2 = y.len() / <span class="number">2</span>;
<a href=#160 id=160 data-nosnippet>160</a> <span class="kw">let </span>(low2, high2) = y.split_at(m2);
<a href=#161 id=161 data-nosnippet>161</a>
<a href=#162 id=162 data-nosnippet>162</a> <span class="comment">// (x * high2) * NBASE ^ m2 + z0
<a href=#163 id=163 data-nosnippet>163</a> </span>mac3(acc, x, low2);
<a href=#164 id=164 data-nosnippet>164</a> mac3(<span class="kw-2">&amp;mut </span>acc[m2..], x, high2);
<a href=#165 id=165 data-nosnippet>165</a> } <span class="kw">else if </span>x.len() &lt;= <span class="number">256 </span>{
<a href=#166 id=166 data-nosnippet>166</a> <span class="comment">// Karatsuba multiplication:
<a href=#167 id=167 data-nosnippet>167</a> //
<a href=#168 id=168 data-nosnippet>168</a> // The idea is that we break x and y up into two smaller numbers that each have about half
<a href=#169 id=169 data-nosnippet>169</a> // as many digits, like so (note that multiplying by b is just a shift):
<a href=#170 id=170 data-nosnippet>170</a> //
<a href=#171 id=171 data-nosnippet>171</a> // x = x0 + x1 * b
<a href=#172 id=172 data-nosnippet>172</a> // y = y0 + y1 * b
<a href=#173 id=173 data-nosnippet>173</a> //
<a href=#174 id=174 data-nosnippet>174</a> // With some algebra, we can compute x * y with three smaller products, where the inputs to
<a href=#175 id=175 data-nosnippet>175</a> // each of the smaller products have only about half as many digits as x and y:
<a href=#176 id=176 data-nosnippet>176</a> //
<a href=#177 id=177 data-nosnippet>177</a> // x * y = (x0 + x1 * b) * (y0 + y1 * b)
<a href=#178 id=178 data-nosnippet>178</a> //
<a href=#179 id=179 data-nosnippet>179</a> // x * y = x0 * y0
<a href=#180 id=180 data-nosnippet>180</a> // + x0 * y1 * b
<a href=#181 id=181 data-nosnippet>181</a> // + x1 * y0 * b
<a href=#182 id=182 data-nosnippet>182</a> // + x1 * y1 * b^2
<a href=#183 id=183 data-nosnippet>183</a> //
<a href=#184 id=184 data-nosnippet>184</a> // Let p0 = x0 * y0 and p2 = x1 * y1:
<a href=#185 id=185 data-nosnippet>185</a> //
<a href=#186 id=186 data-nosnippet>186</a> // x * y = p0
<a href=#187 id=187 data-nosnippet>187</a> // + (x0 * y1 + x1 * y0) * b
<a href=#188 id=188 data-nosnippet>188</a> // + p2 * b^2
<a href=#189 id=189 data-nosnippet>189</a> //
<a href=#190 id=190 data-nosnippet>190</a> // The real trick is that middle term:
<a href=#191 id=191 data-nosnippet>191</a> //
<a href=#192 id=192 data-nosnippet>192</a> // x0 * y1 + x1 * y0
<a href=#193 id=193 data-nosnippet>193</a> //
<a href=#194 id=194 data-nosnippet>194</a> // = x0 * y1 + x1 * y0 - p0 + p0 - p2 + p2
<a href=#195 id=195 data-nosnippet>195</a> //
<a href=#196 id=196 data-nosnippet>196</a> // = x0 * y1 + x1 * y0 - x0 * y0 - x1 * y1 + p0 + p2
<a href=#197 id=197 data-nosnippet>197</a> //
<a href=#198 id=198 data-nosnippet>198</a> // Now we complete the square:
<a href=#199 id=199 data-nosnippet>199</a> //
<a href=#200 id=200 data-nosnippet>200</a> // = -(x0 * y0 - x0 * y1 - x1 * y0 + x1 * y1) + p0 + p2
<a href=#201 id=201 data-nosnippet>201</a> //
<a href=#202 id=202 data-nosnippet>202</a> // = -((x1 - x0) * (y1 - y0)) + p0 + p2
<a href=#203 id=203 data-nosnippet>203</a> //
<a href=#204 id=204 data-nosnippet>204</a> // Let p1 = (x1 - x0) * (y1 - y0), and substitute back into our original formula:
<a href=#205 id=205 data-nosnippet>205</a> //
<a href=#206 id=206 data-nosnippet>206</a> // x * y = p0
<a href=#207 id=207 data-nosnippet>207</a> // + (p0 + p2 - p1) * b
<a href=#208 id=208 data-nosnippet>208</a> // + p2 * b^2
<a href=#209 id=209 data-nosnippet>209</a> //
<a href=#210 id=210 data-nosnippet>210</a> // Where the three intermediate products are:
<a href=#211 id=211 data-nosnippet>211</a> //
<a href=#212 id=212 data-nosnippet>212</a> // p0 = x0 * y0
<a href=#213 id=213 data-nosnippet>213</a> // p1 = (x1 - x0) * (y1 - y0)
<a href=#214 id=214 data-nosnippet>214</a> // p2 = x1 * y1
<a href=#215 id=215 data-nosnippet>215</a> //
<a href=#216 id=216 data-nosnippet>216</a> // In doing the computation, we take great care to avoid unnecessary temporary variables
<a href=#217 id=217 data-nosnippet>217</a> // (since creating a BigUint requires a heap allocation): thus, we rearrange the formula a
<a href=#218 id=218 data-nosnippet>218</a> // bit so we can use the same temporary variable for all the intermediate products:
<a href=#219 id=219 data-nosnippet>219</a> //
<a href=#220 id=220 data-nosnippet>220</a> // x * y = p2 * b^2 + p2 * b
<a href=#221 id=221 data-nosnippet>221</a> // + p0 * b + p0
<a href=#222 id=222 data-nosnippet>222</a> // - p1 * b
<a href=#223 id=223 data-nosnippet>223</a> //
<a href=#224 id=224 data-nosnippet>224</a> // The other trick we use is instead of doing explicit shifts, we slice acc at the
<a href=#225 id=225 data-nosnippet>225</a> // appropriate offset when doing the add.
<a href=#226 id=226 data-nosnippet>226</a>
<a href=#227 id=227 data-nosnippet>227</a> // When x is smaller than y, it's significantly faster to pick b such that x is split in
<a href=#228 id=228 data-nosnippet>228</a> // half, not y:
<a href=#229 id=229 data-nosnippet>229</a> </span><span class="kw">let </span>b = x.len() / <span class="number">2</span>;
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">let </span>(x0, x1) = x.split_at(b);
<a href=#231 id=231 data-nosnippet>231</a> <span class="kw">let </span>(y0, y1) = y.split_at(b);
<a href=#232 id=232 data-nosnippet>232</a>
<a href=#233 id=233 data-nosnippet>233</a> <span class="comment">// We reuse the same BigUint for all the intermediate multiplies and have to size p
<a href=#234 id=234 data-nosnippet>234</a> // appropriately here: x1.len() &gt;= x0.len and y1.len() &gt;= y0.len():
<a href=#235 id=235 data-nosnippet>235</a> </span><span class="kw">let </span>len = x1.len() + y1.len() + <span class="number">1</span>;
<a href=#236 id=236 data-nosnippet>236</a> <span class="kw">let </span><span class="kw-2">mut </span>p = BigUint { data: <span class="macro">vec!</span>[<span class="number">0</span>; len] };
<a href=#237 id=237 data-nosnippet>237</a>
<a href=#238 id=238 data-nosnippet>238</a> <span class="comment">// p2 = x1 * y1
<a href=#239 id=239 data-nosnippet>239</a> </span>mac3(<span class="kw-2">&amp;mut </span>p.data, x1, y1);
<a href=#240 id=240 data-nosnippet>240</a>
<a href=#241 id=241 data-nosnippet>241</a> <span class="comment">// Not required, but the adds go faster if we drop any unneeded 0s from the end:
<a href=#242 id=242 data-nosnippet>242</a> </span>p.normalize();
<a href=#243 id=243 data-nosnippet>243</a>
<a href=#244 id=244 data-nosnippet>244</a> add2(<span class="kw-2">&amp;mut </span>acc[b..], <span class="kw-2">&amp;</span>p.data);
<a href=#245 id=245 data-nosnippet>245</a> add2(<span class="kw-2">&amp;mut </span>acc[b * <span class="number">2</span>..], <span class="kw-2">&amp;</span>p.data);
<a href=#246 id=246 data-nosnippet>246</a>
<a href=#247 id=247 data-nosnippet>247</a> <span class="comment">// Zero out p before the next multiply:
<a href=#248 id=248 data-nosnippet>248</a> </span>p.data.truncate(<span class="number">0</span>);
<a href=#249 id=249 data-nosnippet>249</a> p.data.resize(len, <span class="number">0</span>);
<a href=#250 id=250 data-nosnippet>250</a>
<a href=#251 id=251 data-nosnippet>251</a> <span class="comment">// p0 = x0 * y0
<a href=#252 id=252 data-nosnippet>252</a> </span>mac3(<span class="kw-2">&amp;mut </span>p.data, x0, y0);
<a href=#253 id=253 data-nosnippet>253</a> p.normalize();
<a href=#254 id=254 data-nosnippet>254</a>
<a href=#255 id=255 data-nosnippet>255</a> add2(acc, <span class="kw-2">&amp;</span>p.data);
<a href=#256 id=256 data-nosnippet>256</a> add2(<span class="kw-2">&amp;mut </span>acc[b..], <span class="kw-2">&amp;</span>p.data);
<a href=#257 id=257 data-nosnippet>257</a>
<a href=#258 id=258 data-nosnippet>258</a> <span class="comment">// p1 = (x1 - x0) * (y1 - y0)
<a href=#259 id=259 data-nosnippet>259</a> // We do this one last, since it may be negative and acc can't ever be negative:
<a href=#260 id=260 data-nosnippet>260</a> </span><span class="kw">let </span>(j0_sign, j0) = sub_sign(x1, x0);
<a href=#261 id=261 data-nosnippet>261</a> <span class="kw">let </span>(j1_sign, j1) = sub_sign(y1, y0);
<a href=#262 id=262 data-nosnippet>262</a>
<a href=#263 id=263 data-nosnippet>263</a> <span class="kw">match </span>j0_sign * j1_sign {
<a href=#264 id=264 data-nosnippet>264</a> Plus =&gt; {
<a href=#265 id=265 data-nosnippet>265</a> p.data.truncate(<span class="number">0</span>);
<a href=#266 id=266 data-nosnippet>266</a> p.data.resize(len, <span class="number">0</span>);
<a href=#267 id=267 data-nosnippet>267</a>
<a href=#268 id=268 data-nosnippet>268</a> mac3(<span class="kw-2">&amp;mut </span>p.data, <span class="kw-2">&amp;</span>j0.data, <span class="kw-2">&amp;</span>j1.data);
<a href=#269 id=269 data-nosnippet>269</a> p.normalize();
<a href=#270 id=270 data-nosnippet>270</a>
<a href=#271 id=271 data-nosnippet>271</a> sub2(<span class="kw-2">&amp;mut </span>acc[b..], <span class="kw-2">&amp;</span>p.data);
<a href=#272 id=272 data-nosnippet>272</a> }
<a href=#273 id=273 data-nosnippet>273</a> Minus =&gt; {
<a href=#274 id=274 data-nosnippet>274</a> mac3(<span class="kw-2">&amp;mut </span>acc[b..], <span class="kw-2">&amp;</span>j0.data, <span class="kw-2">&amp;</span>j1.data);
<a href=#275 id=275 data-nosnippet>275</a> }
<a href=#276 id=276 data-nosnippet>276</a> NoSign =&gt; (),
<a href=#277 id=277 data-nosnippet>277</a> }
<a href=#278 id=278 data-nosnippet>278</a> } <span class="kw">else </span>{
<a href=#279 id=279 data-nosnippet>279</a> <span class="comment">// Toom-3 multiplication:
<a href=#280 id=280 data-nosnippet>280</a> //
<a href=#281 id=281 data-nosnippet>281</a> // Toom-3 is like Karatsuba above, but dividing the inputs into three parts.
<a href=#282 id=282 data-nosnippet>282</a> // Both are instances of Toom-Cook, using `k=3` and `k=2` respectively.
<a href=#283 id=283 data-nosnippet>283</a> //
<a href=#284 id=284 data-nosnippet>284</a> // The general idea is to treat the large integers digits as
<a href=#285 id=285 data-nosnippet>285</a> // polynomials of a certain degree and determine the coefficients/digits
<a href=#286 id=286 data-nosnippet>286</a> // of the product of the two via interpolation of the polynomial product.
<a href=#287 id=287 data-nosnippet>287</a> </span><span class="kw">let </span>i = y.len() / <span class="number">3 </span>+ <span class="number">1</span>;
<a href=#288 id=288 data-nosnippet>288</a>
<a href=#289 id=289 data-nosnippet>289</a> <span class="kw">let </span>x0_len = Ord::min(x.len(), i);
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">let </span>x1_len = Ord::min(x.len() - x0_len, i);
<a href=#291 id=291 data-nosnippet>291</a>
<a href=#292 id=292 data-nosnippet>292</a> <span class="kw">let </span>y0_len = i;
<a href=#293 id=293 data-nosnippet>293</a> <span class="kw">let </span>y1_len = Ord::min(y.len() - y0_len, i);
<a href=#294 id=294 data-nosnippet>294</a>
<a href=#295 id=295 data-nosnippet>295</a> <span class="comment">// Break x and y into three parts, representating an order two polynomial.
<a href=#296 id=296 data-nosnippet>296</a> // t is chosen to be the size of a digit so we can use faster shifts
<a href=#297 id=297 data-nosnippet>297</a> // in place of multiplications.
<a href=#298 id=298 data-nosnippet>298</a> //
<a href=#299 id=299 data-nosnippet>299</a> // x(t) = x2*t^2 + x1*t + x0
<a href=#300 id=300 data-nosnippet>300</a> </span><span class="kw">let </span>x0 = bigint_from_slice(<span class="kw-2">&amp;</span>x[..x0_len]);
<a href=#301 id=301 data-nosnippet>301</a> <span class="kw">let </span>x1 = bigint_from_slice(<span class="kw-2">&amp;</span>x[x0_len..x0_len + x1_len]);
<a href=#302 id=302 data-nosnippet>302</a> <span class="kw">let </span>x2 = bigint_from_slice(<span class="kw-2">&amp;</span>x[x0_len + x1_len..]);
<a href=#303 id=303 data-nosnippet>303</a>
<a href=#304 id=304 data-nosnippet>304</a> <span class="comment">// y(t) = y2*t^2 + y1*t + y0
<a href=#305 id=305 data-nosnippet>305</a> </span><span class="kw">let </span>y0 = bigint_from_slice(<span class="kw-2">&amp;</span>y[..y0_len]);
<a href=#306 id=306 data-nosnippet>306</a> <span class="kw">let </span>y1 = bigint_from_slice(<span class="kw-2">&amp;</span>y[y0_len..y0_len + y1_len]);
<a href=#307 id=307 data-nosnippet>307</a> <span class="kw">let </span>y2 = bigint_from_slice(<span class="kw-2">&amp;</span>y[y0_len + y1_len..]);
<a href=#308 id=308 data-nosnippet>308</a>
<a href=#309 id=309 data-nosnippet>309</a> <span class="comment">// Let w(t) = x(t) * y(t)
<a href=#310 id=310 data-nosnippet>310</a> //
<a href=#311 id=311 data-nosnippet>311</a> // This gives us the following order-4 polynomial.
<a href=#312 id=312 data-nosnippet>312</a> //
<a href=#313 id=313 data-nosnippet>313</a> // w(t) = w4*t^4 + w3*t^3 + w2*t^2 + w1*t + w0
<a href=#314 id=314 data-nosnippet>314</a> //
<a href=#315 id=315 data-nosnippet>315</a> // We need to find the coefficients w4, w3, w2, w1 and w0. Instead
<a href=#316 id=316 data-nosnippet>316</a> // of simply multiplying the x and y in total, we can evaluate w
<a href=#317 id=317 data-nosnippet>317</a> // at 5 points. An n-degree polynomial is uniquely identified by (n + 1)
<a href=#318 id=318 data-nosnippet>318</a> // points.
<a href=#319 id=319 data-nosnippet>319</a> //
<a href=#320 id=320 data-nosnippet>320</a> // It is arbitrary as to what points we evaluate w at but we use the
<a href=#321 id=321 data-nosnippet>321</a> // following.
<a href=#322 id=322 data-nosnippet>322</a> //
<a href=#323 id=323 data-nosnippet>323</a> // w(t) at t = 0, 1, -1, -2 and inf
<a href=#324 id=324 data-nosnippet>324</a> //
<a href=#325 id=325 data-nosnippet>325</a> // The values for w(t) in terms of x(t)*y(t) at these points are:
<a href=#326 id=326 data-nosnippet>326</a> //
<a href=#327 id=327 data-nosnippet>327</a> // let a = w(0) = x0 * y0
<a href=#328 id=328 data-nosnippet>328</a> // let b = w(1) = (x2 + x1 + x0) * (y2 + y1 + y0)
<a href=#329 id=329 data-nosnippet>329</a> // let c = w(-1) = (x2 - x1 + x0) * (y2 - y1 + y0)
<a href=#330 id=330 data-nosnippet>330</a> // let d = w(-2) = (4*x2 - 2*x1 + x0) * (4*y2 - 2*y1 + y0)
<a href=#331 id=331 data-nosnippet>331</a> // let e = w(inf) = x2 * y2 as t -&gt; inf
<a href=#332 id=332 data-nosnippet>332</a>
<a href=#333 id=333 data-nosnippet>333</a> // x0 + x2, avoiding temporaries
<a href=#334 id=334 data-nosnippet>334</a> </span><span class="kw">let </span>p = <span class="kw-2">&amp;</span>x0 + <span class="kw-2">&amp;</span>x2;
<a href=#335 id=335 data-nosnippet>335</a>
<a href=#336 id=336 data-nosnippet>336</a> <span class="comment">// y0 + y2, avoiding temporaries
<a href=#337 id=337 data-nosnippet>337</a> </span><span class="kw">let </span>q = <span class="kw-2">&amp;</span>y0 + <span class="kw-2">&amp;</span>y2;
<a href=#338 id=338 data-nosnippet>338</a>
<a href=#339 id=339 data-nosnippet>339</a> <span class="comment">// x2 - x1 + x0, avoiding temporaries
<a href=#340 id=340 data-nosnippet>340</a> </span><span class="kw">let </span>p2 = <span class="kw-2">&amp;</span>p - <span class="kw-2">&amp;</span>x1;
<a href=#341 id=341 data-nosnippet>341</a>
<a href=#342 id=342 data-nosnippet>342</a> <span class="comment">// y2 - y1 + y0, avoiding temporaries
<a href=#343 id=343 data-nosnippet>343</a> </span><span class="kw">let </span>q2 = <span class="kw-2">&amp;</span>q - <span class="kw-2">&amp;</span>y1;
<a href=#344 id=344 data-nosnippet>344</a>
<a href=#345 id=345 data-nosnippet>345</a> <span class="comment">// w(0)
<a href=#346 id=346 data-nosnippet>346</a> </span><span class="kw">let </span>r0 = <span class="kw-2">&amp;</span>x0 * <span class="kw-2">&amp;</span>y0;
<a href=#347 id=347 data-nosnippet>347</a>
<a href=#348 id=348 data-nosnippet>348</a> <span class="comment">// w(inf)
<a href=#349 id=349 data-nosnippet>349</a> </span><span class="kw">let </span>r4 = <span class="kw-2">&amp;</span>x2 * <span class="kw-2">&amp;</span>y2;
<a href=#350 id=350 data-nosnippet>350</a>
<a href=#351 id=351 data-nosnippet>351</a> <span class="comment">// w(1)
<a href=#352 id=352 data-nosnippet>352</a> </span><span class="kw">let </span>r1 = (p + x1) * (q + y1);
<a href=#353 id=353 data-nosnippet>353</a>
<a href=#354 id=354 data-nosnippet>354</a> <span class="comment">// w(-1)
<a href=#355 id=355 data-nosnippet>355</a> </span><span class="kw">let </span>r2 = <span class="kw-2">&amp;</span>p2 * <span class="kw-2">&amp;</span>q2;
<a href=#356 id=356 data-nosnippet>356</a>
<a href=#357 id=357 data-nosnippet>357</a> <span class="comment">// w(-2)
<a href=#358 id=358 data-nosnippet>358</a> </span><span class="kw">let </span>r3 = ((p2 + x2) * <span class="number">2 </span>- x0) * ((q2 + y2) * <span class="number">2 </span>- y0);
<a href=#359 id=359 data-nosnippet>359</a>
<a href=#360 id=360 data-nosnippet>360</a> <span class="comment">// Evaluating these points gives us the following system of linear equations.
<a href=#361 id=361 data-nosnippet>361</a> //
<a href=#362 id=362 data-nosnippet>362</a> // 0 0 0 0 1 | a
<a href=#363 id=363 data-nosnippet>363</a> // 1 1 1 1 1 | b
<a href=#364 id=364 data-nosnippet>364</a> // 1 -1 1 -1 1 | c
<a href=#365 id=365 data-nosnippet>365</a> // 16 -8 4 -2 1 | d
<a href=#366 id=366 data-nosnippet>366</a> // 1 0 0 0 0 | e
<a href=#367 id=367 data-nosnippet>367</a> //
<a href=#368 id=368 data-nosnippet>368</a> // The solved equation (after gaussian elimination or similar)
<a href=#369 id=369 data-nosnippet>369</a> // in terms of its coefficients:
<a href=#370 id=370 data-nosnippet>370</a> //
<a href=#371 id=371 data-nosnippet>371</a> // w0 = w(0)
<a href=#372 id=372 data-nosnippet>372</a> // w1 = w(0)/2 + w(1)/3 - w(-1) + w(-2)/6 - 2*w(inf)
<a href=#373 id=373 data-nosnippet>373</a> // w2 = -w(0) + w(1)/2 + w(-1)/2 - w(inf)
<a href=#374 id=374 data-nosnippet>374</a> // w3 = -w(0)/2 + w(1)/6 + w(-1)/2 - w(-2)/6 + 2*w(inf)
<a href=#375 id=375 data-nosnippet>375</a> // w4 = w(inf)
<a href=#376 id=376 data-nosnippet>376</a> //
<a href=#377 id=377 data-nosnippet>377</a> // This particular sequence is given by Bodrato and is an interpolation
<a href=#378 id=378 data-nosnippet>378</a> // of the above equations.
<a href=#379 id=379 data-nosnippet>379</a> </span><span class="kw">let </span><span class="kw-2">mut </span>comp3: BigInt = (r3 - <span class="kw-2">&amp;</span>r1) / <span class="number">3u32</span>;
<a href=#380 id=380 data-nosnippet>380</a> <span class="kw">let </span><span class="kw-2">mut </span>comp1: BigInt = (r1 - <span class="kw-2">&amp;</span>r2) &gt;&gt; <span class="number">1</span>;
<a href=#381 id=381 data-nosnippet>381</a> <span class="kw">let </span><span class="kw-2">mut </span>comp2: BigInt = r2 - <span class="kw-2">&amp;</span>r0;
<a href=#382 id=382 data-nosnippet>382</a> comp3 = ((<span class="kw-2">&amp;</span>comp2 - comp3) &gt;&gt; <span class="number">1</span>) + (<span class="kw-2">&amp;</span>r4 &lt;&lt; <span class="number">1</span>);
<a href=#383 id=383 data-nosnippet>383</a> comp2 += <span class="kw-2">&amp;</span>comp1 - <span class="kw-2">&amp;</span>r4;
<a href=#384 id=384 data-nosnippet>384</a> comp1 -= <span class="kw-2">&amp;</span>comp3;
<a href=#385 id=385 data-nosnippet>385</a>
<a href=#386 id=386 data-nosnippet>386</a> <span class="comment">// Recomposition. The coefficients of the polynomial are now known.
<a href=#387 id=387 data-nosnippet>387</a> //
<a href=#388 id=388 data-nosnippet>388</a> // Evaluate at w(t) where t is our given base to get the result.
<a href=#389 id=389 data-nosnippet>389</a> //
<a href=#390 id=390 data-nosnippet>390</a> // let bits = u64::from(big_digit::BITS) * i as u64;
<a href=#391 id=391 data-nosnippet>391</a> // let result = r0
<a href=#392 id=392 data-nosnippet>392</a> // + (comp1 &lt;&lt; bits)
<a href=#393 id=393 data-nosnippet>393</a> // + (comp2 &lt;&lt; (2 * bits))
<a href=#394 id=394 data-nosnippet>394</a> // + (comp3 &lt;&lt; (3 * bits))
<a href=#395 id=395 data-nosnippet>395</a> // + (r4 &lt;&lt; (4 * bits));
<a href=#396 id=396 data-nosnippet>396</a> // let result_pos = result.to_biguint().unwrap();
<a href=#397 id=397 data-nosnippet>397</a> // add2(&amp;mut acc[..], &amp;result_pos.data);
<a href=#398 id=398 data-nosnippet>398</a> //
<a href=#399 id=399 data-nosnippet>399</a> // But with less intermediate copying:
<a href=#400 id=400 data-nosnippet>400</a> </span><span class="kw">for </span>(j, result) <span class="kw">in </span>[<span class="kw-2">&amp;</span>r0, <span class="kw-2">&amp;</span>comp1, <span class="kw-2">&amp;</span>comp2, <span class="kw-2">&amp;</span>comp3, <span class="kw-2">&amp;</span>r4].iter().enumerate().rev() {
<a href=#401 id=401 data-nosnippet>401</a> <span class="kw">match </span>result.sign() {
<a href=#402 id=402 data-nosnippet>402</a> Plus =&gt; add2(<span class="kw-2">&amp;mut </span>acc[i * j..], result.digits()),
<a href=#403 id=403 data-nosnippet>403</a> Minus =&gt; sub2(<span class="kw-2">&amp;mut </span>acc[i * j..], result.digits()),
<a href=#404 id=404 data-nosnippet>404</a> NoSign =&gt; {}
<a href=#405 id=405 data-nosnippet>405</a> }
<a href=#406 id=406 data-nosnippet>406</a> }
<a href=#407 id=407 data-nosnippet>407</a> }
<a href=#408 id=408 data-nosnippet>408</a>}
<a href=#409 id=409 data-nosnippet>409</a>
<a href=#410 id=410 data-nosnippet>410</a><span class="kw">fn </span>mul3(x: <span class="kw-2">&amp;</span>[BigDigit], y: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; BigUint {
<a href=#411 id=411 data-nosnippet>411</a> <span class="kw">let </span>len = x.len() + y.len() + <span class="number">1</span>;
<a href=#412 id=412 data-nosnippet>412</a> <span class="kw">let </span><span class="kw-2">mut </span>prod = BigUint { data: <span class="macro">vec!</span>[<span class="number">0</span>; len] };
<a href=#413 id=413 data-nosnippet>413</a>
<a href=#414 id=414 data-nosnippet>414</a> mac3(<span class="kw-2">&amp;mut </span>prod.data, x, y);
<a href=#415 id=415 data-nosnippet>415</a> prod.normalized()
<a href=#416 id=416 data-nosnippet>416</a>}
<a href=#417 id=417 data-nosnippet>417</a>
<a href=#418 id=418 data-nosnippet>418</a><span class="kw">fn </span>scalar_mul(a: <span class="kw-2">&amp;mut </span>BigUint, b: BigDigit) {
<a href=#419 id=419 data-nosnippet>419</a> <span class="kw">match </span>b {
<a href=#420 id=420 data-nosnippet>420</a> <span class="number">0 </span>=&gt; a.set_zero(),
<a href=#421 id=421 data-nosnippet>421</a> <span class="number">1 </span>=&gt; {}
<a href=#422 id=422 data-nosnippet>422</a> <span class="kw">_ </span>=&gt; {
<a href=#423 id=423 data-nosnippet>423</a> <span class="kw">if </span>b.is_power_of_two() {
<a href=#424 id=424 data-nosnippet>424</a> <span class="kw-2">*</span>a &lt;&lt;= b.trailing_zeros();
<a href=#425 id=425 data-nosnippet>425</a> } <span class="kw">else </span>{
<a href=#426 id=426 data-nosnippet>426</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="number">0</span>;
<a href=#427 id=427 data-nosnippet>427</a> <span class="kw">for </span>a <span class="kw">in </span>a.data.iter_mut() {
<a href=#428 id=428 data-nosnippet>428</a> <span class="kw-2">*</span>a = mul_with_carry(<span class="kw-2">*</span>a, b, <span class="kw-2">&amp;mut </span>carry);
<a href=#429 id=429 data-nosnippet>429</a> }
<a href=#430 id=430 data-nosnippet>430</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#431 id=431 data-nosnippet>431</a> a.data.push(carry <span class="kw">as </span>BigDigit);
<a href=#432 id=432 data-nosnippet>432</a> }
<a href=#433 id=433 data-nosnippet>433</a> }
<a href=#434 id=434 data-nosnippet>434</a> }
<a href=#435 id=435 data-nosnippet>435</a> }
<a href=#436 id=436 data-nosnippet>436</a>}
<a href=#437 id=437 data-nosnippet>437</a>
<a href=#438 id=438 data-nosnippet>438</a><span class="kw">fn </span>sub_sign(<span class="kw-2">mut </span>a: <span class="kw-2">&amp;</span>[BigDigit], <span class="kw-2">mut </span>b: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; (Sign, BigUint) {
<a href=#439 id=439 data-nosnippet>439</a> <span class="comment">// Normalize:
<a href=#440 id=440 data-nosnippet>440</a> </span><span class="kw">if let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) = a.last() {
<a href=#441 id=441 data-nosnippet>441</a> a = <span class="kw-2">&amp;</span>a[..a.iter().rposition(|<span class="kw-2">&amp;</span>x| <span class="macro">x !</span>= <span class="number">0</span>).map_or(<span class="number">0</span>, |i| i + <span class="number">1</span>)];
<a href=#442 id=442 data-nosnippet>442</a> }
<a href=#443 id=443 data-nosnippet>443</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">0</span>) = b.last() {
<a href=#444 id=444 data-nosnippet>444</a> b = <span class="kw-2">&amp;</span>b[..b.iter().rposition(|<span class="kw-2">&amp;</span>x| <span class="macro">x !</span>= <span class="number">0</span>).map_or(<span class="number">0</span>, |i| i + <span class="number">1</span>)];
<a href=#445 id=445 data-nosnippet>445</a> }
<a href=#446 id=446 data-nosnippet>446</a>
<a href=#447 id=447 data-nosnippet>447</a> <span class="kw">match </span>cmp_slice(a, b) {
<a href=#448 id=448 data-nosnippet>448</a> Ordering::Greater =&gt; {
<a href=#449 id=449 data-nosnippet>449</a> <span class="kw">let </span><span class="kw-2">mut </span>a = a.to_vec();
<a href=#450 id=450 data-nosnippet>450</a> sub2(<span class="kw-2">&amp;mut </span>a, b);
<a href=#451 id=451 data-nosnippet>451</a> (Plus, biguint_from_vec(a))
<a href=#452 id=452 data-nosnippet>452</a> }
<a href=#453 id=453 data-nosnippet>453</a> Ordering::Less =&gt; {
<a href=#454 id=454 data-nosnippet>454</a> <span class="kw">let </span><span class="kw-2">mut </span>b = b.to_vec();
<a href=#455 id=455 data-nosnippet>455</a> sub2(<span class="kw-2">&amp;mut </span>b, a);
<a href=#456 id=456 data-nosnippet>456</a> (Minus, biguint_from_vec(b))
<a href=#457 id=457 data-nosnippet>457</a> }
<a href=#458 id=458 data-nosnippet>458</a> Ordering::Equal =&gt; (NoSign, BigUint::ZERO),
<a href=#459 id=459 data-nosnippet>459</a> }
<a href=#460 id=460 data-nosnippet>460</a>}
<a href=#461 id=461 data-nosnippet>461</a>
<a href=#462 id=462 data-nosnippet>462</a><span class="macro">macro_rules!</span> impl_mul {
<a href=#463 id=463 data-nosnippet>463</a> ($(<span class="kw">impl </span>Mul&lt;<span class="macro-nonterminal">$Other</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$Self</span>:ty;)<span class="kw-2">*</span>) =&gt; {$(
<a href=#464 id=464 data-nosnippet>464</a> <span class="kw">impl </span>Mul&lt;<span class="macro-nonterminal">$Other</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$Self </span>{
<a href=#465 id=465 data-nosnippet>465</a> <span class="kw">type </span>Output = BigUint;
<a href=#466 id=466 data-nosnippet>466</a>
<a href=#467 id=467 data-nosnippet>467</a> <span class="attr">#[inline]
<a href=#468 id=468 data-nosnippet>468</a> </span><span class="kw">fn </span>mul(<span class="self">self</span>, other: <span class="macro-nonterminal">$Other</span>) -&gt; BigUint {
<a href=#469 id=469 data-nosnippet>469</a> <span class="kw">match </span>(<span class="kw-2">&amp;*</span><span class="self">self</span>.data, <span class="kw-2">&amp;*</span>other.data) {
<a href=#470 id=470 data-nosnippet>470</a> <span class="comment">// multiply by zero
<a href=#471 id=471 data-nosnippet>471</a> </span>(<span class="kw-2">&amp;</span>[], <span class="kw">_</span>) | (<span class="kw">_</span>, <span class="kw-2">&amp;</span>[]) =&gt; BigUint::ZERO,
<a href=#472 id=472 data-nosnippet>472</a> <span class="comment">// multiply by a scalar
<a href=#473 id=473 data-nosnippet>473</a> </span>(<span class="kw">_</span>, <span class="kw-2">&amp;</span>[digit]) =&gt; <span class="self">self </span>* digit,
<a href=#474 id=474 data-nosnippet>474</a> (<span class="kw-2">&amp;</span>[digit], <span class="kw">_</span>) =&gt; other * digit,
<a href=#475 id=475 data-nosnippet>475</a> <span class="comment">// full multiplication
<a href=#476 id=476 data-nosnippet>476</a> </span>(x, y) =&gt; mul3(x, y),
<a href=#477 id=477 data-nosnippet>477</a> }
<a href=#478 id=478 data-nosnippet>478</a> }
<a href=#479 id=479 data-nosnippet>479</a> }
<a href=#480 id=480 data-nosnippet>480</a> )<span class="kw-2">*</span>}
<a href=#481 id=481 data-nosnippet>481</a>}
<a href=#482 id=482 data-nosnippet>482</a><span class="macro">impl_mul!</span> {
<a href=#483 id=483 data-nosnippet>483</a> <span class="kw">impl </span>Mul&lt;BigUint&gt; <span class="kw">for </span>BigUint;
<a href=#484 id=484 data-nosnippet>484</a> <span class="kw">impl </span>Mul&lt;BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint;
<a href=#485 id=485 data-nosnippet>485</a> <span class="kw">impl </span>Mul&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint;
<a href=#486 id=486 data-nosnippet>486</a> <span class="kw">impl </span>Mul&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint;
<a href=#487 id=487 data-nosnippet>487</a>}
<a href=#488 id=488 data-nosnippet>488</a>
<a href=#489 id=489 data-nosnippet>489</a><span class="macro">macro_rules!</span> impl_mul_assign {
<a href=#490 id=490 data-nosnippet>490</a> ($(<span class="kw">impl </span>MulAssign&lt;<span class="macro-nonterminal">$Other</span>:ty&gt; <span class="kw">for </span>BigUint;)<span class="kw-2">*</span>) =&gt; {$(
<a href=#491 id=491 data-nosnippet>491</a> <span class="kw">impl </span>MulAssign&lt;<span class="macro-nonterminal">$Other</span>&gt; <span class="kw">for </span>BigUint {
<a href=#492 id=492 data-nosnippet>492</a> <span class="attr">#[inline]
<a href=#493 id=493 data-nosnippet>493</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="macro-nonterminal">$Other</span>) {
<a href=#494 id=494 data-nosnippet>494</a> <span class="kw">match </span>(<span class="kw-2">&amp;*</span><span class="self">self</span>.data, <span class="kw-2">&amp;*</span>other.data) {
<a href=#495 id=495 data-nosnippet>495</a> <span class="comment">// multiply by zero
<a href=#496 id=496 data-nosnippet>496</a> </span>(<span class="kw-2">&amp;</span>[], <span class="kw">_</span>) =&gt; {},
<a href=#497 id=497 data-nosnippet>497</a> (<span class="kw">_</span>, <span class="kw-2">&amp;</span>[]) =&gt; <span class="self">self</span>.set_zero(),
<a href=#498 id=498 data-nosnippet>498</a> <span class="comment">// multiply by a scalar
<a href=#499 id=499 data-nosnippet>499</a> </span>(<span class="kw">_</span>, <span class="kw-2">&amp;</span>[digit]) =&gt; <span class="kw-2">*</span><span class="self">self </span><span class="kw-2">*</span>= digit,
<a href=#500 id=500 data-nosnippet>500</a> (<span class="kw-2">&amp;</span>[digit], <span class="kw">_</span>) =&gt; <span class="kw-2">*</span><span class="self">self </span>= other * digit,
<a href=#501 id=501 data-nosnippet>501</a> <span class="comment">// full multiplication
<a href=#502 id=502 data-nosnippet>502</a> </span>(x, y) =&gt; <span class="kw-2">*</span><span class="self">self </span>= mul3(x, y),
<a href=#503 id=503 data-nosnippet>503</a> }
<a href=#504 id=504 data-nosnippet>504</a> }
<a href=#505 id=505 data-nosnippet>505</a> }
<a href=#506 id=506 data-nosnippet>506</a> )<span class="kw-2">*</span>}
<a href=#507 id=507 data-nosnippet>507</a>}
<a href=#508 id=508 data-nosnippet>508</a><span class="macro">impl_mul_assign!</span> {
<a href=#509 id=509 data-nosnippet>509</a> <span class="kw">impl </span>MulAssign&lt;BigUint&gt; <span class="kw">for </span>BigUint;
<a href=#510 id=510 data-nosnippet>510</a> <span class="kw">impl </span>MulAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint;
<a href=#511 id=511 data-nosnippet>511</a>}
<a href=#512 id=512 data-nosnippet>512</a>
<a href=#513 id=513 data-nosnippet>513</a><span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span>Mul <span class="kw">for </span>BigUint, mul);
<a href=#514 id=514 data-nosnippet>514</a><span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span>MulAssign <span class="kw">for </span>BigUint, mul_assign);
<a href=#515 id=515 data-nosnippet>515</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u32&gt; <span class="kw">for </span>BigUint, mul);
<a href=#516 id=516 data-nosnippet>516</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u64&gt; <span class="kw">for </span>BigUint, mul);
<a href=#517 id=517 data-nosnippet>517</a><span class="macro">forward_all_scalar_binop_to_val_val_commutative!</span>(<span class="kw">impl </span>Mul&lt;u128&gt; <span class="kw">for </span>BigUint, mul);
<a href=#518 id=518 data-nosnippet>518</a>
<a href=#519 id=519 data-nosnippet>519</a><span class="kw">impl </span>Mul&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#520 id=520 data-nosnippet>520</a> <span class="kw">type </span>Output = BigUint;
<a href=#521 id=521 data-nosnippet>521</a>
<a href=#522 id=522 data-nosnippet>522</a> <span class="attr">#[inline]
<a href=#523 id=523 data-nosnippet>523</a> </span><span class="kw">fn </span>mul(<span class="kw-2">mut </span><span class="self">self</span>, other: u32) -&gt; BigUint {
<a href=#524 id=524 data-nosnippet>524</a> <span class="self">self </span><span class="kw-2">*</span>= other;
<a href=#525 id=525 data-nosnippet>525</a> <span class="self">self
<a href=#526 id=526 data-nosnippet>526</a> </span>}
<a href=#527 id=527 data-nosnippet>527</a>}
<a href=#528 id=528 data-nosnippet>528</a><span class="kw">impl </span>MulAssign&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#529 id=529 data-nosnippet>529</a> <span class="attr">#[inline]
<a href=#530 id=530 data-nosnippet>530</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#531 id=531 data-nosnippet>531</a> scalar_mul(<span class="self">self</span>, other <span class="kw">as </span>BigDigit);
<a href=#532 id=532 data-nosnippet>532</a> }
<a href=#533 id=533 data-nosnippet>533</a>}
<a href=#534 id=534 data-nosnippet>534</a>
<a href=#535 id=535 data-nosnippet>535</a><span class="kw">impl </span>Mul&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#536 id=536 data-nosnippet>536</a> <span class="kw">type </span>Output = BigUint;
<a href=#537 id=537 data-nosnippet>537</a>
<a href=#538 id=538 data-nosnippet>538</a> <span class="attr">#[inline]
<a href=#539 id=539 data-nosnippet>539</a> </span><span class="kw">fn </span>mul(<span class="kw-2">mut </span><span class="self">self</span>, other: u64) -&gt; BigUint {
<a href=#540 id=540 data-nosnippet>540</a> <span class="self">self </span><span class="kw-2">*</span>= other;
<a href=#541 id=541 data-nosnippet>541</a> <span class="self">self
<a href=#542 id=542 data-nosnippet>542</a> </span>}
<a href=#543 id=543 data-nosnippet>543</a>}
<a href=#544 id=544 data-nosnippet>544</a><span class="kw">impl </span>MulAssign&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#545 id=545 data-nosnippet>545</a> <span class="macro">cfg_digit!</span>(
<a href=#546 id=546 data-nosnippet>546</a> <span class="attr">#[inline]
<a href=#547 id=547 data-nosnippet>547</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#548 id=548 data-nosnippet>548</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = BigDigit::from_u64(other) {
<a href=#549 id=549 data-nosnippet>549</a> scalar_mul(<span class="self">self</span>, other);
<a href=#550 id=550 data-nosnippet>550</a> } <span class="kw">else </span>{
<a href=#551 id=551 data-nosnippet>551</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#552 id=552 data-nosnippet>552</a> <span class="kw-2">*</span><span class="self">self </span>= mul3(<span class="kw-2">&amp;</span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#553 id=553 data-nosnippet>553</a> }
<a href=#554 id=554 data-nosnippet>554</a> }
<a href=#555 id=555 data-nosnippet>555</a>
<a href=#556 id=556 data-nosnippet>556</a> <span class="attr">#[inline]
<a href=#557 id=557 data-nosnippet>557</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#558 id=558 data-nosnippet>558</a> scalar_mul(<span class="self">self</span>, other);
<a href=#559 id=559 data-nosnippet>559</a> }
<a href=#560 id=560 data-nosnippet>560</a> );
<a href=#561 id=561 data-nosnippet>561</a>}
<a href=#562 id=562 data-nosnippet>562</a>
<a href=#563 id=563 data-nosnippet>563</a><span class="kw">impl </span>Mul&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#564 id=564 data-nosnippet>564</a> <span class="kw">type </span>Output = BigUint;
<a href=#565 id=565 data-nosnippet>565</a>
<a href=#566 id=566 data-nosnippet>566</a> <span class="attr">#[inline]
<a href=#567 id=567 data-nosnippet>567</a> </span><span class="kw">fn </span>mul(<span class="kw-2">mut </span><span class="self">self</span>, other: u128) -&gt; BigUint {
<a href=#568 id=568 data-nosnippet>568</a> <span class="self">self </span><span class="kw-2">*</span>= other;
<a href=#569 id=569 data-nosnippet>569</a> <span class="self">self
<a href=#570 id=570 data-nosnippet>570</a> </span>}
<a href=#571 id=571 data-nosnippet>571</a>}
<a href=#572 id=572 data-nosnippet>572</a>
<a href=#573 id=573 data-nosnippet>573</a><span class="kw">impl </span>MulAssign&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#574 id=574 data-nosnippet>574</a> <span class="macro">cfg_digit!</span>(
<a href=#575 id=575 data-nosnippet>575</a> <span class="attr">#[inline]
<a href=#576 id=576 data-nosnippet>576</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#577 id=577 data-nosnippet>577</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = BigDigit::from_u128(other) {
<a href=#578 id=578 data-nosnippet>578</a> scalar_mul(<span class="self">self</span>, other);
<a href=#579 id=579 data-nosnippet>579</a> } <span class="kw">else </span>{
<a href=#580 id=580 data-nosnippet>580</a> <span class="kw-2">*</span><span class="self">self </span>= <span class="kw">match </span><span class="kw">super</span>::u32_from_u128(other) {
<a href=#581 id=581 data-nosnippet>581</a> (<span class="number">0</span>, <span class="number">0</span>, c, d) =&gt; mul3(<span class="kw-2">&amp;</span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[d, c]),
<a href=#582 id=582 data-nosnippet>582</a> (<span class="number">0</span>, b, c, d) =&gt; mul3(<span class="kw-2">&amp;</span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[d, c, b]),
<a href=#583 id=583 data-nosnippet>583</a> (a, b, c, d) =&gt; mul3(<span class="kw-2">&amp;</span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[d, c, b, a]),
<a href=#584 id=584 data-nosnippet>584</a> };
<a href=#585 id=585 data-nosnippet>585</a> }
<a href=#586 id=586 data-nosnippet>586</a> }
<a href=#587 id=587 data-nosnippet>587</a>
<a href=#588 id=588 data-nosnippet>588</a> <span class="attr">#[inline]
<a href=#589 id=589 data-nosnippet>589</a> </span><span class="kw">fn </span>mul_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#590 id=590 data-nosnippet>590</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(other) = BigDigit::from_u128(other) {
<a href=#591 id=591 data-nosnippet>591</a> scalar_mul(<span class="self">self</span>, other);
<a href=#592 id=592 data-nosnippet>592</a> } <span class="kw">else </span>{
<a href=#593 id=593 data-nosnippet>593</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#594 id=594 data-nosnippet>594</a> <span class="kw-2">*</span><span class="self">self </span>= mul3(<span class="kw-2">&amp;</span><span class="self">self</span>.data, <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#595 id=595 data-nosnippet>595</a> }
<a href=#596 id=596 data-nosnippet>596</a> }
<a href=#597 id=597 data-nosnippet>597</a> );
<a href=#598 id=598 data-nosnippet>598</a>}
<a href=#599 id=599 data-nosnippet>599</a>
<a href=#600 id=600 data-nosnippet>600</a><span class="kw">impl </span>CheckedMul <span class="kw">for </span>BigUint {
<a href=#601 id=601 data-nosnippet>601</a> <span class="attr">#[inline]
<a href=#602 id=602 data-nosnippet>602</a> </span><span class="kw">fn </span>checked_mul(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#603 id=603 data-nosnippet>603</a> <span class="prelude-val">Some</span>(<span class="self">self</span>.mul(v))
<a href=#604 id=604 data-nosnippet>604</a> }
<a href=#605 id=605 data-nosnippet>605</a>}
<a href=#606 id=606 data-nosnippet>606</a>
<a href=#607 id=607 data-nosnippet>607</a><span class="macro">impl_product_iter_type!</span>(BigUint);
<a href=#608 id=608 data-nosnippet>608</a>
<a href=#609 id=609 data-nosnippet>609</a><span class="attr">#[test]
<a href=#610 id=610 data-nosnippet>610</a></span><span class="kw">fn </span>test_sub_sign() {
<a href=#611 id=611 data-nosnippet>611</a> <span class="kw">use </span><span class="kw">crate</span>::BigInt;
<a href=#612 id=612 data-nosnippet>612</a> <span class="kw">use </span>num_traits::Num;
<a href=#613 id=613 data-nosnippet>613</a>
<a href=#614 id=614 data-nosnippet>614</a> <span class="kw">fn </span>sub_sign_i(a: <span class="kw-2">&amp;</span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) -&gt; BigInt {
<a href=#615 id=615 data-nosnippet>615</a> <span class="kw">let </span>(sign, val) = sub_sign(a, b);
<a href=#616 id=616 data-nosnippet>616</a> BigInt::from_biguint(sign, val)
<a href=#617 id=617 data-nosnippet>617</a> }
<a href=#618 id=618 data-nosnippet>618</a>
<a href=#619 id=619 data-nosnippet>619</a> <span class="kw">let </span>a = BigUint::from_str_radix(<span class="string">"265252859812191058636308480000000"</span>, <span class="number">10</span>).unwrap();
<a href=#620 id=620 data-nosnippet>620</a> <span class="kw">let </span>b = BigUint::from_str_radix(<span class="string">"26525285981219105863630848000000"</span>, <span class="number">10</span>).unwrap();
<a href=#621 id=621 data-nosnippet>621</a> <span class="kw">let </span>a_i = BigInt::from(a.clone());
<a href=#622 id=622 data-nosnippet>622</a> <span class="kw">let </span>b_i = BigInt::from(b.clone());
<a href=#623 id=623 data-nosnippet>623</a>
<a href=#624 id=624 data-nosnippet>624</a> <span class="macro">assert_eq!</span>(sub_sign_i(<span class="kw-2">&amp;</span>a.data, <span class="kw-2">&amp;</span>b.data), <span class="kw-2">&amp;</span>a_i - <span class="kw-2">&amp;</span>b_i);
<a href=#625 id=625 data-nosnippet>625</a> <span class="macro">assert_eq!</span>(sub_sign_i(<span class="kw-2">&amp;</span>b.data, <span class="kw-2">&amp;</span>a.data), <span class="kw-2">&amp;</span>b_i - <span class="kw-2">&amp;</span>a_i);
<a href=#626 id=626 data-nosnippet>626</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,259 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/power.rs`."><title>power.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>power.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::monty::monty_modpow;
<a href=#2 id=2 data-nosnippet>2</a><span class="kw">use </span><span class="kw">super</span>::BigUint;
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit};
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>num_integer::Integer;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>num_traits::{One, Pow, ToPrimitive, Zero};
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#10 id=10 data-nosnippet>10</a> <span class="kw">type </span>Output = BigUint;
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a> <span class="attr">#[inline]
<a href=#13 id=13 data-nosnippet>13</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#14 id=14 data-nosnippet>14</a> <span class="kw">if </span><span class="self">self</span>.is_one() || exp.is_zero() {
<a href=#15 id=15 data-nosnippet>15</a> BigUint::one()
<a href=#16 id=16 data-nosnippet>16</a> } <span class="kw">else if </span><span class="self">self</span>.is_zero() {
<a href=#17 id=17 data-nosnippet>17</a> <span class="self">Self</span>::ZERO
<a href=#18 id=18 data-nosnippet>18</a> } <span class="kw">else if let </span><span class="prelude-val">Some</span>(exp) = exp.to_u64() {
<a href=#19 id=19 data-nosnippet>19</a> <span class="self">self</span>.pow(exp)
<a href=#20 id=20 data-nosnippet>20</a> } <span class="kw">else if let </span><span class="prelude-val">Some</span>(exp) = exp.to_u128() {
<a href=#21 id=21 data-nosnippet>21</a> <span class="self">self</span>.pow(exp)
<a href=#22 id=22 data-nosnippet>22</a> } <span class="kw">else </span>{
<a href=#23 id=23 data-nosnippet>23</a> <span class="comment">// At this point, `self &gt;= 2` and `exp &gt;= 2¹²⁸`. The smallest possible result given
<a href=#24 id=24 data-nosnippet>24</a> // `2.pow(2¹²⁸)` would require far more memory than 64-bit targets can address!
<a href=#25 id=25 data-nosnippet>25</a> </span><span class="macro">panic!</span>(<span class="string">"memory overflow"</span>)
<a href=#26 id=26 data-nosnippet>26</a> }
<a href=#27 id=27 data-nosnippet>27</a> }
<a href=#28 id=28 data-nosnippet>28</a>}
<a href=#29 id=29 data-nosnippet>29</a>
<a href=#30 id=30 data-nosnippet>30</a><span class="kw">impl </span>Pow&lt;BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#31 id=31 data-nosnippet>31</a> <span class="kw">type </span>Output = BigUint;
<a href=#32 id=32 data-nosnippet>32</a>
<a href=#33 id=33 data-nosnippet>33</a> <span class="attr">#[inline]
<a href=#34 id=34 data-nosnippet>34</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: BigUint) -&gt; BigUint {
<a href=#35 id=35 data-nosnippet>35</a> Pow::pow(<span class="self">self</span>, <span class="kw-2">&amp;</span>exp)
<a href=#36 id=36 data-nosnippet>36</a> }
<a href=#37 id=37 data-nosnippet>37</a>}
<a href=#38 id=38 data-nosnippet>38</a>
<a href=#39 id=39 data-nosnippet>39</a><span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">type </span>Output = BigUint;
<a href=#41 id=41 data-nosnippet>41</a>
<a href=#42 id=42 data-nosnippet>42</a> <span class="attr">#[inline]
<a href=#43 id=43 data-nosnippet>43</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw">if </span><span class="self">self</span>.is_one() || exp.is_zero() {
<a href=#45 id=45 data-nosnippet>45</a> BigUint::one()
<a href=#46 id=46 data-nosnippet>46</a> } <span class="kw">else if </span><span class="self">self</span>.is_zero() {
<a href=#47 id=47 data-nosnippet>47</a> BigUint::ZERO
<a href=#48 id=48 data-nosnippet>48</a> } <span class="kw">else </span>{
<a href=#49 id=49 data-nosnippet>49</a> <span class="self">self</span>.clone().pow(exp)
<a href=#50 id=50 data-nosnippet>50</a> }
<a href=#51 id=51 data-nosnippet>51</a> }
<a href=#52 id=52 data-nosnippet>52</a>}
<a href=#53 id=53 data-nosnippet>53</a>
<a href=#54 id=54 data-nosnippet>54</a><span class="kw">impl </span>Pow&lt;BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#55 id=55 data-nosnippet>55</a> <span class="kw">type </span>Output = BigUint;
<a href=#56 id=56 data-nosnippet>56</a>
<a href=#57 id=57 data-nosnippet>57</a> <span class="attr">#[inline]
<a href=#58 id=58 data-nosnippet>58</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: BigUint) -&gt; BigUint {
<a href=#59 id=59 data-nosnippet>59</a> Pow::pow(<span class="self">self</span>, <span class="kw-2">&amp;</span>exp)
<a href=#60 id=60 data-nosnippet>60</a> }
<a href=#61 id=61 data-nosnippet>61</a>}
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a><span class="macro">macro_rules!</span> pow_impl {
<a href=#64 id=64 data-nosnippet>64</a> (<span class="macro-nonterminal">$T</span>:ty) =&gt; {
<a href=#65 id=65 data-nosnippet>65</a> <span class="kw">impl </span>Pow&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigUint {
<a href=#66 id=66 data-nosnippet>66</a> <span class="kw">type </span>Output = BigUint;
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">fn </span>pow(<span class="self">self</span>, <span class="kw-2">mut </span>exp: <span class="macro-nonterminal">$T</span>) -&gt; BigUint {
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">if </span>exp == <span class="number">0 </span>{
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">return </span>BigUint::one();
<a href=#71 id=71 data-nosnippet>71</a> }
<a href=#72 id=72 data-nosnippet>72</a> <span class="kw">let </span><span class="kw-2">mut </span>base = <span class="self">self</span>;
<a href=#73 id=73 data-nosnippet>73</a>
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">while </span>exp &amp; <span class="number">1 </span>== <span class="number">0 </span>{
<a href=#75 id=75 data-nosnippet>75</a> base = <span class="kw-2">&amp;</span>base * <span class="kw-2">&amp;</span>base;
<a href=#76 id=76 data-nosnippet>76</a> exp &gt;&gt;= <span class="number">1</span>;
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a>
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">if </span>exp == <span class="number">1 </span>{
<a href=#80 id=80 data-nosnippet>80</a> <span class="kw">return </span>base;
<a href=#81 id=81 data-nosnippet>81</a> }
<a href=#82 id=82 data-nosnippet>82</a>
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">let </span><span class="kw-2">mut </span>acc = base.clone();
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">while </span>exp &gt; <span class="number">1 </span>{
<a href=#85 id=85 data-nosnippet>85</a> exp &gt;&gt;= <span class="number">1</span>;
<a href=#86 id=86 data-nosnippet>86</a> base = <span class="kw-2">&amp;</span>base * <span class="kw-2">&amp;</span>base;
<a href=#87 id=87 data-nosnippet>87</a> <span class="kw">if </span>exp &amp; <span class="number">1 </span>== <span class="number">1 </span>{
<a href=#88 id=88 data-nosnippet>88</a> acc <span class="kw-2">*</span>= <span class="kw-2">&amp;</span>base;
<a href=#89 id=89 data-nosnippet>89</a> }
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> acc
<a href=#92 id=92 data-nosnippet>92</a> }
<a href=#93 id=93 data-nosnippet>93</a> }
<a href=#94 id=94 data-nosnippet>94</a>
<a href=#95 id=95 data-nosnippet>95</a> <span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span>BigUint {
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">type </span>Output = BigUint;
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a> <span class="attr">#[inline]
<a href=#99 id=99 data-nosnippet>99</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>) -&gt; BigUint {
<a href=#100 id=100 data-nosnippet>100</a> Pow::pow(<span class="self">self</span>, <span class="kw-2">*</span>exp)
<a href=#101 id=101 data-nosnippet>101</a> }
<a href=#102 id=102 data-nosnippet>102</a> }
<a href=#103 id=103 data-nosnippet>103</a>
<a href=#104 id=104 data-nosnippet>104</a> <span class="kw">impl </span>Pow&lt;<span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#105 id=105 data-nosnippet>105</a> <span class="kw">type </span>Output = BigUint;
<a href=#106 id=106 data-nosnippet>106</a>
<a href=#107 id=107 data-nosnippet>107</a> <span class="attr">#[inline]
<a href=#108 id=108 data-nosnippet>108</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: <span class="macro-nonterminal">$T</span>) -&gt; BigUint {
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">if </span>exp == <span class="number">0 </span>{
<a href=#110 id=110 data-nosnippet>110</a> <span class="kw">return </span>BigUint::one();
<a href=#111 id=111 data-nosnippet>111</a> }
<a href=#112 id=112 data-nosnippet>112</a> Pow::pow(<span class="self">self</span>.clone(), exp)
<a href=#113 id=113 data-nosnippet>113</a> }
<a href=#114 id=114 data-nosnippet>114</a> }
<a href=#115 id=115 data-nosnippet>115</a>
<a href=#116 id=116 data-nosnippet>116</a> <span class="kw">impl </span>Pow&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#117 id=117 data-nosnippet>117</a> <span class="kw">type </span>Output = BigUint;
<a href=#118 id=118 data-nosnippet>118</a>
<a href=#119 id=119 data-nosnippet>119</a> <span class="attr">#[inline]
<a href=#120 id=120 data-nosnippet>120</a> </span><span class="kw">fn </span>pow(<span class="self">self</span>, exp: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$T</span>) -&gt; BigUint {
<a href=#121 id=121 data-nosnippet>121</a> Pow::pow(<span class="self">self</span>, <span class="kw-2">*</span>exp)
<a href=#122 id=122 data-nosnippet>122</a> }
<a href=#123 id=123 data-nosnippet>123</a> }
<a href=#124 id=124 data-nosnippet>124</a> };
<a href=#125 id=125 data-nosnippet>125</a>}
<a href=#126 id=126 data-nosnippet>126</a>
<a href=#127 id=127 data-nosnippet>127</a><span class="macro">pow_impl!</span>(u8);
<a href=#128 id=128 data-nosnippet>128</a><span class="macro">pow_impl!</span>(u16);
<a href=#129 id=129 data-nosnippet>129</a><span class="macro">pow_impl!</span>(u32);
<a href=#130 id=130 data-nosnippet>130</a><span class="macro">pow_impl!</span>(u64);
<a href=#131 id=131 data-nosnippet>131</a><span class="macro">pow_impl!</span>(usize);
<a href=#132 id=132 data-nosnippet>132</a><span class="macro">pow_impl!</span>(u128);
<a href=#133 id=133 data-nosnippet>133</a>
<a href=#134 id=134 data-nosnippet>134</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>modpow(x: <span class="kw-2">&amp;</span>BigUint, exponent: <span class="kw-2">&amp;</span>BigUint, modulus: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#135 id=135 data-nosnippet>135</a> <span class="macro">assert!</span>(
<a href=#136 id=136 data-nosnippet>136</a> !modulus.is_zero(),
<a href=#137 id=137 data-nosnippet>137</a> <span class="string">"attempt to calculate with zero modulus!"
<a href=#138 id=138 data-nosnippet>138</a> </span>);
<a href=#139 id=139 data-nosnippet>139</a>
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">if </span>modulus.is_odd() {
<a href=#141 id=141 data-nosnippet>141</a> <span class="comment">// For an odd modulus, we can use Montgomery multiplication in base 2^32.
<a href=#142 id=142 data-nosnippet>142</a> </span>monty_modpow(x, exponent, modulus)
<a href=#143 id=143 data-nosnippet>143</a> } <span class="kw">else </span>{
<a href=#144 id=144 data-nosnippet>144</a> <span class="comment">// Otherwise do basically the same as `num::pow`, but with a modulus.
<a href=#145 id=145 data-nosnippet>145</a> </span>plain_modpow(x, <span class="kw-2">&amp;</span>exponent.data, modulus)
<a href=#146 id=146 data-nosnippet>146</a> }
<a href=#147 id=147 data-nosnippet>147</a>}
<a href=#148 id=148 data-nosnippet>148</a>
<a href=#149 id=149 data-nosnippet>149</a><span class="kw">fn </span>plain_modpow(base: <span class="kw-2">&amp;</span>BigUint, exp_data: <span class="kw-2">&amp;</span>[BigDigit], modulus: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#150 id=150 data-nosnippet>150</a> <span class="macro">assert!</span>(
<a href=#151 id=151 data-nosnippet>151</a> !modulus.is_zero(),
<a href=#152 id=152 data-nosnippet>152</a> <span class="string">"attempt to calculate with zero modulus!"
<a href=#153 id=153 data-nosnippet>153</a> </span>);
<a href=#154 id=154 data-nosnippet>154</a>
<a href=#155 id=155 data-nosnippet>155</a> <span class="kw">let </span>i = <span class="kw">match </span>exp_data.iter().position(|<span class="kw-2">&amp;</span>r| <span class="macro">r !</span>= <span class="number">0</span>) {
<a href=#156 id=156 data-nosnippet>156</a> <span class="prelude-val">None </span>=&gt; <span class="kw">return </span>BigUint::one(),
<a href=#157 id=157 data-nosnippet>157</a> <span class="prelude-val">Some</span>(i) =&gt; i,
<a href=#158 id=158 data-nosnippet>158</a> };
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a> <span class="kw">let </span><span class="kw-2">mut </span>base = base % modulus;
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">for _ in </span><span class="number">0</span>..i {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">for _ in </span><span class="number">0</span>..big_digit::BITS {
<a href=#163 id=163 data-nosnippet>163</a> base = <span class="kw-2">&amp;</span>base * <span class="kw-2">&amp;</span>base % modulus;
<a href=#164 id=164 data-nosnippet>164</a> }
<a href=#165 id=165 data-nosnippet>165</a> }
<a href=#166 id=166 data-nosnippet>166</a>
<a href=#167 id=167 data-nosnippet>167</a> <span class="kw">let </span><span class="kw-2">mut </span>r = exp_data[i];
<a href=#168 id=168 data-nosnippet>168</a> <span class="kw">let </span><span class="kw-2">mut </span>b = <span class="number">0u8</span>;
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">while </span>r.is_even() {
<a href=#170 id=170 data-nosnippet>170</a> base = <span class="kw-2">&amp;</span>base * <span class="kw-2">&amp;</span>base % modulus;
<a href=#171 id=171 data-nosnippet>171</a> r &gt;&gt;= <span class="number">1</span>;
<a href=#172 id=172 data-nosnippet>172</a> b += <span class="number">1</span>;
<a href=#173 id=173 data-nosnippet>173</a> }
<a href=#174 id=174 data-nosnippet>174</a>
<a href=#175 id=175 data-nosnippet>175</a> <span class="kw">let </span><span class="kw-2">mut </span>exp_iter = exp_data[i + <span class="number">1</span>..].iter();
<a href=#176 id=176 data-nosnippet>176</a> <span class="kw">if </span>exp_iter.len() == <span class="number">0 </span>&amp;&amp; r.is_one() {
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">return </span>base;
<a href=#178 id=178 data-nosnippet>178</a> }
<a href=#179 id=179 data-nosnippet>179</a>
<a href=#180 id=180 data-nosnippet>180</a> <span class="kw">let </span><span class="kw-2">mut </span>acc = base.clone();
<a href=#181 id=181 data-nosnippet>181</a> r &gt;&gt;= <span class="number">1</span>;
<a href=#182 id=182 data-nosnippet>182</a> b += <span class="number">1</span>;
<a href=#183 id=183 data-nosnippet>183</a>
<a href=#184 id=184 data-nosnippet>184</a> {
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">let </span><span class="kw-2">mut </span>unit = |exp_is_odd| {
<a href=#186 id=186 data-nosnippet>186</a> base = <span class="kw-2">&amp;</span>base * <span class="kw-2">&amp;</span>base % modulus;
<a href=#187 id=187 data-nosnippet>187</a> <span class="kw">if </span>exp_is_odd {
<a href=#188 id=188 data-nosnippet>188</a> acc <span class="kw-2">*</span>= <span class="kw-2">&amp;</span>base;
<a href=#189 id=189 data-nosnippet>189</a> acc %= modulus;
<a href=#190 id=190 data-nosnippet>190</a> }
<a href=#191 id=191 data-nosnippet>191</a> };
<a href=#192 id=192 data-nosnippet>192</a>
<a href=#193 id=193 data-nosnippet>193</a> <span class="kw">if let </span><span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span>last) = exp_iter.next_back() {
<a href=#194 id=194 data-nosnippet>194</a> <span class="comment">// consume exp_data[i]
<a href=#195 id=195 data-nosnippet>195</a> </span><span class="kw">for _ in </span>b..big_digit::BITS {
<a href=#196 id=196 data-nosnippet>196</a> unit(r.is_odd());
<a href=#197 id=197 data-nosnippet>197</a> r &gt;&gt;= <span class="number">1</span>;
<a href=#198 id=198 data-nosnippet>198</a> }
<a href=#199 id=199 data-nosnippet>199</a>
<a href=#200 id=200 data-nosnippet>200</a> <span class="comment">// consume all other digits before the last
<a href=#201 id=201 data-nosnippet>201</a> </span><span class="kw">for </span><span class="kw-2">&amp;</span>r <span class="kw">in </span>exp_iter {
<a href=#202 id=202 data-nosnippet>202</a> <span class="kw">let </span><span class="kw-2">mut </span>r = r;
<a href=#203 id=203 data-nosnippet>203</a> <span class="kw">for _ in </span><span class="number">0</span>..big_digit::BITS {
<a href=#204 id=204 data-nosnippet>204</a> unit(r.is_odd());
<a href=#205 id=205 data-nosnippet>205</a> r &gt;&gt;= <span class="number">1</span>;
<a href=#206 id=206 data-nosnippet>206</a> }
<a href=#207 id=207 data-nosnippet>207</a> }
<a href=#208 id=208 data-nosnippet>208</a> r = last;
<a href=#209 id=209 data-nosnippet>209</a> }
<a href=#210 id=210 data-nosnippet>210</a>
<a href=#211 id=211 data-nosnippet>211</a> <span class="macro">debug_assert_ne!</span>(r, <span class="number">0</span>);
<a href=#212 id=212 data-nosnippet>212</a> <span class="kw">while </span>!r.is_zero() {
<a href=#213 id=213 data-nosnippet>213</a> unit(r.is_odd());
<a href=#214 id=214 data-nosnippet>214</a> r &gt;&gt;= <span class="number">1</span>;
<a href=#215 id=215 data-nosnippet>215</a> }
<a href=#216 id=216 data-nosnippet>216</a> }
<a href=#217 id=217 data-nosnippet>217</a> acc
<a href=#218 id=218 data-nosnippet>218</a>}
<a href=#219 id=219 data-nosnippet>219</a>
<a href=#220 id=220 data-nosnippet>220</a><span class="attr">#[test]
<a href=#221 id=221 data-nosnippet>221</a></span><span class="kw">fn </span>test_plain_modpow() {
<a href=#222 id=222 data-nosnippet>222</a> <span class="kw">let </span>two = <span class="kw-2">&amp;</span>BigUint::from(<span class="number">2u32</span>);
<a href=#223 id=223 data-nosnippet>223</a> <span class="kw">let </span>modulus = BigUint::from(<span class="number">0x1100u32</span>);
<a href=#224 id=224 data-nosnippet>224</a>
<a href=#225 id=225 data-nosnippet>225</a> <span class="kw">let </span>exp = <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">0b1</span>];
<a href=#226 id=226 data-nosnippet>226</a> <span class="macro">assert_eq!</span>(
<a href=#227 id=227 data-nosnippet>227</a> two.pow(<span class="number">0b1_00000000_u32</span>) % <span class="kw-2">&amp;</span>modulus,
<a href=#228 id=228 data-nosnippet>228</a> plain_modpow(two, <span class="kw-2">&amp;</span>exp, <span class="kw-2">&amp;</span>modulus)
<a href=#229 id=229 data-nosnippet>229</a> );
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">let </span>exp = <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">0b10</span>];
<a href=#231 id=231 data-nosnippet>231</a> <span class="macro">assert_eq!</span>(
<a href=#232 id=232 data-nosnippet>232</a> two.pow(<span class="number">0b10_00000000_u32</span>) % <span class="kw-2">&amp;</span>modulus,
<a href=#233 id=233 data-nosnippet>233</a> plain_modpow(two, <span class="kw-2">&amp;</span>exp, <span class="kw-2">&amp;</span>modulus)
<a href=#234 id=234 data-nosnippet>234</a> );
<a href=#235 id=235 data-nosnippet>235</a> <span class="kw">let </span>exp = <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">0b110010</span>];
<a href=#236 id=236 data-nosnippet>236</a> <span class="macro">assert_eq!</span>(
<a href=#237 id=237 data-nosnippet>237</a> two.pow(<span class="number">0b110010_00000000_u32</span>) % <span class="kw-2">&amp;</span>modulus,
<a href=#238 id=238 data-nosnippet>238</a> plain_modpow(two, <span class="kw-2">&amp;</span>exp, <span class="kw-2">&amp;</span>modulus)
<a href=#239 id=239 data-nosnippet>239</a> );
<a href=#240 id=240 data-nosnippet>240</a> <span class="kw">let </span>exp = <span class="macro">vec!</span>[<span class="number">0b1</span>, <span class="number">0b1</span>];
<a href=#241 id=241 data-nosnippet>241</a> <span class="macro">assert_eq!</span>(
<a href=#242 id=242 data-nosnippet>242</a> two.pow(<span class="number">0b1_00000001_u32</span>) % <span class="kw-2">&amp;</span>modulus,
<a href=#243 id=243 data-nosnippet>243</a> plain_modpow(two, <span class="kw-2">&amp;</span>exp, <span class="kw-2">&amp;</span>modulus)
<a href=#244 id=244 data-nosnippet>244</a> );
<a href=#245 id=245 data-nosnippet>245</a> <span class="kw">let </span>exp = <span class="macro">vec!</span>[<span class="number">0b1100</span>, <span class="number">0</span>, <span class="number">0b1</span>];
<a href=#246 id=246 data-nosnippet>246</a> <span class="macro">assert_eq!</span>(
<a href=#247 id=247 data-nosnippet>247</a> two.pow(<span class="number">0b1_00000000_00001100_u32</span>) % <span class="kw-2">&amp;</span>modulus,
<a href=#248 id=248 data-nosnippet>248</a> plain_modpow(two, <span class="kw-2">&amp;</span>exp, <span class="kw-2">&amp;</span>modulus)
<a href=#249 id=249 data-nosnippet>249</a> );
<a href=#250 id=250 data-nosnippet>250</a>}
<a href=#251 id=251 data-nosnippet>251</a>
<a href=#252 id=252 data-nosnippet>252</a><span class="attr">#[test]
<a href=#253 id=253 data-nosnippet>253</a></span><span class="kw">fn </span>test_pow_biguint() {
<a href=#254 id=254 data-nosnippet>254</a> <span class="kw">let </span>base = BigUint::from(<span class="number">5u8</span>);
<a href=#255 id=255 data-nosnippet>255</a> <span class="kw">let </span>exponent = BigUint::from(<span class="number">3u8</span>);
<a href=#256 id=256 data-nosnippet>256</a>
<a href=#257 id=257 data-nosnippet>257</a> <span class="macro">assert_eq!</span>(BigUint::from(<span class="number">125u8</span>), base.pow(exponent));
<a href=#258 id=258 data-nosnippet>258</a>}
</code></pre></div></section></main></body></html>
@@ -0,0 +1,174 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/shift.rs`."><title>shift.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>shift.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use super</span>::{biguint_from_vec, BigUint};
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use </span><span class="kw">crate</span>::big_digit;
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span>alloc::borrow::Cow;
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>alloc::vec::Vec;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::mem;
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>core::ops::{Shl, ShlAssign, Shr, ShrAssign};
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span>num_traits::{PrimInt, Zero};
<a href=#10 id=10 data-nosnippet>10</a>
<a href=#11 id=11 data-nosnippet>11</a><span class="attr">#[inline]
<a href=#12 id=12 data-nosnippet>12</a></span><span class="kw">fn </span>biguint_shl&lt;T: PrimInt&gt;(n: Cow&lt;<span class="lifetime">'_</span>, BigUint&gt;, shift: T) -&gt; BigUint {
<a href=#13 id=13 data-nosnippet>13</a> <span class="kw">if </span>shift &lt; T::zero() {
<a href=#14 id=14 data-nosnippet>14</a> <span class="macro">panic!</span>(<span class="string">"attempt to shift left with negative"</span>);
<a href=#15 id=15 data-nosnippet>15</a> }
<a href=#16 id=16 data-nosnippet>16</a> <span class="kw">if </span>n.is_zero() {
<a href=#17 id=17 data-nosnippet>17</a> <span class="kw">return </span>n.into_owned();
<a href=#18 id=18 data-nosnippet>18</a> }
<a href=#19 id=19 data-nosnippet>19</a> <span class="kw">let </span>bits = T::from(big_digit::BITS).unwrap();
<a href=#20 id=20 data-nosnippet>20</a> <span class="kw">let </span>digits = (shift / bits).to_usize().expect(<span class="string">"capacity overflow"</span>);
<a href=#21 id=21 data-nosnippet>21</a> <span class="kw">let </span>shift = (shift % bits).to_u8().unwrap();
<a href=#22 id=22 data-nosnippet>22</a> biguint_shl2(n, digits, shift)
<a href=#23 id=23 data-nosnippet>23</a>}
<a href=#24 id=24 data-nosnippet>24</a>
<a href=#25 id=25 data-nosnippet>25</a><span class="kw">fn </span>biguint_shl2(n: Cow&lt;<span class="lifetime">'_</span>, BigUint&gt;, digits: usize, shift: u8) -&gt; BigUint {
<a href=#26 id=26 data-nosnippet>26</a> <span class="kw">let </span><span class="kw-2">mut </span>data = <span class="kw">match </span>digits {
<a href=#27 id=27 data-nosnippet>27</a> <span class="number">0 </span>=&gt; n.into_owned().data,
<a href=#28 id=28 data-nosnippet>28</a> <span class="kw">_ </span>=&gt; {
<a href=#29 id=29 data-nosnippet>29</a> <span class="kw">let </span>len = digits.saturating_add(n.data.len() + <span class="number">1</span>);
<a href=#30 id=30 data-nosnippet>30</a> <span class="kw">let </span><span class="kw-2">mut </span>data = Vec::with_capacity(len);
<a href=#31 id=31 data-nosnippet>31</a> data.resize(digits, <span class="number">0</span>);
<a href=#32 id=32 data-nosnippet>32</a> data.extend(n.data.iter());
<a href=#33 id=33 data-nosnippet>33</a> data
<a href=#34 id=34 data-nosnippet>34</a> }
<a href=#35 id=35 data-nosnippet>35</a> };
<a href=#36 id=36 data-nosnippet>36</a>
<a href=#37 id=37 data-nosnippet>37</a> <span class="kw">if </span>shift &gt; <span class="number">0 </span>{
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">let </span><span class="kw-2">mut </span>carry = <span class="number">0</span>;
<a href=#39 id=39 data-nosnippet>39</a> <span class="kw">let </span>carry_shift = big_digit::BITS - shift;
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">for </span>elem <span class="kw">in </span>data[digits..].iter_mut() {
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw">let </span>new_carry = <span class="kw-2">*</span>elem &gt;&gt; carry_shift;
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw-2">*</span>elem = (<span class="kw-2">*</span>elem &lt;&lt; shift) | carry;
<a href=#43 id=43 data-nosnippet>43</a> carry = new_carry;
<a href=#44 id=44 data-nosnippet>44</a> }
<a href=#45 id=45 data-nosnippet>45</a> <span class="kw">if </span><span class="macro">carry !</span>= <span class="number">0 </span>{
<a href=#46 id=46 data-nosnippet>46</a> data.push(carry);
<a href=#47 id=47 data-nosnippet>47</a> }
<a href=#48 id=48 data-nosnippet>48</a> }
<a href=#49 id=49 data-nosnippet>49</a>
<a href=#50 id=50 data-nosnippet>50</a> biguint_from_vec(data)
<a href=#51 id=51 data-nosnippet>51</a>}
<a href=#52 id=52 data-nosnippet>52</a>
<a href=#53 id=53 data-nosnippet>53</a><span class="attr">#[inline]
<a href=#54 id=54 data-nosnippet>54</a></span><span class="kw">fn </span>biguint_shr&lt;T: PrimInt&gt;(n: Cow&lt;<span class="lifetime">'_</span>, BigUint&gt;, shift: T) -&gt; BigUint {
<a href=#55 id=55 data-nosnippet>55</a> <span class="kw">if </span>shift &lt; T::zero() {
<a href=#56 id=56 data-nosnippet>56</a> <span class="macro">panic!</span>(<span class="string">"attempt to shift right with negative"</span>);
<a href=#57 id=57 data-nosnippet>57</a> }
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">if </span>n.is_zero() {
<a href=#59 id=59 data-nosnippet>59</a> <span class="kw">return </span>n.into_owned();
<a href=#60 id=60 data-nosnippet>60</a> }
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw">let </span>bits = T::from(big_digit::BITS).unwrap();
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">let </span>digits = (shift / bits).to_usize().unwrap_or(usize::MAX);
<a href=#63 id=63 data-nosnippet>63</a> <span class="kw">let </span>shift = (shift % bits).to_u8().unwrap();
<a href=#64 id=64 data-nosnippet>64</a> biguint_shr2(n, digits, shift)
<a href=#65 id=65 data-nosnippet>65</a>}
<a href=#66 id=66 data-nosnippet>66</a>
<a href=#67 id=67 data-nosnippet>67</a><span class="kw">fn </span>biguint_shr2(n: Cow&lt;<span class="lifetime">'_</span>, BigUint&gt;, digits: usize, shift: u8) -&gt; BigUint {
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">if </span>digits &gt;= n.data.len() {
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">let </span><span class="kw-2">mut </span>n = n.into_owned();
<a href=#70 id=70 data-nosnippet>70</a> n.set_zero();
<a href=#71 id=71 data-nosnippet>71</a> <span class="kw">return </span>n;
<a href=#72 id=72 data-nosnippet>72</a> }
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">let </span><span class="kw-2">mut </span>data = <span class="kw">match </span>n {
<a href=#74 id=74 data-nosnippet>74</a> Cow::Borrowed(n) =&gt; n.data[digits..].to_vec(),
<a href=#75 id=75 data-nosnippet>75</a> Cow::Owned(<span class="kw-2">mut </span>n) =&gt; {
<a href=#76 id=76 data-nosnippet>76</a> n.data.drain(..digits);
<a href=#77 id=77 data-nosnippet>77</a> n.data
<a href=#78 id=78 data-nosnippet>78</a> }
<a href=#79 id=79 data-nosnippet>79</a> };
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a> <span class="kw">if </span>shift &gt; <span class="number">0 </span>{
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">let </span><span class="kw-2">mut </span>borrow = <span class="number">0</span>;
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">let </span>borrow_shift = big_digit::BITS - shift;
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">for </span>elem <span class="kw">in </span>data.iter_mut().rev() {
<a href=#85 id=85 data-nosnippet>85</a> <span class="kw">let </span>new_borrow = <span class="kw-2">*</span>elem &lt;&lt; borrow_shift;
<a href=#86 id=86 data-nosnippet>86</a> <span class="kw-2">*</span>elem = (<span class="kw-2">*</span>elem &gt;&gt; shift) | borrow;
<a href=#87 id=87 data-nosnippet>87</a> borrow = new_borrow;
<a href=#88 id=88 data-nosnippet>88</a> }
<a href=#89 id=89 data-nosnippet>89</a> }
<a href=#90 id=90 data-nosnippet>90</a>
<a href=#91 id=91 data-nosnippet>91</a> biguint_from_vec(data)
<a href=#92 id=92 data-nosnippet>92</a>}
<a href=#93 id=93 data-nosnippet>93</a>
<a href=#94 id=94 data-nosnippet>94</a><span class="macro">macro_rules!</span> impl_shift {
<a href=#95 id=95 data-nosnippet>95</a> (@<span class="kw-2">ref </span><span class="macro-nonterminal">$Shx</span>:ident :: <span class="macro-nonterminal">$shx</span>:ident, <span class="macro-nonterminal">$ShxAssign</span>:ident :: <span class="macro-nonterminal">$shx_assign</span>:ident, <span class="macro-nonterminal">$rhs</span>:ty) =&gt; {
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">impl </span><span class="macro-nonterminal">$Shx</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw">type </span>Output = BigUint;
<a href=#98 id=98 data-nosnippet>98</a>
<a href=#99 id=99 data-nosnippet>99</a> <span class="attr">#[inline]
<a href=#100 id=100 data-nosnippet>100</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#101 id=101 data-nosnippet>101</a> <span class="macro-nonterminal">$Shx</span>::<span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs)
<a href=#102 id=102 data-nosnippet>102</a> }
<a href=#103 id=103 data-nosnippet>103</a> }
<a href=#104 id=104 data-nosnippet>104</a> <span class="kw">impl </span><span class="macro-nonterminal">$Shx</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#105 id=105 data-nosnippet>105</a> <span class="kw">type </span>Output = BigUint;
<a href=#106 id=106 data-nosnippet>106</a>
<a href=#107 id=107 data-nosnippet>107</a> <span class="attr">#[inline]
<a href=#108 id=108 data-nosnippet>108</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#109 id=109 data-nosnippet>109</a> <span class="macro-nonterminal">$Shx</span>::<span class="macro-nonterminal">$shx</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs)
<a href=#110 id=110 data-nosnippet>110</a> }
<a href=#111 id=111 data-nosnippet>111</a> }
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">impl </span><span class="macro-nonterminal">$ShxAssign</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#113 id=113 data-nosnippet>113</a> <span class="attr">#[inline]
<a href=#114 id=114 data-nosnippet>114</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$shx_assign</span>(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$rhs</span>) {
<a href=#115 id=115 data-nosnippet>115</a> <span class="macro-nonterminal">$ShxAssign</span>::<span class="macro-nonterminal">$shx_assign</span>(<span class="self">self</span>, <span class="kw-2">*</span>rhs);
<a href=#116 id=116 data-nosnippet>116</a> }
<a href=#117 id=117 data-nosnippet>117</a> }
<a href=#118 id=118 data-nosnippet>118</a> };
<a href=#119 id=119 data-nosnippet>119</a> ($(<span class="macro-nonterminal">$rhs</span>:ty),+) =&gt; {$(
<a href=#120 id=120 data-nosnippet>120</a> <span class="kw">impl </span>Shl&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#121 id=121 data-nosnippet>121</a> <span class="kw">type </span>Output = BigUint;
<a href=#122 id=122 data-nosnippet>122</a>
<a href=#123 id=123 data-nosnippet>123</a> <span class="attr">#[inline]
<a href=#124 id=124 data-nosnippet>124</a> </span><span class="kw">fn </span>shl(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#125 id=125 data-nosnippet>125</a> biguint_shl(Cow::Owned(<span class="self">self</span>), rhs)
<a href=#126 id=126 data-nosnippet>126</a> }
<a href=#127 id=127 data-nosnippet>127</a> }
<a href=#128 id=128 data-nosnippet>128</a> <span class="kw">impl </span>Shl&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#129 id=129 data-nosnippet>129</a> <span class="kw">type </span>Output = BigUint;
<a href=#130 id=130 data-nosnippet>130</a>
<a href=#131 id=131 data-nosnippet>131</a> <span class="attr">#[inline]
<a href=#132 id=132 data-nosnippet>132</a> </span><span class="kw">fn </span>shl(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#133 id=133 data-nosnippet>133</a> biguint_shl(Cow::Borrowed(<span class="self">self</span>), rhs)
<a href=#134 id=134 data-nosnippet>134</a> }
<a href=#135 id=135 data-nosnippet>135</a> }
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">impl </span>ShlAssign&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#137 id=137 data-nosnippet>137</a> <span class="attr">#[inline]
<a href=#138 id=138 data-nosnippet>138</a> </span><span class="kw">fn </span>shl_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) {
<a href=#139 id=139 data-nosnippet>139</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw-2">*</span><span class="self">self </span>= n &lt;&lt; rhs;
<a href=#141 id=141 data-nosnippet>141</a> }
<a href=#142 id=142 data-nosnippet>142</a> }
<a href=#143 id=143 data-nosnippet>143</a> <span class="macro">impl_shift!</span> { @<span class="kw-2">ref </span>Shl::shl, ShlAssign::shl_assign, <span class="macro-nonterminal">$rhs </span>}
<a href=#144 id=144 data-nosnippet>144</a>
<a href=#145 id=145 data-nosnippet>145</a> <span class="kw">impl </span>Shr&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">type </span>Output = BigUint;
<a href=#147 id=147 data-nosnippet>147</a>
<a href=#148 id=148 data-nosnippet>148</a> <span class="attr">#[inline]
<a href=#149 id=149 data-nosnippet>149</a> </span><span class="kw">fn </span>shr(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#150 id=150 data-nosnippet>150</a> biguint_shr(Cow::Owned(<span class="self">self</span>), rhs)
<a href=#151 id=151 data-nosnippet>151</a> }
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a> <span class="kw">impl </span>Shr&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#154 id=154 data-nosnippet>154</a> <span class="kw">type </span>Output = BigUint;
<a href=#155 id=155 data-nosnippet>155</a>
<a href=#156 id=156 data-nosnippet>156</a> <span class="attr">#[inline]
<a href=#157 id=157 data-nosnippet>157</a> </span><span class="kw">fn </span>shr(<span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) -&gt; BigUint {
<a href=#158 id=158 data-nosnippet>158</a> biguint_shr(Cow::Borrowed(<span class="self">self</span>), rhs)
<a href=#159 id=159 data-nosnippet>159</a> }
<a href=#160 id=160 data-nosnippet>160</a> }
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">impl </span>ShrAssign&lt;<span class="macro-nonterminal">$rhs</span>&gt; <span class="kw">for </span>BigUint {
<a href=#162 id=162 data-nosnippet>162</a> <span class="attr">#[inline]
<a href=#163 id=163 data-nosnippet>163</a> </span><span class="kw">fn </span>shr_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, rhs: <span class="macro-nonterminal">$rhs</span>) {
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">let </span>n = mem::replace(<span class="self">self</span>, <span class="self">Self</span>::ZERO);
<a href=#165 id=165 data-nosnippet>165</a> <span class="kw-2">*</span><span class="self">self </span>= n &gt;&gt; rhs;
<a href=#166 id=166 data-nosnippet>166</a> }
<a href=#167 id=167 data-nosnippet>167</a> }
<a href=#168 id=168 data-nosnippet>168</a> <span class="macro">impl_shift!</span> { @<span class="kw-2">ref </span>Shr::shr, ShrAssign::shr_assign, <span class="macro-nonterminal">$rhs </span>}
<a href=#169 id=169 data-nosnippet>169</a> )<span class="kw-2">*</span>};
<a href=#170 id=170 data-nosnippet>170</a>}
<a href=#171 id=171 data-nosnippet>171</a>
<a href=#172 id=172 data-nosnippet>172</a><span class="macro">impl_shift!</span> { u8, u16, u32, u64, u128, usize }
<a href=#173 id=173 data-nosnippet>173</a><span class="macro">impl_shift!</span> { i8, i16, i32, i64, i128, isize }
</code></pre></div></section></main></body></html>
@@ -0,0 +1,313 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/biguint/subtraction.rs`."><title>subtraction.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/biguint/</div>subtraction.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="kw">use </span><span class="kw">super</span>::BigUint;
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a><span class="kw">use </span><span class="kw">crate</span>::big_digit::{<span class="self">self</span>, BigDigit};
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::UsizePromotion;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>core::cmp::Ordering::{Equal, Greater, Less};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::ops::{Sub, SubAssign};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span>num_traits::CheckedSub;
<a href=#9 id=9 data-nosnippet>9</a>
<a href=#10 id=10 data-nosnippet>10</a><span class="attr">#[cfg(target_arch = <span class="string">"x86_64"</span>)]
<a href=#11 id=11 data-nosnippet>11</a></span><span class="kw">use </span>core::arch::x86_64 <span class="kw">as </span>arch;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="attr">#[cfg(target_arch = <span class="string">"x86"</span>)]
<a href=#14 id=14 data-nosnippet>14</a></span><span class="kw">use </span>core::arch::x86 <span class="kw">as </span>arch;
<a href=#15 id=15 data-nosnippet>15</a>
<a href=#16 id=16 data-nosnippet>16</a><span class="comment">// Subtract with borrow:
<a href=#17 id=17 data-nosnippet>17</a></span><span class="attr">#[cfg(target_arch = <span class="string">"x86_64"</span>)]
<a href=#18 id=18 data-nosnippet>18</a></span><span class="macro">cfg_64!</span>(
<a href=#19 id=19 data-nosnippet>19</a> <span class="attr">#[inline]
<a href=#20 id=20 data-nosnippet>20</a> </span><span class="kw">fn </span>sbb(borrow: u8, a: u64, b: u64, out: <span class="kw-2">&amp;mut </span>u64) -&gt; u8 {
<a href=#21 id=21 data-nosnippet>21</a> <span class="comment">// Safety: There are absolutely no safety concerns with calling `_subborrow_u64`.
<a href=#22 id=22 data-nosnippet>22</a> // It's just unsafe for API consistency with other intrinsics.
<a href=#23 id=23 data-nosnippet>23</a> </span><span class="kw">unsafe </span>{ arch::_subborrow_u64(borrow, a, b, out) }
<a href=#24 id=24 data-nosnippet>24</a> }
<a href=#25 id=25 data-nosnippet>25</a>);
<a href=#26 id=26 data-nosnippet>26</a>
<a href=#27 id=27 data-nosnippet>27</a><span class="attr">#[cfg(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>))]
<a href=#28 id=28 data-nosnippet>28</a></span><span class="macro">cfg_32!</span>(
<a href=#29 id=29 data-nosnippet>29</a> <span class="attr">#[inline]
<a href=#30 id=30 data-nosnippet>30</a> </span><span class="kw">fn </span>sbb(borrow: u8, a: u32, b: u32, out: <span class="kw-2">&amp;mut </span>u32) -&gt; u8 {
<a href=#31 id=31 data-nosnippet>31</a> <span class="comment">// Safety: There are absolutely no safety concerns with calling `_subborrow_u32`.
<a href=#32 id=32 data-nosnippet>32</a> // It's just unsafe for API consistency with other intrinsics.
<a href=#33 id=33 data-nosnippet>33</a> </span><span class="kw">unsafe </span>{ arch::_subborrow_u32(borrow, a, b, out) }
<a href=#34 id=34 data-nosnippet>34</a> }
<a href=#35 id=35 data-nosnippet>35</a>);
<a href=#36 id=36 data-nosnippet>36</a>
<a href=#37 id=37 data-nosnippet>37</a><span class="comment">// fallback for environments where we don't have a subborrow intrinsic
<a href=#38 id=38 data-nosnippet>38</a>// (copied from the standard library's `borrowing_sub`)
<a href=#39 id=39 data-nosnippet>39</a></span><span class="attr">#[cfg(not(any(target_arch = <span class="string">"x86"</span>, target_arch = <span class="string">"x86_64"</span>)))]
<a href=#40 id=40 data-nosnippet>40</a>#[inline]
<a href=#41 id=41 data-nosnippet>41</a></span><span class="kw">fn </span>sbb(borrow: u8, lhs: BigDigit, rhs: BigDigit, out: <span class="kw-2">&amp;mut </span>BigDigit) -&gt; u8 {
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">let </span>(a, b) = lhs.overflowing_sub(rhs);
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">let </span>(c, d) = a.overflowing_sub(borrow <span class="kw">as </span>BigDigit);
<a href=#44 id=44 data-nosnippet>44</a> <span class="kw-2">*</span>out = c;
<a href=#45 id=45 data-nosnippet>45</a> u8::from(b || d)
<a href=#46 id=46 data-nosnippet>46</a>}
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a><span class="kw">pub</span>(<span class="kw">super</span>) <span class="kw">fn </span>sub2(a: <span class="kw-2">&amp;mut </span>[BigDigit], b: <span class="kw-2">&amp;</span>[BigDigit]) {
<a href=#49 id=49 data-nosnippet>49</a> <span class="kw">let </span><span class="kw-2">mut </span>borrow = <span class="number">0</span>;
<a href=#50 id=50 data-nosnippet>50</a>
<a href=#51 id=51 data-nosnippet>51</a> <span class="kw">let </span>len = Ord::min(a.len(), b.len());
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">let </span>(a_lo, a_hi) = a.split_at_mut(len);
<a href=#53 id=53 data-nosnippet>53</a> <span class="kw">let </span>(b_lo, b_hi) = b.split_at(len);
<a href=#54 id=54 data-nosnippet>54</a>
<a href=#55 id=55 data-nosnippet>55</a> <span class="kw">for </span>(a, b) <span class="kw">in </span>a_lo.iter_mut().zip(b_lo) {
<a href=#56 id=56 data-nosnippet>56</a> borrow = sbb(borrow, <span class="kw-2">*</span>a, <span class="kw-2">*</span>b, a);
<a href=#57 id=57 data-nosnippet>57</a> }
<a href=#58 id=58 data-nosnippet>58</a>
<a href=#59 id=59 data-nosnippet>59</a> <span class="kw">if </span><span class="macro">borrow !</span>= <span class="number">0 </span>{
<a href=#60 id=60 data-nosnippet>60</a> <span class="kw">for </span>a <span class="kw">in </span>a_hi {
<a href=#61 id=61 data-nosnippet>61</a> borrow = sbb(borrow, <span class="kw-2">*</span>a, <span class="number">0</span>, a);
<a href=#62 id=62 data-nosnippet>62</a> <span class="kw">if </span>borrow == <span class="number">0 </span>{
<a href=#63 id=63 data-nosnippet>63</a> <span class="kw">break</span>;
<a href=#64 id=64 data-nosnippet>64</a> }
<a href=#65 id=65 data-nosnippet>65</a> }
<a href=#66 id=66 data-nosnippet>66</a> }
<a href=#67 id=67 data-nosnippet>67</a>
<a href=#68 id=68 data-nosnippet>68</a> <span class="comment">// note: we're _required_ to fail on underflow
<a href=#69 id=69 data-nosnippet>69</a> </span><span class="macro">assert!</span>(
<a href=#70 id=70 data-nosnippet>70</a> borrow == <span class="number">0 </span>&amp;&amp; b_hi.iter().all(|x| <span class="kw-2">*</span>x == <span class="number">0</span>),
<a href=#71 id=71 data-nosnippet>71</a> <span class="string">"Cannot subtract b from a because b is larger than a."
<a href=#72 id=72 data-nosnippet>72</a> </span>);
<a href=#73 id=73 data-nosnippet>73</a>}
<a href=#74 id=74 data-nosnippet>74</a>
<a href=#75 id=75 data-nosnippet>75</a><span class="comment">// Only for the Sub impl. `a` and `b` must have same length.
<a href=#76 id=76 data-nosnippet>76</a></span><span class="attr">#[inline]
<a href=#77 id=77 data-nosnippet>77</a></span><span class="kw">fn </span>__sub2rev(a: <span class="kw-2">&amp;</span>[BigDigit], b: <span class="kw-2">&amp;mut </span>[BigDigit]) -&gt; u8 {
<a href=#78 id=78 data-nosnippet>78</a> <span class="macro">debug_assert!</span>(b.len() == a.len());
<a href=#79 id=79 data-nosnippet>79</a>
<a href=#80 id=80 data-nosnippet>80</a> <span class="kw">let </span><span class="kw-2">mut </span>borrow = <span class="number">0</span>;
<a href=#81 id=81 data-nosnippet>81</a>
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">for </span>(ai, bi) <span class="kw">in </span>a.iter().zip(b) {
<a href=#83 id=83 data-nosnippet>83</a> borrow = sbb(borrow, <span class="kw-2">*</span>ai, <span class="kw-2">*</span>bi, bi);
<a href=#84 id=84 data-nosnippet>84</a> }
<a href=#85 id=85 data-nosnippet>85</a>
<a href=#86 id=86 data-nosnippet>86</a> borrow
<a href=#87 id=87 data-nosnippet>87</a>}
<a href=#88 id=88 data-nosnippet>88</a>
<a href=#89 id=89 data-nosnippet>89</a><span class="kw">fn </span>sub2rev(a: <span class="kw-2">&amp;</span>[BigDigit], b: <span class="kw-2">&amp;mut </span>[BigDigit]) {
<a href=#90 id=90 data-nosnippet>90</a> <span class="macro">debug_assert!</span>(b.len() &gt;= a.len());
<a href=#91 id=91 data-nosnippet>91</a>
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">let </span>len = Ord::min(a.len(), b.len());
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">let </span>(a_lo, a_hi) = a.split_at(len);
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">let </span>(b_lo, b_hi) = b.split_at_mut(len);
<a href=#95 id=95 data-nosnippet>95</a>
<a href=#96 id=96 data-nosnippet>96</a> <span class="kw">let </span>borrow = __sub2rev(a_lo, b_lo);
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a> <span class="macro">assert!</span>(a_hi.is_empty());
<a href=#99 id=99 data-nosnippet>99</a>
<a href=#100 id=100 data-nosnippet>100</a> <span class="comment">// note: we're _required_ to fail on underflow
<a href=#101 id=101 data-nosnippet>101</a> </span><span class="macro">assert!</span>(
<a href=#102 id=102 data-nosnippet>102</a> borrow == <span class="number">0 </span>&amp;&amp; b_hi.iter().all(|x| <span class="kw-2">*</span>x == <span class="number">0</span>),
<a href=#103 id=103 data-nosnippet>103</a> <span class="string">"Cannot subtract b from a because b is larger than a."
<a href=#104 id=104 data-nosnippet>104</a> </span>);
<a href=#105 id=105 data-nosnippet>105</a>}
<a href=#106 id=106 data-nosnippet>106</a>
<a href=#107 id=107 data-nosnippet>107</a><span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span>Sub <span class="kw">for </span>BigUint, sub);
<a href=#108 id=108 data-nosnippet>108</a><span class="macro">forward_ref_ref_binop!</span>(<span class="kw">impl </span>Sub <span class="kw">for </span>BigUint, sub);
<a href=#109 id=109 data-nosnippet>109</a><span class="macro">forward_val_assign!</span>(<span class="kw">impl </span>SubAssign <span class="kw">for </span>BigUint, sub_assign);
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a><span class="kw">impl </span>Sub&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">type </span>Output = BigUint;
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a> <span class="kw">fn </span>sub(<span class="kw-2">mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) -&gt; BigUint {
<a href=#115 id=115 data-nosnippet>115</a> <span class="self">self </span>-= other;
<a href=#116 id=116 data-nosnippet>116</a> <span class="self">self
<a href=#117 id=117 data-nosnippet>117</a> </span>}
<a href=#118 id=118 data-nosnippet>118</a>}
<a href=#119 id=119 data-nosnippet>119</a><span class="kw">impl </span>SubAssign&lt;<span class="kw-2">&amp;</span>BigUint&gt; <span class="kw">for </span>BigUint {
<a href=#120 id=120 data-nosnippet>120</a> <span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="kw-2">&amp;</span>BigUint) {
<a href=#121 id=121 data-nosnippet>121</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>other.data[..]);
<a href=#122 id=122 data-nosnippet>122</a> <span class="self">self</span>.normalize();
<a href=#123 id=123 data-nosnippet>123</a> }
<a href=#124 id=124 data-nosnippet>124</a>}
<a href=#125 id=125 data-nosnippet>125</a>
<a href=#126 id=126 data-nosnippet>126</a><span class="kw">impl </span>Sub&lt;BigUint&gt; <span class="kw">for </span><span class="kw-2">&amp;</span>BigUint {
<a href=#127 id=127 data-nosnippet>127</a> <span class="kw">type </span>Output = BigUint;
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a> <span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#130 id=130 data-nosnippet>130</a> <span class="kw">let </span>other_len = other.data.len();
<a href=#131 id=131 data-nosnippet>131</a> <span class="kw">if </span>other_len &lt; <span class="self">self</span>.data.len() {
<a href=#132 id=132 data-nosnippet>132</a> <span class="kw">let </span>lo_borrow = __sub2rev(<span class="kw-2">&amp;</span><span class="self">self</span>.data[..other_len], <span class="kw-2">&amp;mut </span>other.data);
<a href=#133 id=133 data-nosnippet>133</a> other.data.extend_from_slice(<span class="kw-2">&amp;</span><span class="self">self</span>.data[other_len..]);
<a href=#134 id=134 data-nosnippet>134</a> <span class="kw">if </span><span class="macro">lo_borrow !</span>= <span class="number">0 </span>{
<a href=#135 id=135 data-nosnippet>135</a> sub2(<span class="kw-2">&amp;mut </span>other.data[other_len..], <span class="kw-2">&amp;</span>[<span class="number">1</span>])
<a href=#136 id=136 data-nosnippet>136</a> }
<a href=#137 id=137 data-nosnippet>137</a> } <span class="kw">else </span>{
<a href=#138 id=138 data-nosnippet>138</a> sub2rev(<span class="kw-2">&amp;</span><span class="self">self</span>.data[..], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#139 id=139 data-nosnippet>139</a> }
<a href=#140 id=140 data-nosnippet>140</a> other.normalized()
<a href=#141 id=141 data-nosnippet>141</a> }
<a href=#142 id=142 data-nosnippet>142</a>}
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a><span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span>Sub <span class="kw">for </span>BigUint, sub);
<a href=#145 id=145 data-nosnippet>145</a><span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span>SubAssign <span class="kw">for </span>BigUint, sub_assign);
<a href=#146 id=146 data-nosnippet>146</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u32&gt; <span class="kw">for </span>BigUint, sub);
<a href=#147 id=147 data-nosnippet>147</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u64&gt; <span class="kw">for </span>BigUint, sub);
<a href=#148 id=148 data-nosnippet>148</a><span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span>Sub&lt;u128&gt; <span class="kw">for </span>BigUint, sub);
<a href=#149 id=149 data-nosnippet>149</a>
<a href=#150 id=150 data-nosnippet>150</a><span class="kw">impl </span>Sub&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#151 id=151 data-nosnippet>151</a> <span class="kw">type </span>Output = BigUint;
<a href=#152 id=152 data-nosnippet>152</a>
<a href=#153 id=153 data-nosnippet>153</a> <span class="attr">#[inline]
<a href=#154 id=154 data-nosnippet>154</a> </span><span class="kw">fn </span>sub(<span class="kw-2">mut </span><span class="self">self</span>, other: u32) -&gt; BigUint {
<a href=#155 id=155 data-nosnippet>155</a> <span class="self">self </span>-= other;
<a href=#156 id=156 data-nosnippet>156</a> <span class="self">self
<a href=#157 id=157 data-nosnippet>157</a> </span>}
<a href=#158 id=158 data-nosnippet>158</a>}
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a><span class="kw">impl </span>SubAssign&lt;u32&gt; <span class="kw">for </span>BigUint {
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u32) {
<a href=#162 id=162 data-nosnippet>162</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>[other <span class="kw">as </span>BigDigit]);
<a href=#163 id=163 data-nosnippet>163</a> <span class="self">self</span>.normalize();
<a href=#164 id=164 data-nosnippet>164</a> }
<a href=#165 id=165 data-nosnippet>165</a>}
<a href=#166 id=166 data-nosnippet>166</a>
<a href=#167 id=167 data-nosnippet>167</a><span class="kw">impl </span>Sub&lt;BigUint&gt; <span class="kw">for </span>u32 {
<a href=#168 id=168 data-nosnippet>168</a> <span class="kw">type </span>Output = BigUint;
<a href=#169 id=169 data-nosnippet>169</a>
<a href=#170 id=170 data-nosnippet>170</a> <span class="macro">cfg_digit!</span>(
<a href=#171 id=171 data-nosnippet>171</a> <span class="attr">#[inline]
<a href=#172 id=172 data-nosnippet>172</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#173 id=173 data-nosnippet>173</a> <span class="kw">if </span>other.data.len() == <span class="number">0 </span>{
<a href=#174 id=174 data-nosnippet>174</a> other.data.push(<span class="self">self</span>);
<a href=#175 id=175 data-nosnippet>175</a> } <span class="kw">else </span>{
<a href=#176 id=176 data-nosnippet>176</a> sub2rev(<span class="kw-2">&amp;</span>[<span class="self">self</span>], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#177 id=177 data-nosnippet>177</a> }
<a href=#178 id=178 data-nosnippet>178</a> other.normalized()
<a href=#179 id=179 data-nosnippet>179</a> }
<a href=#180 id=180 data-nosnippet>180</a>
<a href=#181 id=181 data-nosnippet>181</a> <span class="attr">#[inline]
<a href=#182 id=182 data-nosnippet>182</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#183 id=183 data-nosnippet>183</a> <span class="kw">if </span>other.data.is_empty() {
<a href=#184 id=184 data-nosnippet>184</a> other.data.push(<span class="self">self </span><span class="kw">as </span>BigDigit);
<a href=#185 id=185 data-nosnippet>185</a> } <span class="kw">else </span>{
<a href=#186 id=186 data-nosnippet>186</a> sub2rev(<span class="kw-2">&amp;</span>[<span class="self">self </span><span class="kw">as </span>BigDigit], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a> other.normalized()
<a href=#189 id=189 data-nosnippet>189</a> }
<a href=#190 id=190 data-nosnippet>190</a> );
<a href=#191 id=191 data-nosnippet>191</a>}
<a href=#192 id=192 data-nosnippet>192</a>
<a href=#193 id=193 data-nosnippet>193</a><span class="kw">impl </span>Sub&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#194 id=194 data-nosnippet>194</a> <span class="kw">type </span>Output = BigUint;
<a href=#195 id=195 data-nosnippet>195</a>
<a href=#196 id=196 data-nosnippet>196</a> <span class="attr">#[inline]
<a href=#197 id=197 data-nosnippet>197</a> </span><span class="kw">fn </span>sub(<span class="kw-2">mut </span><span class="self">self</span>, other: u64) -&gt; BigUint {
<a href=#198 id=198 data-nosnippet>198</a> <span class="self">self </span>-= other;
<a href=#199 id=199 data-nosnippet>199</a> <span class="self">self
<a href=#200 id=200 data-nosnippet>200</a> </span>}
<a href=#201 id=201 data-nosnippet>201</a>}
<a href=#202 id=202 data-nosnippet>202</a>
<a href=#203 id=203 data-nosnippet>203</a><span class="kw">impl </span>SubAssign&lt;u64&gt; <span class="kw">for </span>BigUint {
<a href=#204 id=204 data-nosnippet>204</a> <span class="macro">cfg_digit!</span>(
<a href=#205 id=205 data-nosnippet>205</a> <span class="attr">#[inline]
<a href=#206 id=206 data-nosnippet>206</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#207 id=207 data-nosnippet>207</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#208 id=208 data-nosnippet>208</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#209 id=209 data-nosnippet>209</a> <span class="self">self</span>.normalize();
<a href=#210 id=210 data-nosnippet>210</a> }
<a href=#211 id=211 data-nosnippet>211</a>
<a href=#212 id=212 data-nosnippet>212</a> <span class="attr">#[inline]
<a href=#213 id=213 data-nosnippet>213</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u64) {
<a href=#214 id=214 data-nosnippet>214</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>[other <span class="kw">as </span>BigDigit]);
<a href=#215 id=215 data-nosnippet>215</a> <span class="self">self</span>.normalize();
<a href=#216 id=216 data-nosnippet>216</a> }
<a href=#217 id=217 data-nosnippet>217</a> );
<a href=#218 id=218 data-nosnippet>218</a>}
<a href=#219 id=219 data-nosnippet>219</a>
<a href=#220 id=220 data-nosnippet>220</a><span class="kw">impl </span>Sub&lt;BigUint&gt; <span class="kw">for </span>u64 {
<a href=#221 id=221 data-nosnippet>221</a> <span class="kw">type </span>Output = BigUint;
<a href=#222 id=222 data-nosnippet>222</a>
<a href=#223 id=223 data-nosnippet>223</a> <span class="macro">cfg_digit!</span>(
<a href=#224 id=224 data-nosnippet>224</a> <span class="attr">#[inline]
<a href=#225 id=225 data-nosnippet>225</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#226 id=226 data-nosnippet>226</a> <span class="kw">while </span>other.data.len() &lt; <span class="number">2 </span>{
<a href=#227 id=227 data-nosnippet>227</a> other.data.push(<span class="number">0</span>);
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a>
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(<span class="self">self</span>);
<a href=#231 id=231 data-nosnippet>231</a> sub2rev(<span class="kw-2">&amp;</span>[lo, hi], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#232 id=232 data-nosnippet>232</a> other.normalized()
<a href=#233 id=233 data-nosnippet>233</a> }
<a href=#234 id=234 data-nosnippet>234</a>
<a href=#235 id=235 data-nosnippet>235</a> <span class="attr">#[inline]
<a href=#236 id=236 data-nosnippet>236</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#237 id=237 data-nosnippet>237</a> <span class="kw">if </span>other.data.is_empty() {
<a href=#238 id=238 data-nosnippet>238</a> other.data.push(<span class="self">self</span>);
<a href=#239 id=239 data-nosnippet>239</a> } <span class="kw">else </span>{
<a href=#240 id=240 data-nosnippet>240</a> sub2rev(<span class="kw-2">&amp;</span>[<span class="self">self</span>], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#241 id=241 data-nosnippet>241</a> }
<a href=#242 id=242 data-nosnippet>242</a> other.normalized()
<a href=#243 id=243 data-nosnippet>243</a> }
<a href=#244 id=244 data-nosnippet>244</a> );
<a href=#245 id=245 data-nosnippet>245</a>}
<a href=#246 id=246 data-nosnippet>246</a>
<a href=#247 id=247 data-nosnippet>247</a><span class="kw">impl </span>Sub&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#248 id=248 data-nosnippet>248</a> <span class="kw">type </span>Output = BigUint;
<a href=#249 id=249 data-nosnippet>249</a>
<a href=#250 id=250 data-nosnippet>250</a> <span class="attr">#[inline]
<a href=#251 id=251 data-nosnippet>251</a> </span><span class="kw">fn </span>sub(<span class="kw-2">mut </span><span class="self">self</span>, other: u128) -&gt; BigUint {
<a href=#252 id=252 data-nosnippet>252</a> <span class="self">self </span>-= other;
<a href=#253 id=253 data-nosnippet>253</a> <span class="self">self
<a href=#254 id=254 data-nosnippet>254</a> </span>}
<a href=#255 id=255 data-nosnippet>255</a>}
<a href=#256 id=256 data-nosnippet>256</a>
<a href=#257 id=257 data-nosnippet>257</a><span class="kw">impl </span>SubAssign&lt;u128&gt; <span class="kw">for </span>BigUint {
<a href=#258 id=258 data-nosnippet>258</a> <span class="macro">cfg_digit!</span>(
<a href=#259 id=259 data-nosnippet>259</a> <span class="attr">#[inline]
<a href=#260 id=260 data-nosnippet>260</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#261 id=261 data-nosnippet>261</a> <span class="kw">let </span>(a, b, c, d) = <span class="kw">super</span>::u32_from_u128(other);
<a href=#262 id=262 data-nosnippet>262</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>[d, c, b, a]);
<a href=#263 id=263 data-nosnippet>263</a> <span class="self">self</span>.normalize();
<a href=#264 id=264 data-nosnippet>264</a> }
<a href=#265 id=265 data-nosnippet>265</a>
<a href=#266 id=266 data-nosnippet>266</a> <span class="attr">#[inline]
<a href=#267 id=267 data-nosnippet>267</a> </span><span class="kw">fn </span>sub_assign(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: u128) {
<a href=#268 id=268 data-nosnippet>268</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(other);
<a href=#269 id=269 data-nosnippet>269</a> sub2(<span class="kw-2">&amp;mut </span><span class="self">self</span>.data[..], <span class="kw-2">&amp;</span>[lo, hi]);
<a href=#270 id=270 data-nosnippet>270</a> <span class="self">self</span>.normalize();
<a href=#271 id=271 data-nosnippet>271</a> }
<a href=#272 id=272 data-nosnippet>272</a> );
<a href=#273 id=273 data-nosnippet>273</a>}
<a href=#274 id=274 data-nosnippet>274</a>
<a href=#275 id=275 data-nosnippet>275</a><span class="kw">impl </span>Sub&lt;BigUint&gt; <span class="kw">for </span>u128 {
<a href=#276 id=276 data-nosnippet>276</a> <span class="kw">type </span>Output = BigUint;
<a href=#277 id=277 data-nosnippet>277</a>
<a href=#278 id=278 data-nosnippet>278</a> <span class="macro">cfg_digit!</span>(
<a href=#279 id=279 data-nosnippet>279</a> <span class="attr">#[inline]
<a href=#280 id=280 data-nosnippet>280</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">while </span>other.data.len() &lt; <span class="number">4 </span>{
<a href=#282 id=282 data-nosnippet>282</a> other.data.push(<span class="number">0</span>);
<a href=#283 id=283 data-nosnippet>283</a> }
<a href=#284 id=284 data-nosnippet>284</a>
<a href=#285 id=285 data-nosnippet>285</a> <span class="kw">let </span>(a, b, c, d) = <span class="kw">super</span>::u32_from_u128(<span class="self">self</span>);
<a href=#286 id=286 data-nosnippet>286</a> sub2rev(<span class="kw-2">&amp;</span>[d, c, b, a], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#287 id=287 data-nosnippet>287</a> other.normalized()
<a href=#288 id=288 data-nosnippet>288</a> }
<a href=#289 id=289 data-nosnippet>289</a>
<a href=#290 id=290 data-nosnippet>290</a> <span class="attr">#[inline]
<a href=#291 id=291 data-nosnippet>291</a> </span><span class="kw">fn </span>sub(<span class="self">self</span>, <span class="kw-2">mut </span>other: BigUint) -&gt; BigUint {
<a href=#292 id=292 data-nosnippet>292</a> <span class="kw">while </span>other.data.len() &lt; <span class="number">2 </span>{
<a href=#293 id=293 data-nosnippet>293</a> other.data.push(<span class="number">0</span>);
<a href=#294 id=294 data-nosnippet>294</a> }
<a href=#295 id=295 data-nosnippet>295</a>
<a href=#296 id=296 data-nosnippet>296</a> <span class="kw">let </span>(hi, lo) = big_digit::from_doublebigdigit(<span class="self">self</span>);
<a href=#297 id=297 data-nosnippet>297</a> sub2rev(<span class="kw-2">&amp;</span>[lo, hi], <span class="kw-2">&amp;mut </span>other.data[..]);
<a href=#298 id=298 data-nosnippet>298</a> other.normalized()
<a href=#299 id=299 data-nosnippet>299</a> }
<a href=#300 id=300 data-nosnippet>300</a> );
<a href=#301 id=301 data-nosnippet>301</a>}
<a href=#302 id=302 data-nosnippet>302</a>
<a href=#303 id=303 data-nosnippet>303</a><span class="kw">impl </span>CheckedSub <span class="kw">for </span>BigUint {
<a href=#304 id=304 data-nosnippet>304</a> <span class="attr">#[inline]
<a href=#305 id=305 data-nosnippet>305</a> </span><span class="kw">fn </span>checked_sub(<span class="kw-2">&amp;</span><span class="self">self</span>, v: <span class="kw-2">&amp;</span>BigUint) -&gt; <span class="prelude-ty">Option</span>&lt;BigUint&gt; {
<a href=#306 id=306 data-nosnippet>306</a> <span class="kw">match </span><span class="self">self</span>.cmp(v) {
<a href=#307 id=307 data-nosnippet>307</a> Less =&gt; <span class="prelude-val">None</span>,
<a href=#308 id=308 data-nosnippet>308</a> Equal =&gt; <span class="prelude-val">Some</span>(<span class="self">Self</span>::ZERO),
<a href=#309 id=309 data-nosnippet>309</a> Greater =&gt; <span class="prelude-val">Some</span>(<span class="self">self</span>.sub(v)),
<a href=#310 id=310 data-nosnippet>310</a> }
<a href=#311 id=311 data-nosnippet>311</a> }
<a href=#312 id=312 data-nosnippet>312</a>}
</code></pre></div></section></main></body></html>
+269
View File
@@ -0,0 +1,269 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/lib.rs`."><title>lib.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/</div>lib.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="comment">// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
<a href=#2 id=2 data-nosnippet>2</a>// file at the top-level directory of this distribution and at
<a href=#3 id=3 data-nosnippet>3</a>// http://rust-lang.org/COPYRIGHT.
<a href=#4 id=4 data-nosnippet>4</a>//
<a href=#5 id=5 data-nosnippet>5</a>// Licensed under the Apache License, Version 2.0 &lt;LICENSE-APACHE or
<a href=#6 id=6 data-nosnippet>6</a>// http://www.apache.org/licenses/LICENSE-2.0&gt; or the MIT license
<a href=#7 id=7 data-nosnippet>7</a>// &lt;LICENSE-MIT or http://opensource.org/licenses/MIT&gt;, at your
<a href=#8 id=8 data-nosnippet>8</a>// option. This file may not be copied, modified, or distributed
<a href=#9 id=9 data-nosnippet>9</a>// except according to those terms.
<a href=#10 id=10 data-nosnippet>10</a>
<a href=#11 id=11 data-nosnippet>11</a></span><span class="doccomment">//! Big Integer Types for Rust
<a href=#12 id=12 data-nosnippet>12</a>//!
<a href=#13 id=13 data-nosnippet>13</a>//! * A [`BigUint`] is unsigned and represented as a vector of digits.
<a href=#14 id=14 data-nosnippet>14</a>//! * A [`BigInt`] is signed and is a combination of [`BigUint`] and [`Sign`].
<a href=#15 id=15 data-nosnippet>15</a>//!
<a href=#16 id=16 data-nosnippet>16</a>//! Common numerical operations are overloaded, so we can treat them
<a href=#17 id=17 data-nosnippet>17</a>//! the same way we treat other numbers.
<a href=#18 id=18 data-nosnippet>18</a>//!
<a href=#19 id=19 data-nosnippet>19</a>//! ## Example
<a href=#20 id=20 data-nosnippet>20</a>//!
<a href=#21 id=21 data-nosnippet>21</a>//! ```rust
<a href=#22 id=22 data-nosnippet>22</a>//! # fn main() {
<a href=#23 id=23 data-nosnippet>23</a>//! use num_bigint::BigUint;
<a href=#24 id=24 data-nosnippet>24</a>//! use num_traits::One;
<a href=#25 id=25 data-nosnippet>25</a>//!
<a href=#26 id=26 data-nosnippet>26</a>//! // Calculate large fibonacci numbers.
<a href=#27 id=27 data-nosnippet>27</a>//! fn fib(n: usize) -&gt; BigUint {
<a href=#28 id=28 data-nosnippet>28</a>//! let mut f0 = BigUint::ZERO;
<a href=#29 id=29 data-nosnippet>29</a>//! let mut f1 = BigUint::one();
<a href=#30 id=30 data-nosnippet>30</a>//! for _ in 0..n {
<a href=#31 id=31 data-nosnippet>31</a>//! let f2 = f0 + &amp;f1;
<a href=#32 id=32 data-nosnippet>32</a>//! f0 = f1;
<a href=#33 id=33 data-nosnippet>33</a>//! f1 = f2;
<a href=#34 id=34 data-nosnippet>34</a>//! }
<a href=#35 id=35 data-nosnippet>35</a>//! f0
<a href=#36 id=36 data-nosnippet>36</a>//! }
<a href=#37 id=37 data-nosnippet>37</a>//!
<a href=#38 id=38 data-nosnippet>38</a>//! // This is a very large number.
<a href=#39 id=39 data-nosnippet>39</a>//! println!("fib(1000) = {}", fib(1000));
<a href=#40 id=40 data-nosnippet>40</a>//! # }
<a href=#41 id=41 data-nosnippet>41</a>//! ```
<a href=#42 id=42 data-nosnippet>42</a>//!
<a href=#43 id=43 data-nosnippet>43</a>//! It's easy to generate large random numbers:
<a href=#44 id=44 data-nosnippet>44</a>//!
<a href=#45 id=45 data-nosnippet>45</a>//! ```rust,ignore
<a href=#46 id=46 data-nosnippet>46</a>//! use num_bigint::{ToBigInt, RandBigInt};
<a href=#47 id=47 data-nosnippet>47</a>//!
<a href=#48 id=48 data-nosnippet>48</a>//! let mut rng = rand::thread_rng();
<a href=#49 id=49 data-nosnippet>49</a>//! let a = rng.gen_bigint(1000);
<a href=#50 id=50 data-nosnippet>50</a>//!
<a href=#51 id=51 data-nosnippet>51</a>//! let low = -10000.to_bigint().unwrap();
<a href=#52 id=52 data-nosnippet>52</a>//! let high = 10000.to_bigint().unwrap();
<a href=#53 id=53 data-nosnippet>53</a>//! let b = rng.gen_bigint_range(&amp;low, &amp;high);
<a href=#54 id=54 data-nosnippet>54</a>//!
<a href=#55 id=55 data-nosnippet>55</a>//! // Probably an even larger number.
<a href=#56 id=56 data-nosnippet>56</a>//! println!("{}", a * b);
<a href=#57 id=57 data-nosnippet>57</a>//! ```
<a href=#58 id=58 data-nosnippet>58</a>//!
<a href=#59 id=59 data-nosnippet>59</a>//! See the "Features" section for instructions for enabling random number generation.
<a href=#60 id=60 data-nosnippet>60</a>//!
<a href=#61 id=61 data-nosnippet>61</a>//! ## Features
<a href=#62 id=62 data-nosnippet>62</a>//!
<a href=#63 id=63 data-nosnippet>63</a>//! The `std` crate feature is enabled by default, which enables [`std::error::Error`]
<a href=#64 id=64 data-nosnippet>64</a>//! implementations and some internal use of floating point approximations. This can be disabled by
<a href=#65 id=65 data-nosnippet>65</a>//! depending on `num-bigint` with `default-features = false`. Either way, the `alloc` crate is
<a href=#66 id=66 data-nosnippet>66</a>//! always required for heap allocation of the `BigInt`/`BigUint` digits.
<a href=#67 id=67 data-nosnippet>67</a>//!
<a href=#68 id=68 data-nosnippet>68</a>//! ### Random Generation
<a href=#69 id=69 data-nosnippet>69</a>//!
<a href=#70 id=70 data-nosnippet>70</a>//! `num-bigint` supports the generation of random big integers when the `rand`
<a href=#71 id=71 data-nosnippet>71</a>//! feature is enabled. To enable it include rand as
<a href=#72 id=72 data-nosnippet>72</a>//!
<a href=#73 id=73 data-nosnippet>73</a>//! ```toml
<a href=#74 id=74 data-nosnippet>74</a>//! rand = "0.8"
<a href=#75 id=75 data-nosnippet>75</a>//! num-bigint = { version = "0.4", features = ["rand"] }
<a href=#76 id=76 data-nosnippet>76</a>//! ```
<a href=#77 id=77 data-nosnippet>77</a>//!
<a href=#78 id=78 data-nosnippet>78</a>//! Note that you must use the version of `rand` that `num-bigint` is compatible
<a href=#79 id=79 data-nosnippet>79</a>//! with: `0.8`.
<a href=#80 id=80 data-nosnippet>80</a>//!
<a href=#81 id=81 data-nosnippet>81</a>//! ### Arbitrary Big Integers
<a href=#82 id=82 data-nosnippet>82</a>//!
<a href=#83 id=83 data-nosnippet>83</a>//! `num-bigint` supports `arbitrary` and `quickcheck` features to implement
<a href=#84 id=84 data-nosnippet>84</a>//! [`arbitrary::Arbitrary`] and [`quickcheck::Arbitrary`], respectively, for both `BigInt` and
<a href=#85 id=85 data-nosnippet>85</a>//! `BigUint`. These are useful for fuzzing and other forms of randomized testing.
<a href=#86 id=86 data-nosnippet>86</a>//!
<a href=#87 id=87 data-nosnippet>87</a>//! ### Serialization
<a href=#88 id=88 data-nosnippet>88</a>//!
<a href=#89 id=89 data-nosnippet>89</a>//! The `serde` feature adds implementations of [`Serialize`][serde::Serialize] and
<a href=#90 id=90 data-nosnippet>90</a>//! [`Deserialize`][serde::Deserialize] for both `BigInt` and `BigUint`. Their serialized data is
<a href=#91 id=91 data-nosnippet>91</a>//! generated portably, regardless of platform differences like the internal digit size.
<a href=#92 id=92 data-nosnippet>92</a>//!
<a href=#93 id=93 data-nosnippet>93</a>//!
<a href=#94 id=94 data-nosnippet>94</a>//! ## Compatibility
<a href=#95 id=95 data-nosnippet>95</a>//!
<a href=#96 id=96 data-nosnippet>96</a>//! The `num-bigint` crate is tested for rustc 1.60 and greater.
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a></span><span class="attr">#![cfg_attr(docsrs, feature(doc_cfg))]
<a href=#99 id=99 data-nosnippet>99</a>#![doc(html_root_url = <span class="string">"https://docs.rs/num-bigint/0.4"</span>)]
<a href=#100 id=100 data-nosnippet>100</a>#![warn(rust_2018_idioms)]
<a href=#101 id=101 data-nosnippet>101</a>#![no_std]
<a href=#102 id=102 data-nosnippet>102</a>
<a href=#103 id=103 data-nosnippet>103</a>#[macro_use]
<a href=#104 id=104 data-nosnippet>104</a></span><span class="kw">extern crate </span>alloc;
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#107 id=107 data-nosnippet>107</a></span><span class="kw">extern crate </span>std;
<a href=#108 id=108 data-nosnippet>108</a>
<a href=#109 id=109 data-nosnippet>109</a><span class="kw">use </span>core::fmt;
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a><span class="attr">#[macro_use]
<a href=#112 id=112 data-nosnippet>112</a></span><span class="kw">mod </span>macros;
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a><span class="kw">mod </span>bigint;
<a href=#115 id=115 data-nosnippet>115</a><span class="kw">mod </span>bigrand;
<a href=#116 id=116 data-nosnippet>116</a><span class="kw">mod </span>biguint;
<a href=#117 id=117 data-nosnippet>117</a>
<a href=#118 id=118 data-nosnippet>118</a><span class="attr">#[cfg(target_pointer_width = <span class="string">"32"</span>)]
<a href=#119 id=119 data-nosnippet>119</a></span><span class="kw">type </span>UsizePromotion = u32;
<a href=#120 id=120 data-nosnippet>120</a><span class="attr">#[cfg(target_pointer_width = <span class="string">"64"</span>)]
<a href=#121 id=121 data-nosnippet>121</a></span><span class="kw">type </span>UsizePromotion = u64;
<a href=#122 id=122 data-nosnippet>122</a>
<a href=#123 id=123 data-nosnippet>123</a><span class="attr">#[cfg(target_pointer_width = <span class="string">"32"</span>)]
<a href=#124 id=124 data-nosnippet>124</a></span><span class="kw">type </span>IsizePromotion = i32;
<a href=#125 id=125 data-nosnippet>125</a><span class="attr">#[cfg(target_pointer_width = <span class="string">"64"</span>)]
<a href=#126 id=126 data-nosnippet>126</a></span><span class="kw">type </span>IsizePromotion = i64;
<a href=#127 id=127 data-nosnippet>127</a>
<a href=#128 id=128 data-nosnippet>128</a><span class="attr">#[derive(Debug, Clone, PartialEq, Eq)]
<a href=#129 id=129 data-nosnippet>129</a></span><span class="kw">pub struct </span>ParseBigIntError {
<a href=#130 id=130 data-nosnippet>130</a> kind: BigIntErrorKind,
<a href=#131 id=131 data-nosnippet>131</a>}
<a href=#132 id=132 data-nosnippet>132</a>
<a href=#133 id=133 data-nosnippet>133</a><span class="attr">#[derive(Debug, Clone, PartialEq, Eq)]
<a href=#134 id=134 data-nosnippet>134</a></span><span class="kw">enum </span>BigIntErrorKind {
<a href=#135 id=135 data-nosnippet>135</a> Empty,
<a href=#136 id=136 data-nosnippet>136</a> InvalidDigit,
<a href=#137 id=137 data-nosnippet>137</a>}
<a href=#138 id=138 data-nosnippet>138</a>
<a href=#139 id=139 data-nosnippet>139</a><span class="kw">impl </span>ParseBigIntError {
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">fn </span>__description(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">use </span><span class="kw">crate</span>::BigIntErrorKind::<span class="kw-2">*</span>;
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">match </span><span class="self">self</span>.kind {
<a href=#143 id=143 data-nosnippet>143</a> Empty =&gt; <span class="string">"cannot parse integer from empty string"</span>,
<a href=#144 id=144 data-nosnippet>144</a> InvalidDigit =&gt; <span class="string">"invalid digit found in string"</span>,
<a href=#145 id=145 data-nosnippet>145</a> }
<a href=#146 id=146 data-nosnippet>146</a> }
<a href=#147 id=147 data-nosnippet>147</a>
<a href=#148 id=148 data-nosnippet>148</a> <span class="kw">fn </span>empty() -&gt; <span class="self">Self </span>{
<a href=#149 id=149 data-nosnippet>149</a> ParseBigIntError {
<a href=#150 id=150 data-nosnippet>150</a> kind: BigIntErrorKind::Empty,
<a href=#151 id=151 data-nosnippet>151</a> }
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a>
<a href=#154 id=154 data-nosnippet>154</a> <span class="kw">fn </span>invalid() -&gt; <span class="self">Self </span>{
<a href=#155 id=155 data-nosnippet>155</a> ParseBigIntError {
<a href=#156 id=156 data-nosnippet>156</a> kind: BigIntErrorKind::InvalidDigit,
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a> }
<a href=#159 id=159 data-nosnippet>159</a>}
<a href=#160 id=160 data-nosnippet>160</a>
<a href=#161 id=161 data-nosnippet>161</a><span class="kw">impl </span>fmt::Display <span class="kw">for </span>ParseBigIntError {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter&lt;<span class="lifetime">'_</span>&gt;) -&gt; fmt::Result {
<a href=#163 id=163 data-nosnippet>163</a> <span class="self">self</span>.__description().fmt(f)
<a href=#164 id=164 data-nosnippet>164</a> }
<a href=#165 id=165 data-nosnippet>165</a>}
<a href=#166 id=166 data-nosnippet>166</a>
<a href=#167 id=167 data-nosnippet>167</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#168 id=168 data-nosnippet>168</a>#[cfg_attr(docsrs, doc(cfg(feature = <span class="string">"std"</span>)))]
<a href=#169 id=169 data-nosnippet>169</a></span><span class="kw">impl </span>std::error::Error <span class="kw">for </span>ParseBigIntError {
<a href=#170 id=170 data-nosnippet>170</a> <span class="kw">fn </span>description(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<a href=#171 id=171 data-nosnippet>171</a> <span class="self">self</span>.__description()
<a href=#172 id=172 data-nosnippet>172</a> }
<a href=#173 id=173 data-nosnippet>173</a>}
<a href=#174 id=174 data-nosnippet>174</a>
<a href=#175 id=175 data-nosnippet>175</a><span class="doccomment">/// The error type returned when a checked conversion regarding big integer fails.
<a href=#176 id=176 data-nosnippet>176</a></span><span class="attr">#[derive(Debug, Copy, Clone, PartialEq, Eq)]
<a href=#177 id=177 data-nosnippet>177</a></span><span class="kw">pub struct </span>TryFromBigIntError&lt;T&gt; {
<a href=#178 id=178 data-nosnippet>178</a> original: T,
<a href=#179 id=179 data-nosnippet>179</a>}
<a href=#180 id=180 data-nosnippet>180</a>
<a href=#181 id=181 data-nosnippet>181</a><span class="kw">impl</span>&lt;T&gt; TryFromBigIntError&lt;T&gt; {
<a href=#182 id=182 data-nosnippet>182</a> <span class="kw">fn </span>new(original: T) -&gt; <span class="self">Self </span>{
<a href=#183 id=183 data-nosnippet>183</a> TryFromBigIntError { original }
<a href=#184 id=184 data-nosnippet>184</a> }
<a href=#185 id=185 data-nosnippet>185</a>
<a href=#186 id=186 data-nosnippet>186</a> <span class="kw">fn </span>__description(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<a href=#187 id=187 data-nosnippet>187</a> <span class="string">"out of range conversion regarding big integer attempted"
<a href=#188 id=188 data-nosnippet>188</a> </span>}
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a> <span class="doccomment">/// Extract the original value, if available. The value will be available
<a href=#191 id=191 data-nosnippet>191</a> /// if the type before conversion was either [`BigInt`] or [`BigUint`].
<a href=#192 id=192 data-nosnippet>192</a> </span><span class="kw">pub fn </span>into_original(<span class="self">self</span>) -&gt; T {
<a href=#193 id=193 data-nosnippet>193</a> <span class="self">self</span>.original
<a href=#194 id=194 data-nosnippet>194</a> }
<a href=#195 id=195 data-nosnippet>195</a>}
<a href=#196 id=196 data-nosnippet>196</a>
<a href=#197 id=197 data-nosnippet>197</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#198 id=198 data-nosnippet>198</a>#[cfg_attr(docsrs, doc(cfg(feature = <span class="string">"std"</span>)))]
<a href=#199 id=199 data-nosnippet>199</a></span><span class="kw">impl</span>&lt;T&gt; std::error::Error <span class="kw">for </span>TryFromBigIntError&lt;T&gt;
<a href=#200 id=200 data-nosnippet>200</a><span class="kw">where
<a href=#201 id=201 data-nosnippet>201</a> </span>T: fmt::Debug,
<a href=#202 id=202 data-nosnippet>202</a>{
<a href=#203 id=203 data-nosnippet>203</a> <span class="kw">fn </span>description(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<a href=#204 id=204 data-nosnippet>204</a> <span class="self">self</span>.__description()
<a href=#205 id=205 data-nosnippet>205</a> }
<a href=#206 id=206 data-nosnippet>206</a>}
<a href=#207 id=207 data-nosnippet>207</a>
<a href=#208 id=208 data-nosnippet>208</a><span class="kw">impl</span>&lt;T&gt; fmt::Display <span class="kw">for </span>TryFromBigIntError&lt;T&gt; {
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter&lt;<span class="lifetime">'_</span>&gt;) -&gt; fmt::Result {
<a href=#210 id=210 data-nosnippet>210</a> <span class="self">self</span>.__description().fmt(f)
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a>}
<a href=#213 id=213 data-nosnippet>213</a>
<a href=#214 id=214 data-nosnippet>214</a><span class="kw">pub use </span><span class="kw">crate</span>::biguint::BigUint;
<a href=#215 id=215 data-nosnippet>215</a><span class="kw">pub use </span><span class="kw">crate</span>::biguint::ToBigUint;
<a href=#216 id=216 data-nosnippet>216</a><span class="kw">pub use </span><span class="kw">crate</span>::biguint::U32Digits;
<a href=#217 id=217 data-nosnippet>217</a><span class="kw">pub use </span><span class="kw">crate</span>::biguint::U64Digits;
<a href=#218 id=218 data-nosnippet>218</a>
<a href=#219 id=219 data-nosnippet>219</a><span class="kw">pub use </span><span class="kw">crate</span>::bigint::BigInt;
<a href=#220 id=220 data-nosnippet>220</a><span class="kw">pub use </span><span class="kw">crate</span>::bigint::Sign;
<a href=#221 id=221 data-nosnippet>221</a><span class="kw">pub use </span><span class="kw">crate</span>::bigint::ToBigInt;
<a href=#222 id=222 data-nosnippet>222</a>
<a href=#223 id=223 data-nosnippet>223</a><span class="attr">#[cfg(feature = <span class="string">"rand"</span>)]
<a href=#224 id=224 data-nosnippet>224</a>#[cfg_attr(docsrs, doc(cfg(feature = <span class="string">"rand"</span>)))]
<a href=#225 id=225 data-nosnippet>225</a></span><span class="kw">pub use </span><span class="kw">crate</span>::bigrand::{RandBigInt, RandomBits, UniformBigInt, UniformBigUint};
<a href=#226 id=226 data-nosnippet>226</a>
<a href=#227 id=227 data-nosnippet>227</a><span class="kw">mod </span>big_digit {
<a href=#228 id=228 data-nosnippet>228</a> <span class="comment">// A [`BigDigit`] is a [`BigUint`]'s composing element.
<a href=#229 id=229 data-nosnippet>229</a> </span><span class="macro">cfg_digit!</span>(
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">type </span>BigDigit = u32;
<a href=#231 id=231 data-nosnippet>231</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">type </span>BigDigit = u64;
<a href=#232 id=232 data-nosnippet>232</a> );
<a href=#233 id=233 data-nosnippet>233</a>
<a href=#234 id=234 data-nosnippet>234</a> <span class="comment">// A [`DoubleBigDigit`] is the internal type used to do the computations. Its
<a href=#235 id=235 data-nosnippet>235</a> // size is the double of the size of [`BigDigit`].
<a href=#236 id=236 data-nosnippet>236</a> </span><span class="macro">cfg_digit!</span>(
<a href=#237 id=237 data-nosnippet>237</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">type </span>DoubleBigDigit = u64;
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">type </span>DoubleBigDigit = u128;
<a href=#239 id=239 data-nosnippet>239</a> );
<a href=#240 id=240 data-nosnippet>240</a>
<a href=#241 id=241 data-nosnippet>241</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">const </span>BITS: u8 = BigDigit::BITS <span class="kw">as </span>u8;
<a href=#242 id=242 data-nosnippet>242</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">const </span>HALF_BITS: u8 = BITS / <span class="number">2</span>;
<a href=#243 id=243 data-nosnippet>243</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">const </span>HALF: BigDigit = (<span class="number">1 </span>&lt;&lt; HALF_BITS) - <span class="number">1</span>;
<a href=#244 id=244 data-nosnippet>244</a>
<a href=#245 id=245 data-nosnippet>245</a> <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">const </span>MAX: BigDigit = BigDigit::MAX;
<a href=#246 id=246 data-nosnippet>246</a> <span class="kw">const </span>LO_MASK: DoubleBigDigit = MAX <span class="kw">as </span>DoubleBigDigit;
<a href=#247 id=247 data-nosnippet>247</a>
<a href=#248 id=248 data-nosnippet>248</a> <span class="attr">#[inline]
<a href=#249 id=249 data-nosnippet>249</a> </span><span class="kw">fn </span>get_hi(n: DoubleBigDigit) -&gt; BigDigit {
<a href=#250 id=250 data-nosnippet>250</a> (n &gt;&gt; BITS) <span class="kw">as </span>BigDigit
<a href=#251 id=251 data-nosnippet>251</a> }
<a href=#252 id=252 data-nosnippet>252</a> <span class="attr">#[inline]
<a href=#253 id=253 data-nosnippet>253</a> </span><span class="kw">fn </span>get_lo(n: DoubleBigDigit) -&gt; BigDigit {
<a href=#254 id=254 data-nosnippet>254</a> (n &amp; LO_MASK) <span class="kw">as </span>BigDigit
<a href=#255 id=255 data-nosnippet>255</a> }
<a href=#256 id=256 data-nosnippet>256</a>
<a href=#257 id=257 data-nosnippet>257</a> <span class="doccomment">/// Split one [`DoubleBigDigit`] into two [`BigDigit`]s.
<a href=#258 id=258 data-nosnippet>258</a> </span><span class="attr">#[inline]
<a href=#259 id=259 data-nosnippet>259</a> </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>from_doublebigdigit(n: DoubleBigDigit) -&gt; (BigDigit, BigDigit) {
<a href=#260 id=260 data-nosnippet>260</a> (get_hi(n), get_lo(n))
<a href=#261 id=261 data-nosnippet>261</a> }
<a href=#262 id=262 data-nosnippet>262</a>
<a href=#263 id=263 data-nosnippet>263</a> <span class="doccomment">/// Join two [`BigDigit`]s into one [`DoubleBigDigit`].
<a href=#264 id=264 data-nosnippet>264</a> </span><span class="attr">#[inline]
<a href=#265 id=265 data-nosnippet>265</a> </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>to_doublebigdigit(hi: BigDigit, lo: BigDigit) -&gt; DoubleBigDigit {
<a href=#266 id=266 data-nosnippet>266</a> DoubleBigDigit::from(lo) | (DoubleBigDigit::from(hi) &lt;&lt; BITS)
<a href=#267 id=267 data-nosnippet>267</a> }
<a href=#268 id=268 data-nosnippet>268</a>}
</code></pre></div></section></main></body></html>
+474
View File
@@ -0,0 +1,474 @@
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/macros.rs`."><title>macros.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="num_bigint" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">num_bigint/</div>macros.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="attr">#![allow(unused_macros)]
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="macro">macro_rules!</span> cfg_32 {
<a href=#4 id=4 data-nosnippet>4</a> ($(<span class="macro-nonterminal">$any</span>:tt)+) =&gt; {
<a href=#5 id=5 data-nosnippet>5</a> <span class="attr">#[cfg(not(target_pointer_width = <span class="string">"64"</span>))] </span>$(<span class="macro-nonterminal">$any</span>)+
<a href=#6 id=6 data-nosnippet>6</a> }
<a href=#7 id=7 data-nosnippet>7</a>}
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="macro">macro_rules!</span> cfg_32_or_test {
<a href=#10 id=10 data-nosnippet>10</a> ($(<span class="macro-nonterminal">$any</span>:tt)+) =&gt; {
<a href=#11 id=11 data-nosnippet>11</a> <span class="attr">#[cfg(any(not(target_pointer_width = <span class="string">"64"</span>), test))] </span>$(<span class="macro-nonterminal">$any</span>)+
<a href=#12 id=12 data-nosnippet>12</a> }
<a href=#13 id=13 data-nosnippet>13</a>}
<a href=#14 id=14 data-nosnippet>14</a>
<a href=#15 id=15 data-nosnippet>15</a><span class="macro">macro_rules!</span> cfg_64 {
<a href=#16 id=16 data-nosnippet>16</a> ($(<span class="macro-nonterminal">$any</span>:tt)+) =&gt; {
<a href=#17 id=17 data-nosnippet>17</a> <span class="attr">#[cfg(target_pointer_width = <span class="string">"64"</span>)] </span>$(<span class="macro-nonterminal">$any</span>)+
<a href=#18 id=18 data-nosnippet>18</a> }
<a href=#19 id=19 data-nosnippet>19</a>}
<a href=#20 id=20 data-nosnippet>20</a>
<a href=#21 id=21 data-nosnippet>21</a><span class="macro">macro_rules!</span> cfg_digit {
<a href=#22 id=22 data-nosnippet>22</a> (<span class="macro-nonterminal">$item32</span>:item <span class="macro-nonterminal">$item64</span>:item) =&gt; {
<a href=#23 id=23 data-nosnippet>23</a> <span class="macro">cfg_32!</span>(<span class="macro-nonterminal">$item32</span>);
<a href=#24 id=24 data-nosnippet>24</a> <span class="macro">cfg_64!</span>(<span class="macro-nonterminal">$item64</span>);
<a href=#25 id=25 data-nosnippet>25</a> };
<a href=#26 id=26 data-nosnippet>26</a>}
<a href=#27 id=27 data-nosnippet>27</a>
<a href=#28 id=28 data-nosnippet>28</a><span class="macro">macro_rules!</span> cfg_digit_expr {
<a href=#29 id=29 data-nosnippet>29</a> (<span class="macro-nonterminal">$expr32</span>:expr, <span class="macro-nonterminal">$expr64</span>:expr) =&gt; {
<a href=#30 id=30 data-nosnippet>30</a> <span class="macro">cfg_32!</span>(<span class="macro-nonterminal">$expr32</span>);
<a href=#31 id=31 data-nosnippet>31</a> <span class="macro">cfg_64!</span>(<span class="macro-nonterminal">$expr64</span>);
<a href=#32 id=32 data-nosnippet>32</a> };
<a href=#33 id=33 data-nosnippet>33</a>}
<a href=#34 id=34 data-nosnippet>34</a>
<a href=#35 id=35 data-nosnippet>35</a><span class="macro">macro_rules!</span> forward_val_val_binop {
<a href=#36 id=36 data-nosnippet>36</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#37 id=37 data-nosnippet>37</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#39 id=39 data-nosnippet>39</a>
<a href=#40 id=40 data-nosnippet>40</a> <span class="attr">#[inline]
<a href=#41 id=41 data-nosnippet>41</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#42 id=42 data-nosnippet>42</a> <span class="comment">// forward to val-ref
<a href=#43 id=43 data-nosnippet>43</a> </span><span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">&amp;</span>other)
<a href=#44 id=44 data-nosnippet>44</a> }
<a href=#45 id=45 data-nosnippet>45</a> }
<a href=#46 id=46 data-nosnippet>46</a> };
<a href=#47 id=47 data-nosnippet>47</a>}
<a href=#48 id=48 data-nosnippet>48</a>
<a href=#49 id=49 data-nosnippet>49</a><span class="macro">macro_rules!</span> forward_val_val_binop_commutative {
<a href=#50 id=50 data-nosnippet>50</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#51 id=51 data-nosnippet>51</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#53 id=53 data-nosnippet>53</a>
<a href=#54 id=54 data-nosnippet>54</a> <span class="attr">#[inline]
<a href=#55 id=55 data-nosnippet>55</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#56 id=56 data-nosnippet>56</a> <span class="comment">// forward to val-ref, with the larger capacity as val
<a href=#57 id=57 data-nosnippet>57</a> </span><span class="kw">if </span><span class="self">self</span>.capacity() &gt;= other.capacity() {
<a href=#58 id=58 data-nosnippet>58</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">&amp;</span>other)
<a href=#59 id=59 data-nosnippet>59</a> } <span class="kw">else </span>{
<a href=#60 id=60 data-nosnippet>60</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(other, <span class="kw-2">&amp;</span><span class="self">self</span>)
<a href=#61 id=61 data-nosnippet>61</a> }
<a href=#62 id=62 data-nosnippet>62</a> }
<a href=#63 id=63 data-nosnippet>63</a> }
<a href=#64 id=64 data-nosnippet>64</a> };
<a href=#65 id=65 data-nosnippet>65</a>}
<a href=#66 id=66 data-nosnippet>66</a>
<a href=#67 id=67 data-nosnippet>67</a><span class="macro">macro_rules!</span> forward_ref_val_binop {
<a href=#68 id=68 data-nosnippet>68</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#71 id=71 data-nosnippet>71</a>
<a href=#72 id=72 data-nosnippet>72</a> <span class="attr">#[inline]
<a href=#73 id=73 data-nosnippet>73</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#74 id=74 data-nosnippet>74</a> <span class="comment">// forward to ref-ref
<a href=#75 id=75 data-nosnippet>75</a> </span><span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">&amp;</span>other)
<a href=#76 id=76 data-nosnippet>76</a> }
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a> };
<a href=#79 id=79 data-nosnippet>79</a>}
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a><span class="macro">macro_rules!</span> forward_ref_val_binop_commutative {
<a href=#82 id=82 data-nosnippet>82</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#85 id=85 data-nosnippet>85</a>
<a href=#86 id=86 data-nosnippet>86</a> <span class="attr">#[inline]
<a href=#87 id=87 data-nosnippet>87</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#88 id=88 data-nosnippet>88</a> <span class="comment">// reverse, forward to val-ref
<a href=#89 id=89 data-nosnippet>89</a> </span><span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(other, <span class="self">self</span>)
<a href=#90 id=90 data-nosnippet>90</a> }
<a href=#91 id=91 data-nosnippet>91</a> }
<a href=#92 id=92 data-nosnippet>92</a> };
<a href=#93 id=93 data-nosnippet>93</a>}
<a href=#94 id=94 data-nosnippet>94</a>
<a href=#95 id=95 data-nosnippet>95</a><span class="macro">macro_rules!</span> forward_val_ref_binop {
<a href=#96 id=96 data-nosnippet>96</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#98 id=98 data-nosnippet>98</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#99 id=99 data-nosnippet>99</a>
<a href=#100 id=100 data-nosnippet>100</a> <span class="attr">#[inline]
<a href=#101 id=101 data-nosnippet>101</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#102 id=102 data-nosnippet>102</a> <span class="comment">// forward to ref-ref
<a href=#103 id=103 data-nosnippet>103</a> </span><span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, other)
<a href=#104 id=104 data-nosnippet>104</a> }
<a href=#105 id=105 data-nosnippet>105</a> }
<a href=#106 id=106 data-nosnippet>106</a> };
<a href=#107 id=107 data-nosnippet>107</a>}
<a href=#108 id=108 data-nosnippet>108</a>
<a href=#109 id=109 data-nosnippet>109</a><span class="macro">macro_rules!</span> forward_ref_ref_binop {
<a href=#110 id=110 data-nosnippet>110</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a> <span class="attr">#[inline]
<a href=#115 id=115 data-nosnippet>115</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#116 id=116 data-nosnippet>116</a> <span class="comment">// forward to val-ref
<a href=#117 id=117 data-nosnippet>117</a> </span><span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>.clone(), other)
<a href=#118 id=118 data-nosnippet>118</a> }
<a href=#119 id=119 data-nosnippet>119</a> }
<a href=#120 id=120 data-nosnippet>120</a> };
<a href=#121 id=121 data-nosnippet>121</a>}
<a href=#122 id=122 data-nosnippet>122</a>
<a href=#123 id=123 data-nosnippet>123</a><span class="macro">macro_rules!</span> forward_ref_ref_binop_commutative {
<a href=#124 id=124 data-nosnippet>124</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#126 id=126 data-nosnippet>126</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#127 id=127 data-nosnippet>127</a>
<a href=#128 id=128 data-nosnippet>128</a> <span class="attr">#[inline]
<a href=#129 id=129 data-nosnippet>129</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#130 id=130 data-nosnippet>130</a> <span class="comment">// forward to val-ref, choosing the larger to clone
<a href=#131 id=131 data-nosnippet>131</a> </span><span class="kw">if </span><span class="self">self</span>.len() &gt;= other.len() {
<a href=#132 id=132 data-nosnippet>132</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>.clone(), other)
<a href=#133 id=133 data-nosnippet>133</a> } <span class="kw">else </span>{
<a href=#134 id=134 data-nosnippet>134</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(other.clone(), <span class="self">self</span>)
<a href=#135 id=135 data-nosnippet>135</a> }
<a href=#136 id=136 data-nosnippet>136</a> }
<a href=#137 id=137 data-nosnippet>137</a> }
<a href=#138 id=138 data-nosnippet>138</a> };
<a href=#139 id=139 data-nosnippet>139</a>}
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a><span class="macro">macro_rules!</span> forward_val_assign {
<a href=#142 id=142 data-nosnippet>142</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#143 id=143 data-nosnippet>143</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#144 id=144 data-nosnippet>144</a> <span class="attr">#[inline]
<a href=#145 id=145 data-nosnippet>145</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) {
<a href=#146 id=146 data-nosnippet>146</a> <span class="self">self</span>.<span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;</span>other);
<a href=#147 id=147 data-nosnippet>147</a> }
<a href=#148 id=148 data-nosnippet>148</a> }
<a href=#149 id=149 data-nosnippet>149</a> };
<a href=#150 id=150 data-nosnippet>150</a>}
<a href=#151 id=151 data-nosnippet>151</a>
<a href=#152 id=152 data-nosnippet>152</a><span class="macro">macro_rules!</span> forward_val_assign_scalar {
<a href=#153 id=153 data-nosnippet>153</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$scalar</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#154 id=154 data-nosnippet>154</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#155 id=155 data-nosnippet>155</a> <span class="attr">#[inline]
<a href=#156 id=156 data-nosnippet>156</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) {
<a href=#157 id=157 data-nosnippet>157</a> <span class="self">self</span>.<span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;</span>other);
<a href=#158 id=158 data-nosnippet>158</a> }
<a href=#159 id=159 data-nosnippet>159</a> }
<a href=#160 id=160 data-nosnippet>160</a> };
<a href=#161 id=161 data-nosnippet>161</a>}
<a href=#162 id=162 data-nosnippet>162</a>
<a href=#163 id=163 data-nosnippet>163</a><span class="doccomment">/// use this if val_val_binop is already implemented and the reversed order is required
<a href=#164 id=164 data-nosnippet>164</a></span><span class="macro">macro_rules!</span> forward_scalar_val_val_binop_commutative {
<a href=#165 id=165 data-nosnippet>165</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident &lt; <span class="macro-nonterminal">$scalar</span>:ty &gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#167 id=167 data-nosnippet>167</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a> <span class="attr">#[inline]
<a href=#170 id=170 data-nosnippet>170</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#171 id=171 data-nosnippet>171</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(other, <span class="self">self</span>)
<a href=#172 id=172 data-nosnippet>172</a> }
<a href=#173 id=173 data-nosnippet>173</a> }
<a href=#174 id=174 data-nosnippet>174</a> };
<a href=#175 id=175 data-nosnippet>175</a>}
<a href=#176 id=176 data-nosnippet>176</a>
<a href=#177 id=177 data-nosnippet>177</a><span class="comment">// Forward scalar to ref-val, when reusing storage is not helpful
<a href=#178 id=178 data-nosnippet>178</a></span><span class="macro">macro_rules!</span> forward_scalar_val_val_binop_to_ref_val {
<a href=#179 id=179 data-nosnippet>179</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#180 id=180 data-nosnippet>180</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#181 id=181 data-nosnippet>181</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#182 id=182 data-nosnippet>182</a>
<a href=#183 id=183 data-nosnippet>183</a> <span class="attr">#[inline]
<a href=#184 id=184 data-nosnippet>184</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#185 id=185 data-nosnippet>185</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, other)
<a href=#186 id=186 data-nosnippet>186</a> }
<a href=#187 id=187 data-nosnippet>187</a> }
<a href=#188 id=188 data-nosnippet>188</a>
<a href=#189 id=189 data-nosnippet>189</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#190 id=190 data-nosnippet>190</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#191 id=191 data-nosnippet>191</a>
<a href=#192 id=192 data-nosnippet>192</a> <span class="attr">#[inline]
<a href=#193 id=193 data-nosnippet>193</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#194 id=194 data-nosnippet>194</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">&amp;</span>other)
<a href=#195 id=195 data-nosnippet>195</a> }
<a href=#196 id=196 data-nosnippet>196</a> }
<a href=#197 id=197 data-nosnippet>197</a> };
<a href=#198 id=198 data-nosnippet>198</a>}
<a href=#199 id=199 data-nosnippet>199</a>
<a href=#200 id=200 data-nosnippet>200</a><span class="macro">macro_rules!</span> forward_scalar_ref_ref_binop_to_ref_val {
<a href=#201 id=201 data-nosnippet>201</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#202 id=202 data-nosnippet>202</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#203 id=203 data-nosnippet>203</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#204 id=204 data-nosnippet>204</a>
<a href=#205 id=205 data-nosnippet>205</a> <span class="attr">#[inline]
<a href=#206 id=206 data-nosnippet>206</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#207 id=207 data-nosnippet>207</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">*</span>other)
<a href=#208 id=208 data-nosnippet>208</a> }
<a href=#209 id=209 data-nosnippet>209</a> }
<a href=#210 id=210 data-nosnippet>210</a>
<a href=#211 id=211 data-nosnippet>211</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar </span>{
<a href=#212 id=212 data-nosnippet>212</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#213 id=213 data-nosnippet>213</a>
<a href=#214 id=214 data-nosnippet>214</a> <span class="attr">#[inline]
<a href=#215 id=215 data-nosnippet>215</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#216 id=216 data-nosnippet>216</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">*</span><span class="self">self</span>, other)
<a href=#217 id=217 data-nosnippet>217</a> }
<a href=#218 id=218 data-nosnippet>218</a> }
<a href=#219 id=219 data-nosnippet>219</a> };
<a href=#220 id=220 data-nosnippet>220</a>}
<a href=#221 id=221 data-nosnippet>221</a>
<a href=#222 id=222 data-nosnippet>222</a><span class="macro">macro_rules!</span> forward_scalar_val_ref_binop_to_ref_val {
<a href=#223 id=223 data-nosnippet>223</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#224 id=224 data-nosnippet>224</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#225 id=225 data-nosnippet>225</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#226 id=226 data-nosnippet>226</a>
<a href=#227 id=227 data-nosnippet>227</a> <span class="attr">#[inline]
<a href=#228 id=228 data-nosnippet>228</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#229 id=229 data-nosnippet>229</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="kw-2">*</span>other)
<a href=#230 id=230 data-nosnippet>230</a> }
<a href=#231 id=231 data-nosnippet>231</a> }
<a href=#232 id=232 data-nosnippet>232</a>
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar </span>{
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#235 id=235 data-nosnippet>235</a>
<a href=#236 id=236 data-nosnippet>236</a> <span class="attr">#[inline]
<a href=#237 id=237 data-nosnippet>237</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#238 id=238 data-nosnippet>238</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">*</span><span class="self">self</span>, <span class="kw-2">&amp;</span>other)
<a href=#239 id=239 data-nosnippet>239</a> }
<a href=#240 id=240 data-nosnippet>240</a> }
<a href=#241 id=241 data-nosnippet>241</a> };
<a href=#242 id=242 data-nosnippet>242</a>}
<a href=#243 id=243 data-nosnippet>243</a>
<a href=#244 id=244 data-nosnippet>244</a><span class="macro">macro_rules!</span> forward_scalar_val_ref_binop_to_val_val {
<a href=#245 id=245 data-nosnippet>245</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#246 id=246 data-nosnippet>246</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#247 id=247 data-nosnippet>247</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#248 id=248 data-nosnippet>248</a>
<a href=#249 id=249 data-nosnippet>249</a> <span class="attr">#[inline]
<a href=#250 id=250 data-nosnippet>250</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#251 id=251 data-nosnippet>251</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, <span class="kw-2">*</span>other)
<a href=#252 id=252 data-nosnippet>252</a> }
<a href=#253 id=253 data-nosnippet>253</a> }
<a href=#254 id=254 data-nosnippet>254</a>
<a href=#255 id=255 data-nosnippet>255</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar </span>{
<a href=#256 id=256 data-nosnippet>256</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#257 id=257 data-nosnippet>257</a>
<a href=#258 id=258 data-nosnippet>258</a> <span class="attr">#[inline]
<a href=#259 id=259 data-nosnippet>259</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#260 id=260 data-nosnippet>260</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">*</span><span class="self">self</span>, other)
<a href=#261 id=261 data-nosnippet>261</a> }
<a href=#262 id=262 data-nosnippet>262</a> }
<a href=#263 id=263 data-nosnippet>263</a> };
<a href=#264 id=264 data-nosnippet>264</a>}
<a href=#265 id=265 data-nosnippet>265</a>
<a href=#266 id=266 data-nosnippet>266</a><span class="macro">macro_rules!</span> forward_scalar_ref_val_binop_to_val_val {
<a href=#267 id=267 data-nosnippet>267</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident &lt; <span class="macro-nonterminal">$scalar</span>:ty &gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#268 id=268 data-nosnippet>268</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#269 id=269 data-nosnippet>269</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#270 id=270 data-nosnippet>270</a>
<a href=#271 id=271 data-nosnippet>271</a> <span class="attr">#[inline]
<a href=#272 id=272 data-nosnippet>272</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#273 id=273 data-nosnippet>273</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>.clone(), other)
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a> }
<a href=#276 id=276 data-nosnippet>276</a>
<a href=#277 id=277 data-nosnippet>277</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#278 id=278 data-nosnippet>278</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#279 id=279 data-nosnippet>279</a>
<a href=#280 id=280 data-nosnippet>280</a> <span class="attr">#[inline]
<a href=#281 id=281 data-nosnippet>281</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#282 id=282 data-nosnippet>282</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other.clone())
<a href=#283 id=283 data-nosnippet>283</a> }
<a href=#284 id=284 data-nosnippet>284</a> }
<a href=#285 id=285 data-nosnippet>285</a> };
<a href=#286 id=286 data-nosnippet>286</a>}
<a href=#287 id=287 data-nosnippet>287</a>
<a href=#288 id=288 data-nosnippet>288</a><span class="macro">macro_rules!</span> forward_scalar_ref_ref_binop_to_val_val {
<a href=#289 id=289 data-nosnippet>289</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$res </span>{
<a href=#291 id=291 data-nosnippet>291</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#292 id=292 data-nosnippet>292</a>
<a href=#293 id=293 data-nosnippet>293</a> <span class="attr">#[inline]
<a href=#294 id=294 data-nosnippet>294</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#295 id=295 data-nosnippet>295</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>.clone(), <span class="kw-2">*</span>other)
<a href=#296 id=296 data-nosnippet>296</a> }
<a href=#297 id=297 data-nosnippet>297</a> }
<a href=#298 id=298 data-nosnippet>298</a>
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="kw-2">&amp;</span><span class="macro-nonterminal">$scalar </span>{
<a href=#300 id=300 data-nosnippet>300</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#301 id=301 data-nosnippet>301</a>
<a href=#302 id=302 data-nosnippet>302</a> <span class="attr">#[inline]
<a href=#303 id=303 data-nosnippet>303</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="kw-2">&amp;</span><span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#304 id=304 data-nosnippet>304</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="kw-2">*</span><span class="self">self</span>, other.clone())
<a href=#305 id=305 data-nosnippet>305</a> }
<a href=#306 id=306 data-nosnippet>306</a> }
<a href=#307 id=307 data-nosnippet>307</a> };
<a href=#308 id=308 data-nosnippet>308</a>}
<a href=#309 id=309 data-nosnippet>309</a>
<a href=#310 id=310 data-nosnippet>310</a><span class="macro">macro_rules!</span> promote_scalars {
<a href=#311 id=311 data-nosnippet>311</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$promo</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident, $( <span class="macro-nonterminal">$scalar</span>:ty ),<span class="kw-2">*</span>) =&gt; {
<a href=#312 id=312 data-nosnippet>312</a> $(
<a href=#313 id=313 data-nosnippet>313</a> <span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#314 id=314 data-nosnippet>314</a>
<a href=#315 id=315 data-nosnippet>315</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#316 id=316 data-nosnippet>316</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#317 id=317 data-nosnippet>317</a>
<a href=#318 id=318 data-nosnippet>318</a> <span class="attr">#[allow(clippy::cast_lossless)]
<a href=#319 id=319 data-nosnippet>319</a> #[inline]
<a href=#320 id=320 data-nosnippet>320</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$scalar</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#321 id=321 data-nosnippet>321</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other <span class="kw">as </span><span class="macro-nonterminal">$promo</span>)
<a href=#322 id=322 data-nosnippet>322</a> }
<a href=#323 id=323 data-nosnippet>323</a> }
<a href=#324 id=324 data-nosnippet>324</a>
<a href=#325 id=325 data-nosnippet>325</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$res</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$scalar </span>{
<a href=#326 id=326 data-nosnippet>326</a> <span class="kw">type </span>Output = <span class="macro-nonterminal">$res</span>;
<a href=#327 id=327 data-nosnippet>327</a>
<a href=#328 id=328 data-nosnippet>328</a> <span class="attr">#[allow(clippy::cast_lossless)]
<a href=#329 id=329 data-nosnippet>329</a> #[inline]
<a href=#330 id=330 data-nosnippet>330</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="self">self</span>, other: <span class="macro-nonterminal">$res</span>) -&gt; <span class="macro-nonterminal">$res </span>{
<a href=#331 id=331 data-nosnippet>331</a> <span class="macro-nonterminal">$imp</span>::<span class="macro-nonterminal">$method</span>(<span class="self">self </span><span class="kw">as </span><span class="macro-nonterminal">$promo</span>, other)
<a href=#332 id=332 data-nosnippet>332</a> }
<a href=#333 id=333 data-nosnippet>333</a> }
<a href=#334 id=334 data-nosnippet>334</a> )*
<a href=#335 id=335 data-nosnippet>335</a> }
<a href=#336 id=336 data-nosnippet>336</a>}
<a href=#337 id=337 data-nosnippet>337</a><span class="macro">macro_rules!</span> promote_scalars_assign {
<a href=#338 id=338 data-nosnippet>338</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$promo</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident, $( <span class="macro-nonterminal">$scalar</span>:ty ),<span class="kw-2">*</span>) =&gt; {
<a href=#339 id=339 data-nosnippet>339</a> $(
<a href=#340 id=340 data-nosnippet>340</a> <span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res </span>{
<a href=#341 id=341 data-nosnippet>341</a> <span class="attr">#[allow(clippy::cast_lossless)]
<a href=#342 id=342 data-nosnippet>342</a> #[inline]
<a href=#343 id=343 data-nosnippet>343</a> </span><span class="kw">fn </span><span class="macro-nonterminal">$method</span>(<span class="kw-2">&amp;mut </span><span class="self">self</span>, other: <span class="macro-nonterminal">$scalar</span>) {
<a href=#344 id=344 data-nosnippet>344</a> <span class="self">self</span>.<span class="macro-nonterminal">$method</span>(other <span class="kw">as </span><span class="macro-nonterminal">$promo</span>);
<a href=#345 id=345 data-nosnippet>345</a> }
<a href=#346 id=346 data-nosnippet>346</a> }
<a href=#347 id=347 data-nosnippet>347</a> )*
<a href=#348 id=348 data-nosnippet>348</a> }
<a href=#349 id=349 data-nosnippet>349</a>}
<a href=#350 id=350 data-nosnippet>350</a>
<a href=#351 id=351 data-nosnippet>351</a><span class="macro">macro_rules!</span> promote_unsigned_scalars {
<a href=#352 id=352 data-nosnippet>352</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#353 id=353 data-nosnippet>353</a> <span class="macro">promote_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;u32&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, u8, u16);
<a href=#354 id=354 data-nosnippet>354</a> <span class="macro">promote_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;UsizePromotion&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, usize);
<a href=#355 id=355 data-nosnippet>355</a> }
<a href=#356 id=356 data-nosnippet>356</a>}
<a href=#357 id=357 data-nosnippet>357</a>
<a href=#358 id=358 data-nosnippet>358</a><span class="macro">macro_rules!</span> promote_unsigned_scalars_assign {
<a href=#359 id=359 data-nosnippet>359</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#360 id=360 data-nosnippet>360</a> <span class="macro">promote_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;u32&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, u8, u16);
<a href=#361 id=361 data-nosnippet>361</a> <span class="macro">promote_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;UsizePromotion&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, usize);
<a href=#362 id=362 data-nosnippet>362</a> }
<a href=#363 id=363 data-nosnippet>363</a>}
<a href=#364 id=364 data-nosnippet>364</a>
<a href=#365 id=365 data-nosnippet>365</a><span class="macro">macro_rules!</span> promote_signed_scalars {
<a href=#366 id=366 data-nosnippet>366</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#367 id=367 data-nosnippet>367</a> <span class="macro">promote_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;i32&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, i8, i16);
<a href=#368 id=368 data-nosnippet>368</a> <span class="macro">promote_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;IsizePromotion&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, isize);
<a href=#369 id=369 data-nosnippet>369</a> }
<a href=#370 id=370 data-nosnippet>370</a>}
<a href=#371 id=371 data-nosnippet>371</a>
<a href=#372 id=372 data-nosnippet>372</a><span class="macro">macro_rules!</span> promote_signed_scalars_assign {
<a href=#373 id=373 data-nosnippet>373</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#374 id=374 data-nosnippet>374</a> <span class="macro">promote_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;i32&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, i8, i16);
<a href=#375 id=375 data-nosnippet>375</a> <span class="macro">promote_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;IsizePromotion&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>, isize);
<a href=#376 id=376 data-nosnippet>376</a> }
<a href=#377 id=377 data-nosnippet>377</a>}
<a href=#378 id=378 data-nosnippet>378</a>
<a href=#379 id=379 data-nosnippet>379</a><span class="comment">// Forward everything to ref-ref, when reusing storage is not helpful
<a href=#380 id=380 data-nosnippet>380</a></span><span class="macro">macro_rules!</span> forward_all_binop_to_ref_ref {
<a href=#381 id=381 data-nosnippet>381</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#382 id=382 data-nosnippet>382</a> <span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#383 id=383 data-nosnippet>383</a> <span class="macro">forward_val_ref_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#384 id=384 data-nosnippet>384</a> <span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#385 id=385 data-nosnippet>385</a> };
<a href=#386 id=386 data-nosnippet>386</a>}
<a href=#387 id=387 data-nosnippet>387</a>
<a href=#388 id=388 data-nosnippet>388</a><span class="comment">// Forward everything to val-ref, so LHS storage can be reused
<a href=#389 id=389 data-nosnippet>389</a></span><span class="macro">macro_rules!</span> forward_all_binop_to_val_ref {
<a href=#390 id=390 data-nosnippet>390</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#391 id=391 data-nosnippet>391</a> <span class="macro">forward_val_val_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#392 id=392 data-nosnippet>392</a> <span class="macro">forward_ref_val_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#393 id=393 data-nosnippet>393</a> <span class="macro">forward_ref_ref_binop!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#394 id=394 data-nosnippet>394</a> };
<a href=#395 id=395 data-nosnippet>395</a>}
<a href=#396 id=396 data-nosnippet>396</a>
<a href=#397 id=397 data-nosnippet>397</a><span class="comment">// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reused
<a href=#398 id=398 data-nosnippet>398</a></span><span class="macro">macro_rules!</span> forward_all_binop_to_val_ref_commutative {
<a href=#399 id=399 data-nosnippet>399</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#400 id=400 data-nosnippet>400</a> <span class="macro">forward_val_val_binop_commutative!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#401 id=401 data-nosnippet>401</a> <span class="macro">forward_ref_val_binop_commutative!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#402 id=402 data-nosnippet>402</a> <span class="macro">forward_ref_ref_binop_commutative!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#403 id=403 data-nosnippet>403</a> };
<a href=#404 id=404 data-nosnippet>404</a>}
<a href=#405 id=405 data-nosnippet>405</a>
<a href=#406 id=406 data-nosnippet>406</a><span class="macro">macro_rules!</span> forward_all_scalar_binop_to_ref_val {
<a href=#407 id=407 data-nosnippet>407</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#408 id=408 data-nosnippet>408</a> <span class="macro">forward_scalar_val_val_binop_to_ref_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#409 id=409 data-nosnippet>409</a> <span class="macro">forward_scalar_val_ref_binop_to_ref_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#410 id=410 data-nosnippet>410</a> <span class="macro">forward_scalar_ref_ref_binop_to_ref_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#411 id=411 data-nosnippet>411</a> }
<a href=#412 id=412 data-nosnippet>412</a>}
<a href=#413 id=413 data-nosnippet>413</a>
<a href=#414 id=414 data-nosnippet>414</a><span class="macro">macro_rules!</span> forward_all_scalar_binop_to_val_val {
<a href=#415 id=415 data-nosnippet>415</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#416 id=416 data-nosnippet>416</a> <span class="macro">forward_scalar_val_ref_binop_to_val_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#417 id=417 data-nosnippet>417</a> <span class="macro">forward_scalar_ref_val_binop_to_val_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#418 id=418 data-nosnippet>418</a> <span class="macro">forward_scalar_ref_ref_binop_to_val_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#419 id=419 data-nosnippet>419</a> }
<a href=#420 id=420 data-nosnippet>420</a>}
<a href=#421 id=421 data-nosnippet>421</a>
<a href=#422 id=422 data-nosnippet>422</a><span class="macro">macro_rules!</span> forward_all_scalar_binop_to_val_val_commutative {
<a href=#423 id=423 data-nosnippet>423</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident&lt;<span class="macro-nonterminal">$scalar</span>:ty&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#424 id=424 data-nosnippet>424</a> <span class="macro">forward_scalar_val_val_binop_commutative!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#425 id=425 data-nosnippet>425</a> <span class="macro">forward_all_scalar_binop_to_val_val!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>&lt;<span class="macro-nonterminal">$scalar</span>&gt; <span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#426 id=426 data-nosnippet>426</a> }
<a href=#427 id=427 data-nosnippet>427</a>}
<a href=#428 id=428 data-nosnippet>428</a>
<a href=#429 id=429 data-nosnippet>429</a><span class="macro">macro_rules!</span> promote_all_scalars {
<a href=#430 id=430 data-nosnippet>430</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#431 id=431 data-nosnippet>431</a> <span class="macro">promote_unsigned_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#432 id=432 data-nosnippet>432</a> <span class="macro">promote_signed_scalars!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#433 id=433 data-nosnippet>433</a> }
<a href=#434 id=434 data-nosnippet>434</a>}
<a href=#435 id=435 data-nosnippet>435</a>
<a href=#436 id=436 data-nosnippet>436</a><span class="macro">macro_rules!</span> promote_all_scalars_assign {
<a href=#437 id=437 data-nosnippet>437</a> (<span class="kw">impl </span><span class="macro-nonterminal">$imp</span>:ident <span class="kw">for </span><span class="macro-nonterminal">$res</span>:ty, <span class="macro-nonterminal">$method</span>:ident) =&gt; {
<a href=#438 id=438 data-nosnippet>438</a> <span class="macro">promote_unsigned_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#439 id=439 data-nosnippet>439</a> <span class="macro">promote_signed_scalars_assign!</span>(<span class="kw">impl </span><span class="macro-nonterminal">$imp </span><span class="kw">for </span><span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$method</span>);
<a href=#440 id=440 data-nosnippet>440</a> }
<a href=#441 id=441 data-nosnippet>441</a>}
<a href=#442 id=442 data-nosnippet>442</a>
<a href=#443 id=443 data-nosnippet>443</a><span class="macro">macro_rules!</span> impl_sum_iter_type {
<a href=#444 id=444 data-nosnippet>444</a> (<span class="macro-nonterminal">$res</span>:ty) =&gt; {
<a href=#445 id=445 data-nosnippet>445</a> <span class="kw">impl</span>&lt;T&gt; Sum&lt;T&gt; <span class="kw">for </span><span class="macro-nonterminal">$res
<a href=#446 id=446 data-nosnippet>446</a> </span><span class="kw">where
<a href=#447 id=447 data-nosnippet>447</a> </span><span class="macro-nonterminal">$res</span>: Add&lt;T, Output = <span class="macro-nonterminal">$res</span>&gt;,
<a href=#448 id=448 data-nosnippet>448</a> {
<a href=#449 id=449 data-nosnippet>449</a> <span class="kw">fn </span>sum&lt;I&gt;(iter: I) -&gt; <span class="self">Self
<a href=#450 id=450 data-nosnippet>450</a> </span><span class="kw">where
<a href=#451 id=451 data-nosnippet>451</a> </span>I: Iterator&lt;Item = T&gt;,
<a href=#452 id=452 data-nosnippet>452</a> {
<a href=#453 id=453 data-nosnippet>453</a> iter.fold(<span class="self">Self</span>::ZERO, &lt;<span class="macro-nonterminal">$res</span>&gt;::add)
<a href=#454 id=454 data-nosnippet>454</a> }
<a href=#455 id=455 data-nosnippet>455</a> }
<a href=#456 id=456 data-nosnippet>456</a> };
<a href=#457 id=457 data-nosnippet>457</a>}
<a href=#458 id=458 data-nosnippet>458</a>
<a href=#459 id=459 data-nosnippet>459</a><span class="macro">macro_rules!</span> impl_product_iter_type {
<a href=#460 id=460 data-nosnippet>460</a> (<span class="macro-nonterminal">$res</span>:ty) =&gt; {
<a href=#461 id=461 data-nosnippet>461</a> <span class="kw">impl</span>&lt;T&gt; Product&lt;T&gt; <span class="kw">for </span><span class="macro-nonterminal">$res
<a href=#462 id=462 data-nosnippet>462</a> </span><span class="kw">where
<a href=#463 id=463 data-nosnippet>463</a> </span><span class="macro-nonterminal">$res</span>: Mul&lt;T, Output = <span class="macro-nonterminal">$res</span>&gt;,
<a href=#464 id=464 data-nosnippet>464</a> {
<a href=#465 id=465 data-nosnippet>465</a> <span class="kw">fn </span>product&lt;I&gt;(iter: I) -&gt; <span class="self">Self
<a href=#466 id=466 data-nosnippet>466</a> </span><span class="kw">where
<a href=#467 id=467 data-nosnippet>467</a> </span>I: Iterator&lt;Item = T&gt;,
<a href=#468 id=468 data-nosnippet>468</a> {
<a href=#469 id=469 data-nosnippet>469</a> iter.fold(One::one(), &lt;<span class="macro-nonterminal">$res</span>&gt;::mul)
<a href=#470 id=470 data-nosnippet>470</a> }
<a href=#471 id=471 data-nosnippet>471</a> }
<a href=#472 id=472 data-nosnippet>472</a> };
<a href=#473 id=473 data-nosnippet>473</a>}
</code></pre></div></section></main></body></html>