polynomi_8cpp-source.html

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

00192         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = CoefficientCount(ring);
00193         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;count; i++)
00194                 m_coefficients[i] = ring.Inverse(m_coefficients[i]);
00195 }
00196 
00197 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00198 <span class="keywordtype">void</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::swap</a>(<a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> &amp;t)
00199 {
00200         m_coefficients.swap(t.m_coefficients);
00201 }
00202 
00203 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00204 <span class="keywordtype">bool</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Equals</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00205 <span class="keyword"></span>{
00206         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = CoefficientCount(ring);
00207 
00208         <span class="keywordflow">if</span> (count != t.CoefficientCount(ring))
00209                 <span class="keywordflow">return</span> <span class="keyword">false</span>;
00210 
00211         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;count; i++)
00212                 <span class="keywordflow">if</span> (!ring.Equal(m_coefficients[i], t.m_coefficients[i]))
00213                         <span class="keywordflow">return</span> <span class="keyword">false</span>;
00214 
00215         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00216 }
00217 
00218 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00219 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Plus</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00220 <span class="keyword"></span>{
00221         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i;
00222         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = CoefficientCount(ring);
00223         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> tCount = t.CoefficientCount(ring);
00224 
00225         <span class="keywordflow">if</span> (count &gt; tCount)
00226         {
00227                 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, count);
00228 
00229                 <span class="keywordflow">for</span> (i=0; i&lt;tCount; i++)
00230                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Add(m_coefficients[i], t.m_coefficients[i]);
00231                 <span class="keywordflow">for</span> (; i&lt;count; i++)
00232                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = m_coefficients[i];
00233 
00234                 <span class="keywordflow">return</span> result;
00235         }
00236         <span class="keywordflow">else</span>
00237         {
00238                 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, tCount);
00239 
00240                 <span class="keywordflow">for</span> (i=0; i&lt;count; i++)
00241                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Add(m_coefficients[i], t.m_coefficients[i]);
00242                 <span class="keywordflow">for</span> (; i&lt;tCount; i++)
00243                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = t.m_coefficients[i];
00244 
00245                 <span class="keywordflow">return</span> result;
00246         }
00247 }
00248 
00249 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00250 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Minus</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00251 <span class="keyword"></span>{
00252         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i;
00253         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = CoefficientCount(ring);
00254         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> tCount = t.CoefficientCount(ring);
00255 
00256         <span class="keywordflow">if</span> (count &gt; tCount)
00257         {
00258                 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, count);
00259 
00260                 <span class="keywordflow">for</span> (i=0; i&lt;tCount; i++)
00261                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Subtract(m_coefficients[i], t.m_coefficients[i]);
00262                 <span class="keywordflow">for</span> (; i&lt;count; i++)
00263                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = m_coefficients[i];
00264 
00265                 <span class="keywordflow">return</span> result;
00266         }
00267         <span class="keywordflow">else</span>
00268         {
00269                 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, tCount);
00270 
00271                 <span class="keywordflow">for</span> (i=0; i&lt;count; i++)
00272                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Subtract(m_coefficients[i], t.m_coefficients[i]);
00273                 <span class="keywordflow">for</span> (; i&lt;tCount; i++)
00274                         result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Inverse(t.m_coefficients[i]);
00275 
00276                 <span class="keywordflow">return</span> result;
00277         }
00278 }
00279 
00280 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00281 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Inverse</a>(<span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00282 <span class="keyword"></span>{
00283         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count = CoefficientCount(ring);
00284         <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, count);
00285 
00286         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;count; i++)
00287                 result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i] = ring.Inverse(m_coefficients[i]);
00288 
00289         <span class="keywordflow">return</span> result;
00290 }
00291 
00292 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00293 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Times</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00294 <span class="keyword"></span>{
00295         <span class="keywordflow">if</span> (IsZero(ring) || t.IsZero(ring))
00296                 <span class="keywordflow">return</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>();
00297 
00298         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> count1 = CoefficientCount(ring), count2 = t.CoefficientCount(ring);
00299         <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> result(ring, count1 + count2 - 1);
00300 
00301         <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;count1; i++)
00302                 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> j=0; j&lt;count2; j++)
00303                         ring.Accumulate(result.<a class="code" href="class_polynomial_over.html#_polynomial_overr0">m_coefficients</a>[i+j], ring.Multiply(m_coefficients[i], t.m_coefficients[j]));
00304 
00305         <span class="keywordflow">return</span> result;
00306 }
00307 
00308 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00309 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::DividedBy</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00310 <span class="keyword"></span>{
00311         <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> remainder, quotient;
00312         <a class="code" href="class_polynomial_over.html#_polynomial_over_fixed_ringz63_17">Divide</a>(remainder, quotient, *<span class="keyword">this</span>, t, ring);
00313         <span class="keywordflow">return</span> quotient;
00314 }
00315 
00316 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00317 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Modulo</a>(<span class="keyword">const</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>&amp; t, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00318 <span class="keyword"></span>{
00319         <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> remainder, quotient;
00320         <a class="code" href="class_polynomial_over.html#_polynomial_over_fixed_ringz63_17">Divide</a>(remainder, quotient, *<span class="keyword">this</span>, t, ring);
00321         <span class="keywordflow">return</span> remainder;
00322 }
00323 
00324 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00325 <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::MultiplicativeInverse</a>(<span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00326 <span class="keyword"></span>{
00327         <span class="keywordflow">return</span> <a class="code" href="class_polynomial_over.html#_polynomial_over_fixed_ringz59_0">Degree</a>(ring)==0 ? ring.MultiplicativeInverse(m_coefficients[0]) : ring.Identity();
00328 }
00329 
00330 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00331 <span class="keywordtype">bool</span> <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::IsUnit</a>(<span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00332 <span class="keyword"></span>{
00333         <span class="keywordflow">return</span> <a class="code" href="class_polynomial_over.html#_polynomial_over_fixed_ringz59_0">Degree</a>(ring)==0 &amp;&amp; ring.IsUnit(m_coefficients[0]);
00334 }
00335 
00336 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00337 std::istream&amp; <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Input</a>(std::istream &amp;in, <span class="keyword">const</span> Ring &amp;ring)
00338 {
00339         <span class="keywordtype">char</span> c;
00340         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length = 0;
00341         <a class="code" href="class_sec_block.html">SecBlock&lt;char&gt;</a> str(length + 16);
00342         <span class="keywordtype">bool</span> paren = <span class="keyword">false</span>;
00343 
00344         std::ws(in);
00345 
00346         <span class="keywordflow">if</span> (in.peek() == <span class="charliteral">'('</span>)
00347         {
00348                 paren = <span class="keyword">true</span>;
00349                 in.get();
00350         }
00351 
00352         <span class="keywordflow">do</span>
00353         {
00354                 in.read(&amp;c, 1);
00355                 str[length++] = c;
00356                 <span class="keywordflow">if</span> (length &gt;= str.<a class="code" href="class_sec_block.html#_sec_block_with_hinta13">size</a>())
00357                         str.<a class="code" href="class_sec_block.html#_sec_block_with_hinta21">Grow</a>(length + 16);
00358         }
00359         <span class="comment">// if we started with a left paren, then read until we find a right paren,</span>
00360         <span class="comment">// otherwise read until the end of the line</span>
00361         <span class="keywordflow">while</span> (in &amp;&amp; ((paren &amp;&amp; c != <span class="charliteral">')'</span>) || (!paren &amp;&amp; c != <span class="charliteral">'\n'</span>)));
00362 
00363         str[length-1] = <span class="charliteral">'\0'</span>;
00364         *<span class="keyword">this</span> = <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;</a>(str, ring);
00365 
00366         <span class="keywordflow">return</span> in;
00367 }
00368 
00369 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
00370 std::ostream&amp; <a class="code" href="class_polynomial_over.html">PolynomialOver&lt;T&gt;::Output</a>(std::ostream &amp;out, <span class="keyword">const</span> Ring &amp;ring)<span class="keyword"> const</span>
00371 <span class="keyword"></span>{
00372         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i = CoefficientCount(ring);
00373         <span class="keywordflow">if</span> (i)
00374         {
00375                 <span class="keywordtype">bool</span> firstTerm = <span class="keyword">true</span>;
00376 
00377                 <span class="keywordflow">while</span> (i--)
00378                 {
00379                         <span class="keywordflow">if</span> (m_coefficients[i] != ring.Identity())
00380                         {
00381                                 <span class="keywordflow">if</span> (firstTerm)
00382                                 {
00383                                         firstTerm = <span class="keyword">false</span>;
00384                                         <span class="keywordflow">if</span> (!i || !ring.Equal(m_coefficients[i], ring.MultiplicativeIdentity()))
00385                                                 out &lt;&lt; m_coefficients[i];
00386                                 }
00387                                 <span class="keywordflow">else</span>
00388                                 {
00389                                         CoefficientType inverse = ring.Inverse(m_coefficients[i]);