gf2n_8cpp-source.html

Crypto++是一个非常强大的密码学库,主要是功能全

00344 
00345         <span class="keywordtype">int</span> shiftWords = n / WORD_BITS;
00346         <span class="keywordtype">int</span> shiftBits = n % WORD_BITS;
00347 
00348         <span class="keywordflow">if</span> (shiftBits)
00349         {
00350                 i = reg.size();
00351                 <span class="keywordflow">while</span> (i--)
00352                 {
00353                         u = *r;
00354                         *r = (u &lt;&lt; shiftBits) | carry;
00355                         carry = u &gt;&gt; (WORD_BITS-shiftBits);
00356                         r++;
00357                 }
00358         }
00359 
00360         <span class="keywordflow">if</span> (carry)
00361         {
00362                 reg.Grow(reg.size()+shiftWords+1);
00363                 reg[reg.size()-1] = carry;
00364         }
00365         <span class="keywordflow">else</span>
00366                 reg.Grow(reg.size()+shiftWords);
00367 
00368         <span class="keywordflow">if</span> (shiftWords)
00369         {
00370                 <span class="keywordflow">for</span> (i = reg.size()-1; i&gt;=shiftWords; i--)
00371                         reg[i] = reg[i-shiftWords];
00372                 <span class="keywordflow">for</span> (; i&gt;=0; i--)
00373                         reg[i] = 0;
00374         }
00375 
00376         <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00377 }
00378 
00379 <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a>&amp; PolynomialMod2::operator&gt;&gt;=(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> n)
00380 {
00381         <span class="keywordflow">if</span> (!reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>())
00382                 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00383 
00384         <span class="keywordtype">int</span> shiftWords = n / WORD_BITS;
00385         <span class="keywordtype">int</span> shiftBits = n % WORD_BITS;
00386 
00387         <span class="keywordtype">unsigned</span> i;
00388         word u;
00389         word carry=0;
00390         word *r=reg+reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>()-1;
00391 
00392         <span class="keywordflow">if</span> (shiftBits)
00393         {
00394                 i = reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>();
00395                 <span class="keywordflow">while</span> (i--)
00396                 {
00397                         u = *r;
00398                         *r = (u &gt;&gt; shiftBits) | carry;
00399                         carry = u &lt;&lt; (WORD_BITS-shiftBits);
00400                         r--;
00401                 }
00402         }
00403 
00404         <span class="keywordflow">if</span> (shiftWords)
00405         {
00406                 <span class="keywordflow">for</span> (i=0; i&lt;reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>()-shiftWords; i++)
00407                         reg[i] = reg[i+shiftWords];
00408                 <span class="keywordflow">for</span> (; i&lt;reg.size(); i++)
00409                         reg[i] = 0;
00410         }
00411 
00412         <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00413 }
00414 
00415 <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> PolynomialMod2::operator&lt;&lt;(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> n)<span class="keyword"> const</span>
00416 <span class="keyword"></span>{
00417         <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> result(*<span class="keyword">this</span>);
00418         <span class="keywordflow">return</span> result&lt;&lt;=n;
00419 }
00420 
00421 <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> PolynomialMod2::operator&gt;&gt;(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> n)<span class="keyword"> const</span>
00422 <span class="keyword"></span>{
00423         <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> result(*<span class="keyword">this</span>);
00424         <span class="keywordflow">return</span> result&gt;&gt;=n;
00425 }
00426 
00427 <span class="keywordtype">bool</span> PolynomialMod2::operator!()<span class="keyword"> const</span>
00428 <span class="keyword"></span>{
00429         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=0; i&lt;reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>(); i++)
00430                 <span class="keywordflow">if</span> (reg[i]) <span class="keywordflow">return</span> <span class="keyword">false</span>;
00431         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00432 }
00433 
00434 <span class="keywordtype">bool</span> PolynomialMod2::Equals(<span class="keyword">const</span> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> &amp;rhs)<span class="keyword"> const</span>
00435 <span class="keyword"></span>{
00436         <span class="keywordtype">unsigned</span> i, smallerSize = STDMIN(reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>(), rhs.<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2r0">reg</a>.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>());
00437 
00438         <span class="keywordflow">for</span> (i=0; i&lt;smallerSize; i++)
00439                 <span class="keywordflow">if</span> (reg[i] != rhs.<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2r0">reg</a>[i]) <span class="keywordflow">return</span> <span class="keyword">false</span>;
00440 
00441         <span class="keywordflow">for</span> (i=smallerSize; i&lt;reg.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>(); i++)
00442                 <span class="keywordflow">if</span> (reg[i] != 0) <span class="keywordflow">return</span> <span class="keyword">false</span>;
00443 
00444         <span class="keywordflow">for</span> (i=smallerSize; i&lt;rhs.<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2r0">reg</a>.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>(); i++)
00445                 <span class="keywordflow">if</span> (rhs.<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2r0">reg</a>[i] != 0) <span class="keywordflow">return</span> <span class="keyword">false</span>;
00446 
00447         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00448 }
00449 
00450 std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, <span class="keyword">const</span> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> &amp;a)
00451 {
00452         <span class="comment">// Get relevant conversion specifications from ostream.</span>
00453         <span class="keywordtype">long</span> f = out.flags() &amp; std::ios::basefield;     <span class="comment">// Get base digits.</span>
00454         <span class="keywordtype">int</span> bits, block;
00455         <span class="keywordtype">char</span> suffix;
00456         <span class="keywordflow">switch</span>(f)
00457         {
00458         <span class="keywordflow">case</span> std::ios::oct :
00459                 bits = 3;
00460                 block = 4;
00461                 suffix = <span class="charliteral">'o'</span>;
00462                 <span class="keywordflow">break</span>;
00463         <span class="keywordflow">case</span> std::ios::hex :
00464                 bits = 4;
00465                 block = 2;
00466                 suffix = <span class="charliteral">'h'</span>;
00467                 <span class="keywordflow">break</span>;
00468         <span class="keywordflow">default</span> :
00469                 bits = 1;
00470                 block = 8;
00471                 suffix = <span class="charliteral">'b'</span>;
00472         }
00473 
00474         <span class="keywordflow">if</span> (!a)
00475                 <span class="keywordflow">return</span> out &lt;&lt; <span class="charliteral">'0'</span> &lt;&lt; suffix;
00476 
00477         <a class="code" href="class_sec_block.html">SecBlock&lt;char&gt;</a> s(a.BitCount()/bits+1);
00478         <span class="keywordtype">unsigned</span> i;
00479         <span class="keyword">const</span> <span class="keywordtype">char</span> vec[]=<span class="stringliteral">"0123456789ABCDEF"</span>;
00480 
00481         <span class="keywordflow">for</span> (i=0; i*bits &lt; a.BitCount(); i++)
00482         {
00483                 <span class="keywordtype">int</span> digit=0;
00484                 <span class="keywordflow">for</span> (<span class="keywordtype">int</span> j=0; j&lt;bits; j++)
00485                         digit |= a[i*bits+j] &lt;&lt; j;
00486                 s[i]=vec[digit];
00487         }
00488 
00489         <span class="keywordflow">while</span> (i--)
00490         {
00491                 out &lt;&lt; s[i];
00492                 <span class="keywordflow">if</span> (i &amp;&amp; (i%block)==0)
00493                         out &lt;&lt; <span class="charliteral">','</span>;
00494         }
00495 
00496         <span class="keywordflow">return</span> out &lt;&lt; suffix;
00497 }
00498 
<a name="l00499"></a><a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_7">00499</a> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> <a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_7">PolynomialMod2::Gcd</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> &amp;a, <span class="keyword">const</span> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> &amp;b)
00500 {
00501         <span class="keywordflow">return</span> <a class="code" href="class_euclidean_domain_of.html">EuclideanDomainOf&lt;PolynomialMod2&gt;</a>().<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_7">Gcd</a>(a, b);
00502 }
00503 
<a name="l00504"></a><a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_6">00504</a> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> <a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_6">PolynomialMod2::InverseMod</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> &amp;modulus)<span class="keyword"> const</span>
00505 <span class="keyword"></span>{
00506         <span class="keyword">typedef</span> <a class="code" href="class_euclidean_domain_of.html">EuclideanDomainOf&lt;PolynomialMod2&gt;</a> Domain;
00507         <span class="keywordflow">return</span> <a class="code" href="class_quotient_ring.html">QuotientRing&lt;Domain&gt;</a>(Domain(), modulus).<a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_5">MultiplicativeInverse</a>(*<span class="keyword">this</span>);
00508 }
00509 
<a name="l00510"></a><a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_1">00510</a> <span class="keywordtype">bool</span> <a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z31_1">PolynomialMod2::IsIrreducible</a>()<span class="keyword"> const</span>
00511 <span class="keyword"></span>{
00512         <span class="keywordtype">signed</span> <span class="keywordtype">int</span> d = <a class="code" href="class_polynomial_mod2.html#_polynomial_mod2z23_5">Degree</a>();
00513         <span class="keywordflow">if</span> (d &lt;= 0)
00514                 <span class="keywordflow">return</span> <span class="keyword">false</span>;
00515 
00516         <a class="code" href="class_polynomial_mod2.html">PolynomialMod2</a> t(2), u(t);
00517         <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i=1; i&lt;=d/2; i++)
00518         {