<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>Crypto++: integer.cpp Source File</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>
</head>
<body>
<!-- Generated by Doxygen 1.7.4 -->
<div id="top">
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<td style="padding-left: 0.5em;">
<div id="projectname">Crypto++</div>
</td>
</tr>
</tbody>
</table>
</div>
<div id="navrow1" class="tabs">
<ul class="tablist">
<li><a href="index.html"><span>Main Page</span></a></li>
<li><a href="namespaces.html"><span>Namespaces</span></a></li>
<li><a href="annotated.html"><span>Classes</span></a></li>
<li class="current"><a href="files.html"><span>Files</span></a></li>
</ul>
</div>
<div id="navrow2" class="tabs2">
<ul class="tablist">
<li><a href="files.html"><span>File List</span></a></li>
<li><a href="globals.html"><span>File Members</span></a></li>
</ul>
</div>
<div class="header">
<div class="headertitle">
<div class="title">integer.cpp</div> </div>
</div>
<div class="contents">
<div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 <span class="comment">// integer.cpp - written and placed in the public domain by Wei Dai</span>
<a name="l00002"></a>00002 <span class="comment">// contains public domain code contributed by Alister Lee and Leonard Janke</span>
<a name="l00003"></a>00003
<a name="l00004"></a>00004 <span class="preprocessor">#include "pch.h"</span>
<a name="l00005"></a>00005
<a name="l00006"></a>00006 <span class="preprocessor">#ifndef CRYPTOPP_IMPORTS</span>
<a name="l00007"></a>00007 <span class="preprocessor"></span>
<a name="l00008"></a>00008 <span class="preprocessor">#include "<a class="code" href="integer_8h.html">integer.h</a>"</span>
<a name="l00009"></a>00009 <span class="preprocessor">#include "modarith.h"</span>
<a name="l00010"></a>00010 <span class="preprocessor">#include "nbtheory.h"</span>
<a name="l00011"></a>00011 <span class="preprocessor">#include "asn.h"</span>
<a name="l00012"></a>00012 <span class="preprocessor">#include "oids.h"</span>
<a name="l00013"></a>00013 <span class="preprocessor">#include "words.h"</span>
<a name="l00014"></a>00014 <span class="preprocessor">#include "algparam.h"</span>
<a name="l00015"></a>00015 <span class="preprocessor">#include "<a class="code" href="pubkey_8h.html" title="This file contains helper classes/functions for implementing public key algorithms.">pubkey.h</a>"</span> <span class="comment">// for P1363_KDF2</span>
<a name="l00016"></a>00016 <span class="preprocessor">#include "sha.h"</span>
<a name="l00017"></a>00017 <span class="preprocessor">#include "cpu.h"</span>
<a name="l00018"></a>00018
<a name="l00019"></a>00019 <span class="preprocessor">#include <iostream></span>
<a name="l00020"></a>00020
<a name="l00021"></a>00021 <span class="preprocessor">#if _MSC_VER >= 1400</span>
<a name="l00022"></a>00022 <span class="preprocessor"></span><span class="preprocessor"> #include <intrin.h></span>
<a name="l00023"></a>00023 <span class="preprocessor">#endif</span>
<a name="l00024"></a>00024 <span class="preprocessor"></span>
<a name="l00025"></a>00025 <span class="preprocessor">#ifdef __DECCXX</span>
<a name="l00026"></a>00026 <span class="preprocessor"></span><span class="preprocessor"> #include <c_asm.h></span>
<a name="l00027"></a>00027 <span class="preprocessor">#endif</span>
<a name="l00028"></a>00028 <span class="preprocessor"></span>
<a name="l00029"></a>00029 <span class="preprocessor">#ifdef CRYPTOPP_MSVC6_NO_PP</span>
<a name="l00030"></a>00030 <span class="preprocessor"></span><span class="preprocessor"> #pragma message("You do not seem to have the Visual C++ Processor Pack installed, so use of SSE2 instructions will be disabled.")</span>
<a name="l00031"></a>00031 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00032"></a>00032 <span class="preprocessor"></span>
<a name="l00033"></a>00033 <span class="preprocessor">#define CRYPTOPP_INTEGER_SSE2 (CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && CRYPTOPP_BOOL_X86)</span>
<a name="l00034"></a>00034 <span class="preprocessor"></span>
<a name="l00035"></a>00035 NAMESPACE_BEGIN(CryptoPP)
<a name="l00036"></a>00036
<a name="l00037"></a>00037 bool AssignIntToInteger(const std::type_info &valueType, <span class="keywordtype">void</span> *pInteger, const <span class="keywordtype">void</span> *pInt)
<a name="l00038"></a>00038 {
<a name="l00039"></a>00039 <span class="keywordflow">if</span> (valueType != <span class="keyword">typeid</span>(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>))
<a name="l00040"></a>00040 <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00041"></a>00041 *<span class="keyword">reinterpret_cast<</span><a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> *<span class="keyword">></span>(pInteger) = *reinterpret_cast<const int *>(pInt);
<a name="l00042"></a>00042 <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00043"></a>00043 }
<a name="l00044"></a>00044
<a name="l00045"></a>00045 <span class="keyword">inline</span> <span class="keyword">static</span> <span class="keywordtype">int</span> Compare(<span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l00046"></a>00046 {
<a name="l00047"></a>00047 <span class="keywordflow">while</span> (N--)
<a name="l00048"></a>00048 <span class="keywordflow">if</span> (A[N] > B[N])
<a name="l00049"></a>00049 <span class="keywordflow">return</span> 1;
<a name="l00050"></a>00050 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (A[N] < B[N])
<a name="l00051"></a>00051 <span class="keywordflow">return</span> -1;
<a name="l00052"></a>00052
<a name="l00053"></a>00053 <span class="keywordflow">return</span> 0;
<a name="l00054"></a>00054 }
<a name="l00055"></a>00055
<a name="l00056"></a>00056 <span class="keyword">inline</span> <span class="keyword">static</span> <span class="keywordtype">int</span> Increment(word *A, <span class="keywordtype">size_t</span> N, word B=1)
<a name="l00057"></a>00057 {
<a name="l00058"></a>00058 assert(N);
<a name="l00059"></a>00059 word t = A[0];
<a name="l00060"></a>00060 A[0] = t+B;
<a name="l00061"></a>00061 <span class="keywordflow">if</span> (A[0] >= t)
<a name="l00062"></a>00062 <span class="keywordflow">return</span> 0;
<a name="l00063"></a>00063 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=1; i<N; i++)
<a name="l00064"></a>00064 <span class="keywordflow">if</span> (++A[i])
<a name="l00065"></a>00065 <span class="keywordflow">return</span> 0;
<a name="l00066"></a>00066 <span class="keywordflow">return</span> 1;
<a name="l00067"></a>00067 }
<a name="l00068"></a>00068
<a name="l00069"></a>00069 <span class="keyword">inline</span> <span class="keyword">static</span> <span class="keywordtype">int</span> Decrement(word *A, <span class="keywordtype">size_t</span> N, word B=1)
<a name="l00070"></a>00070 {
<a name="l00071"></a>00071 assert(N);
<a name="l00072"></a>00072 word t = A[0];
<a name="l00073"></a>00073 A[0] = t-B;
<a name="l00074"></a>00074 <span class="keywordflow">if</span> (A[0] <= t)
<a name="l00075"></a>00075 <span class="keywordflow">return</span> 0;
<a name="l00076"></a>00076 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=1; i<N; i++)
<a name="l00077"></a>00077 <span class="keywordflow">if</span> (A[i]--)
<a name="l00078"></a>00078 <span class="keywordflow">return</span> 0;
<a name="l00079"></a>00079 <span class="keywordflow">return</span> 1;
<a name="l00080"></a>00080 }
<a name="l00081"></a>00081
<a name="l00082"></a>00082 <span class="keyword">static</span> <span class="keywordtype">void</span> TwosComplement(word *A, <span class="keywordtype">size_t</span> N)
<a name="l00083"></a>00083 {
<a name="l00084"></a>00084 Decrement(A, N);
<a name="l00085"></a>00085 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=0; i<N; i++)
<a name="l00086"></a>00086 A[i] = ~A[i];
<a name="l00087"></a>00087 }
<a name="l00088"></a>00088
<a name="l00089"></a>00089 <span class="keyword">static</span> word AtomicInverseModPower2(word A)
<a name="l00090"></a>00090 {
<a name="l00091"></a>00091 assert(A%2==1);
<a name="l00092"></a>00092
<a name="l00093"></a>00093 word R=A%8;
<a name="l00094"></a>00094
<a name="l00095"></a>00095 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=3; i<WORD_BITS; i*=2)
<a name="l00096"></a>00096 R = R*(2-R*A);
<a name="l00097"></a>00097
<a name="l00098"></a>00098 assert(R*A==1);
<a name="l00099"></a>00099 <span class="keywordflow">return</span> R;
<a name="l00100"></a>00100 }
<a name="l00101"></a>00101
<a name="l00102"></a>00102 <span class="comment">// ********************************************************</span>
<a name="l00103"></a>00103
<a name="l00104"></a>00104 <span class="preprocessor">#if !defined(CRYPTOPP_NATIVE_DWORD_AVAILABLE) || (defined(__x86_64__) && defined(CRYPTOPP_WORD128_AVAILABLE))</span>
<a name="l00105"></a>00105 <span class="preprocessor"></span><span class="preprocessor"> #define Declare2Words(x) word x##0, x##1;</span>
<a name="l00106"></a>00106 <span class="preprocessor"></span><span class="preprocessor"> #define AssignWord(a, b) a##0 = b; a##1 = 0;</span>
<a name="l00107"></a>00107 <span class="preprocessor"></span><span class="preprocessor"> #define Add2WordsBy1(a, b, c) a##0 = b##0 + c; a##1 = b##1 + (a##0 < c);</span>
<a name="l00108"></a>00108 <span class="preprocessor"></span><span class="preprocessor"> #define LowWord(a) a##0</span>
<a name="l00109"></a>00109 <span class="preprocessor"></span><span class="preprocessor"> #define HighWord(a) a##1</span>
<a name="l00110"></a>00110 <span class="preprocessor"></span><span class="preprocessor"> #ifdef _MSC_VER</span>
<a name="l00111"></a>00111 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWordsLoHi(p0, p1, a, b) p0 = _umul128(a, b, &p1);</span>
<a name="l00112"></a>00112 <span class="preprocessor"></span><span class="preprocessor"> #ifndef __INTEL_COMPILER</span>
<a name="l00113"></a>00113 <span class="preprocessor"></span><span class="preprocessor"> #define Double3Words(c, d) d##1 = __shiftleft128(d##0, d##1, 1); d##0 = __shiftleft128(c, d##0, 1); c *= 2;</span>
<a name="l00114"></a>00114 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00115"></a>00115 <span class="preprocessor"></span><span class="preprocessor"> #elif defined(__DECCXX)</span>
<a name="l00116"></a>00116 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWordsLoHi(p0, p1, a, b) p0 = a*b; p1 = asm("umulh %a0, %a1, %v0", a, b);</span>
<a name="l00117"></a>00117 <span class="preprocessor"></span><span class="preprocessor"> #elif defined(__x86_64__)</span>
<a name="l00118"></a>00118 <span class="preprocessor"></span><span class="preprocessor"> #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5100</span>
<a name="l00119"></a>00119 <span class="preprocessor"></span> <span class="comment">// Sun Studio's gcc-style inline assembly is heavily bugged as of version 5.9 Patch 124864-09 2008/12/16, but this one works</span>
<a name="l00120"></a>00120 <span class="preprocessor"> #define MultiplyWordsLoHi(p0, p1, a, b) asm ("mulq %3" : "=a"(p0), "=d"(p1) : "a"(a), "r"(b) : "cc");</span>
<a name="l00121"></a>00121 <span class="preprocessor"></span><span class="preprocessor"> #else</span>
<a name="l00122"></a>00122 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWordsLoHi(p0, p1, a, b) asm ("mulq %3" : "=a"(p0), "=d"(p1) : "a"(a), "g"(b) : "cc");</span>
<a name="l00123"></a>00123 <span class="preprocessor"></span><span class="preprocessor"> #define MulAcc(c, d, a, b) asm ("mulq %6; addq %3, %0; adcq %4, %1; adcq $0, %2;" : "+r"(c), "+r"(d##0), "+r"(d##1), "=a"(p0), "=d"(p1) : "a"(a), "g"(b) : "cc");</span>
<a name="l00124"></a>00124 <span class="preprocessor"></span><span class="preprocessor"> #define Double3Words(c, d) asm ("addq %0, %0; adcq %1, %1; adcq %2, %2;" : "+r"(c), "+r"(d##0), "+r"(d##1) : : "cc");</span>
<a name="l00125"></a>00125 <span class="preprocessor"></span><span class="preprocessor"> #define Acc2WordsBy1(a, b) asm ("addq %2, %0; adcq $0, %1;" : "+r"(a##0), "+r"(a##1) : "r"(b) : "cc");</span>
<a name="l00126"></a>00126 <span class="preprocessor"></span><span class="preprocessor"> #define Acc2WordsBy2(a, b) asm ("addq %2, %0; adcq %3, %1;" : "+r"(a##0), "+r"(a##1) : "r"(b##0), "r"(b##1) : "cc");</span>
<a name="l00127"></a>00127 <span class="preprocessor"></span><span class="preprocessor"> #define Acc3WordsBy2(c, d, e) asm ("addq %5, %0; adcq %6, %1; adcq $0, %2;" : "+r"(c), "=r"(e##0), "=r"(e##1) : "1"(d##0), "2"(d##1), "r"(e##0), "r"(e##1) : "cc");</span>
<a name="l00128"></a>00128 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00129"></a>00129 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00130"></a>00130 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWords(p, a, b) MultiplyWordsLoHi(p##0, p##1, a, b)</span>
<a name="l00131"></a>00131 <span class="preprocessor"></span><span class="preprocessor"> #ifndef Double3Words</span>
<a name="l00132"></a>00132 <span class="preprocessor"></span><span class="preprocessor"> #define Double3Words(c, d) d##1 = 2*d##1 + (d##0>>(WORD_BITS-1)); d##0 = 2*d##0 + (c>>(WORD_BITS-1)); c *= 2;</span>
<a name="l00133"></a>00133 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00134"></a>00134 <span class="preprocessor"></span><span class="preprocessor"> #ifndef Acc2WordsBy2</span>
<a name="l00135"></a>00135 <span class="preprocessor"></span><span class="preprocessor"> #define Acc2WordsBy2(a, b) a##0 += b##0; a##1 += a##0 < b##0; a##1 += b##1;</span>
<a name="l00136"></a>00136 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00137"></a>00137 <span class="preprocessor"></span><span class="preprocessor"> #define AddWithCarry(u, a, b) {word t = a+b; u##0 = t + u##1; u##1 = (t<a) + (u##0<t);}</span>
<a name="l00138"></a>00138 <span class="preprocessor"></span><span class="preprocessor"> #define SubtractWithBorrow(u, a, b) {word t = a-b; u##0 = t - u##1; u##1 = (t>a) + (u##0>t);}</span>
<a name="l00139"></a>00139 <span class="preprocessor"></span><span class="preprocessor"> #define GetCarry(u) u##1</span>
<a name="l00140"></a>00140 <span class="preprocessor"></span><span class="preprocessor"> #define GetBorrow(u) u##1</span>
<a name="l00141"></a>00141 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00142"></a>00142 <span class="preprocessor"></span><span class="preprocessor"> #define Declare2Words(x) dword x;</span>
<a name="l00143"></a>00143 <span class="preprocessor"></span><span class="preprocessor"> #if _MSC_VER >= 1400 && !defined(__INTEL_COMPILER)</span>
<a name="l00144"></a>00144 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWords(p, a, b) p = __emulu(a, b);</span>
<a name="l00145"></a>00145 <span class="preprocessor"></span><span class="preprocessor"> #else</span>
<a name="l00146"></a>00146 <span class="preprocessor"></span><span class="preprocessor"> #define MultiplyWords(p, a, b) p = (dword)a*b;</span>
<a name="l00147"></a>00147 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00148"></a>00148 <span class="preprocessor"></span><span class="preprocessor"> #define AssignWord(a, b) a = b;</span>
<a name="l00149"></a>00149 <span class="preprocessor"></span><span class="preprocessor"> #define Add2WordsBy1(a, b, c) a = b + c;</span>
<a name="l00150"></a>00150 <span class="preprocessor"></span><span class="preprocessor"> #define Acc2WordsBy2(a, b) a += b;</span>
<a name="l00151"></a>00151 <span class="preprocessor"></span><span class="preprocessor"> #define LowWord(a) word(a)</span>
<a name="l00152"></a>00152 <span class="preprocessor"></span><span class="preprocessor"> #define HighWord(a) word(a>>WORD_BITS)</span>
<a name="l00153"></a>00153 <span class="preprocessor"></span><span class="preprocessor"> #define Double3Words(c, d) d = 2*d + (c>>(WORD_BITS-1)); c *= 2;</span>
<a name="l00154"></a>00154 <span class="preprocessor"></span><span class="preprocessor"> #define AddWithCarry(u, a, b) u = dword(a) + b + GetCarry(u);</span>
<a name="l00155"></a>00155 <span class="preprocessor"></span><span class="preprocessor"> #define SubtractWithBorrow(u, a, b) u = dword(a) - b - GetBorrow(u);</span>
<a name="l00156"></a>00156 <span class="preprocessor"></span><span class="preprocessor"> #define GetCarry(u) HighWord(u)</span>
<a name="l00157"></a>00157 <span class="preprocessor"></span><span class="preprocessor"> #define GetBorrow(u) word(u>>(WORD_BITS*2-1))</span>
<a name="l00158"></a>00158 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00159"></a>00159 <span class="preprocessor"></span><span class="preprocessor">#ifndef MulAcc</span>
<a name="l00160"></a>00160 <span class="preprocessor"></span><span class="preprocessor"> #define MulAcc(c, d, a, b) MultiplyWords(p, a, b); Acc2WordsBy1(p, c); c = LowWord(p); Acc2WordsBy1(d, HighWord(p));</span>
<a name="l00161"></a>00161 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00162"></a>00162 <span class="preprocessor"></span><span class="preprocessor">#ifndef Acc2WordsBy1</span>
<a name="l00163"></a>00163 <span class="preprocessor"></span><span class="preprocessor"> #define Acc2WordsBy1(a, b) Add2WordsBy1(a, a, b)</span>
<a name="l00164"></a>00164 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00165"></a>00165 <span class="preprocessor"></span><span class="preprocessor">#ifndef Acc3WordsBy2</span>
<a name="l00166"></a>00166 <span class="preprocessor"></span><span class="preprocessor"> #define Acc3WordsBy2(c, d, e) Acc2WordsBy1(e, c); c = LowWord(e); Add2WordsBy1(e, d, HighWord(e));</span>
<a name="l00167"></a>00167 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00168"></a>00168 <span class="preprocessor"></span>
<a name="l00169"></a><a class="code" href="class_d_word.html">00169</a> <span class="keyword">class </span><a class="code" href="class_d_word.html">DWord</a>
<a name="l00170"></a>00170 {
<a name="l00171"></a>00171 <span class="keyword">public</span>:
<a name="l00172"></a>00172 <a class="code" href="class_d_word.html">DWord</a>() {}
<a name="l00173"></a>00173
<a name="l00174"></a>00174 <span class="preprocessor">#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00175"></a>00175 <span class="preprocessor"></span> <span class="keyword">explicit</span> <a class="code" href="class_d_word.html">DWord</a>(word low)
<a name="l00176"></a>00176 {
<a name="l00177"></a>00177 m_whole = low;
<a name="l00178"></a>00178 }
<a name="l00179"></a>00179 <span class="preprocessor">#else</span>
<a name="l00180"></a>00180 <span class="preprocessor"></span> <span class="keyword">explicit</span> <a class="code" href="class_d_word.html">DWord</a>(word low)
<a name="l00181"></a>00181 {
<a name="l00182"></a>00182 m_halfs.low = low;
<a name="l00183"></a>00183 m_halfs.high = 0;
<a name="l00184"></a>00184 }
<a name="l00185"></a>00185 <span class="preprocessor">#endif</span>
<a name="l00186"></a>00186 <span class="preprocessor"></span>
<a name="l00187"></a>00187 <a class="code" href="class_d_word.html">DWord</a>(word low, word high)
<a name="l00188"></a>00188 {
<a name="l00189"></a>00189 m_halfs.low = low;
<a name="l00190"></a>00190 m_halfs.high = high;
<a name="l00191"></a>00191 }
<a name="l00192"></a>00192
<a name="l00193"></a>00193 <span class="keyword">static</span> <a class="code" href="class_d_word.html">DWord</a> Multiply(word a, word b)
<a name="l00194"></a>00194 {
<a name="l00195"></a>00195 <a class="code" href="class_d_word.html">DWord</a> r;
<a name="l00196"></a>00196 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00197"></a>00197 <span class="preprocessor"></span> r.m_whole = (dword)a * b;
<a name="l00198"></a>00198 <span class="preprocessor"> #elif defined(MultiplyWordsLoHi)</span>
<a name="l00199"></a>00199 <span class="preprocessor"></span> MultiplyWordsLoHi(r.m_halfs.low, r.m_halfs.high, a, b);
<a name="l00200"></a>00200 <span class="preprocessor"> #endif</span>
<a name="l00201"></a>00201 <span class="preprocessor"></span> <span class="keywordflow">return</span> r;
<a name="l00202"></a>00202 }
<a name="l00203"></a>00203
<a name="l00204"></a>00204 <span class="keyword">static</span> <a class="code" href="class_d_word.html">DWord</a> MultiplyAndAdd(word a, word b, word c)
<a name="l00205"></a>00205 {
<a name="l00206"></a>00206 <a class="code" href="class_d_word.html">DWord</a> r = Multiply(a, b);
<a name="l00207"></a>00207 <span class="keywordflow">return</span> r += c;
<a name="l00208"></a>00208 }
<a name="l00209"></a>00209
<a name="l00210"></a>00210 <a class="code" href="class_d_word.html">DWord</a> & operator+=(word a)
<a name="l00211"></a>00211 {
<a name="l00212"></a>00212 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00213"></a>00213 <span class="preprocessor"></span> m_whole = m_whole + a;
<a name="l00214"></a>00214 <span class="preprocessor"> #else</span>
<a name="l00215"></a>00215 <span class="preprocessor"></span> m_halfs.low += a;
<a name="l00216"></a>00216 m_halfs.high += (m_halfs.low < a);
<a name="l00217"></a>00217 <span class="preprocessor"> #endif</span>
<a name="l00218"></a>00218 <span class="preprocessor"></span> <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l00219"></a>00219 }
<a name="l00220"></a>00220
<a name="l00221"></a>00221 <a class="code" href="class_d_word.html">DWord</a> operator+(word a)
<a name="l00222"></a>00222 {
<a name="l00223"></a>00223 <a class="code" href="class_d_word.html">DWord</a> r;
<a name="l00224"></a>00224 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00225"></a>00225 <span class="preprocessor"></span> r.m_whole = m_whole + a;
<a name="l00226"></a>00226 <span class="preprocessor"> #else</span>
<a name="l00227"></a>00227 <span class="preprocessor"></span> r.m_halfs.low = m_halfs.low + a;
<a name="l00228"></a>00228 r.m_halfs.high = m_halfs.high + (r.m_halfs.low < a);
<a name="l00229"></a>00229 <span class="preprocessor"> #endif</span>
<a name="l00230"></a>00230 <span class="preprocessor"></span> <span class="keywordflow">return</span> r;
<a name="l00231"></a>00231 }
<a name="l00232"></a>00232
<a name="l00233"></a>00233 <a class="code" href="class_d_word.html">DWord</a> operator-(<a class="code" href="class_d_word.html">DWord</a> a)
<a name="l00234"></a>00234 {
<a name="l00235"></a>00235 <a class="code" href="class_d_word.html">DWord</a> r;
<a name="l00236"></a>00236 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00237"></a>00237 <span class="preprocessor"></span> r.m_whole = m_whole - a.m_whole;
<a name="l00238"></a>00238 <span class="preprocessor"> #else</span>
<a name="l00239"></a>00239 <span class="preprocessor"></span> r.m_halfs.low = m_halfs.low - a.m_halfs.low;
<a name="l00240"></a>00240 r.m_halfs.high = m_halfs.high - a.m_halfs.high - (r.m_halfs.low > m_halfs.low);
<a name="l00241"></a>00241 <span class="preprocessor"> #endif</span>
<a name="l00242"></a>00242 <span class="preprocessor"></span> <span class="keywordflow">return</span> r;
<a name="l00243"></a>00243 }
<a name="l00244"></a>00244
<a name="l00245"></a>00245 <a class="code" href="class_d_word.html">DWord</a> operator-(word a)
<a name="l00246"></a>00246 {
<a name="l00247"></a>00247 <a class="code" href="class_d_word.html">DWord</a> r;
<a name="l00248"></a>00248 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00249"></a>00249 <span class="preprocessor"></span> r.m_whole = m_whole - a;
<a name="l00250"></a>00250 <span class="preprocessor"> #else</span>
<a name="l00251"></a>00251 <span class="preprocessor"></span> r.m_halfs.low = m_halfs.low - a;
<a name="l00252"></a>00252 r.m_halfs.high = m_halfs.high - (r.m_halfs.low > m_halfs.low);
<a name="l00253"></a>00253 <span class="preprocessor"> #endif</span>
<a name="l00254"></a>00254 <span class="preprocessor"></span> <span class="keywordflow">return</span> r;
<a name="l00255"></a>00255 }
<a name="l00256"></a>00256
<a name="l00257"></a>00257 <span class="comment">// returns quotient, which must fit in a word</span>
<a name="l00258"></a>00258 word operator/(word divisor);
<a name="l00259"></a>00259
<a name="l00260"></a>00260 word operator%(word a);
<a name="l00261"></a>00261
<a name="l00262"></a>00262 <span class="keywordtype">bool</span> operator!()<span class="keyword"> const</span>
<a name="l00263"></a>00263 <span class="keyword"> </span>{
<a name="l00264"></a>00264 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00265"></a>00265 <span class="preprocessor"></span> <span class="keywordflow">return</span> !m_whole;
<a name="l00266"></a>00266 <span class="preprocessor"> #else</span>
<a name="l00267"></a>00267 <span class="preprocessor"></span> <span class="keywordflow">return</span> !m_halfs.high && !m_halfs.low;
<a name="l00268"></a>00268 <span class="preprocessor"> #endif</span>
<a name="l00269"></a>00269 <span class="preprocessor"></span> }
<a name="l00270"></a>00270
<a name="l00271"></a>00271 word GetLowHalf()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_halfs.low;}
<a name="l00272"></a>00272 word GetHighHalf()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_halfs.high;}
<a name="l00273"></a>00273 word GetHighHalfAsBorrow()<span class="keyword"> const </span>{<span class="keywordflow">return</span> 0-m_halfs.high;}
<a name="l00274"></a>00274
<a name="l00275"></a>00275 <span class="keyword">private</span>:
<a name="l00276"></a>00276 <span class="keyword">union</span>
<a name="l00277"></a>00277 {
<a name="l00278"></a>00278 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00279"></a>00279 <span class="preprocessor"></span> dword m_whole;
<a name="l00280"></a>00280 <span class="preprocessor"> #endif</span>
<a name="l00281"></a>00281 <span class="preprocessor"></span> <span class="keyword">struct</span>
<a name="l00282"></a>00282 {
<a name="l00283"></a>00283 <span class="preprocessor"> #ifdef IS_LITTLE_ENDIAN</span>
<a name="l00284"></a>00284 <span class="preprocessor"></span> word low;
<a name="l00285"></a>00285 word high;
<a name="l00286"></a>00286 <span class="preprocessor"> #else</span>
<a name="l00287"></a>00287 <span class="preprocessor"></span> word high;
<a name="l00288"></a>00288 word low;
<a name="l00289"></a>00289 <span class="preprocessor"> #endif</span>
<a name="l00290"></a>00290 <span class="preprocessor"></span> } m_halfs;
<a name="l00291"></a>00291 };
<a name="l00292"></a>00292 };
<a name="l00293"></a>00293
<a name="l00294"></a><a class="code" href="class_word.html">00294</a> <span class="keyword">class </span><a class="code" href="class_word.html">Word</a>
<a name="l00295"></a>00295 {
<a name="l00296"></a>00296 <span class="keyword">public</span>:
<a name="l00297"></a>00297 <a class="code" href="class_word.html">Word</a>() {}
<a name="l00298"></a>00298
<a name="l00299"></a>00299 <a class="code" href="class_word.html">Word</a>(word value)
<a name="l00300"></a>00300 {
<a name="l00301"></a>00301 m_whole = value;
<a name="l00302"></a>00302 }
<a name="l00303"></a>00303
<a name="l00304"></a>00304 <a class="code" href="class_word.html">Word</a>(hword low, hword high)
<a name="l00305"></a>00305 {
<a name="l00306"></a>00306 m_whole = low | (word(high) << (WORD_BITS/2));
<a name="l00307"></a>00307 }
<a name="l00308"></a>00308
<a name="l00309"></a>00309 <span class="keyword">static</span> <a class="code" href="class_word.html">Word</a> Multiply(hword a, hword b)
<a name="l00310"></a>00310 {
<a name="l00311"></a>00311 <a class="code" href="class_word.html">Word</a> r;
<a name="l00312"></a>00312 r.m_whole = (word)a * b;
<a name="l00313"></a>00313 <span class="keywordflow">return</span> r;
<a name="l00314"></a>00314 }
<a name="l00315"></a>00315
<a name="l00316"></a>00316 <a class="code" href="class_word.html">Word</a> operator-(<a class="code" href="class_word.html">Word</a> a)
<a name="l00317"></a>00317 {
<a name="l00318"></a>00318 <a class="code" href="class_word.html">Word</a> r;
<a name="l00319"></a>00319 r.m_whole = m_whole - a.m_whole;
<a name="l00320"></a>00320 <span class="keywordflow">return</span> r;
<a name="l00321"></a>00321 }
<a name="l00322"></a>00322
<a name="l00323"></a>00323 <a class="code" href="class_word.html">Word</a> operator-(hword a)
<a name="l00324"></a>00324 {
<a name="l00325"></a>00325 <a class="code" href="class_word.html">Word</a> r;
<a name="l00326"></a>00326 r.m_whole = m_whole - a;
<a name="l00327"></a>00327 <span class="keywordflow">return</span> r;
<a name="l00328"></a>00328 }
<a name="l00329"></a>00329
<a name="l00330"></a>00330 <span class="comment">// returns quotient, which must fit in a word</span>
<a name="l00331"></a>00331 hword operator/(hword divisor)
<a name="l00332"></a>00332 {
<a name="l00333"></a>00333 <span class="keywordflow">return</span> hword(m_whole / divisor);
<a name="l00334"></a>00334 }
<a name="l00335"></a>00335
<a name="l00336"></a>00336 <span class="keywordtype">bool</span> operator!()<span class="keyword"> const</span>
<a name="l00337"></a>00337 <span class="keyword"> </span>{
<a name="l00338"></a>00338 <span class="keywordflow">return</span> !m_whole;
<a name="l00339"></a>00339 }
<a name="l00340"></a>00340
<a name="l00341"></a>00341 word GetWhole()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_whole;}
<a name="l00342"></a>00342 hword GetLowHalf()<span class="keyword"> const </span>{<span class="keywordflow">return</span> hword(m_whole);}
<a name="l00343"></a>00343 hword GetHighHalf()<span class="keyword"> const </span>{<span class="keywordflow">return</span> hword(m_whole>>(WORD_BITS/2));}
<a name="l00344"></a>00344 hword GetHighHalfAsBorrow()<span class="keyword"> const </span>{<span class="keywordflow">return</span> 0-hword(m_whole>>(WORD_BITS/2));}
<a name="l00345"></a>00345
<a name="l00346"></a>00346 <span class="keyword">private</span>:
<a name="l00347"></a>00347 word m_whole;
<a name="l00348"></a>00348 };
<a name="l00349"></a>00349
<a name="l00350"></a>00350 <span class="comment">// do a 3 word by 2 word divide, returns quotient and leaves remainder in A</span>
<a name="l00351"></a>00351 <span class="keyword">template</span> <<span class="keyword">class</span> S, <span class="keyword">class</span> D>
<a name="l00352"></a>00352 S DivideThreeWordsByTwo(S *A, S B0, S B1, D *dummy=NULL)
<a name="l00353"></a>00353 {
<a name="l00354"></a>00354 <span class="comment">// assert {A[2],A[1]} < {B1,B0}, so quotient can fit in a S</span>
<a name="l00355"></a>00355 assert(A[2] < B1 || (A[2]==B1 && A[1] < B0));
<a name="l00356"></a>00356
<a name="l00357"></a>00357 <span class="comment">// estimate the quotient: do a 2 S by 1 S divide</span>
<a name="l00358"></a>00358 S Q;
<a name="l00359"></a>00359 <span class="keywordflow">if</span> (S(B1+1) == 0)
<a name="l00360"></a>00360 Q = A[2];
<a name="l00361"></a>00361 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (B1 > 0)
<a name="l00362"></a>00362 Q = D(A[1], A[2]) / S(B1+1);
<a name="l00363"></a>00363 <span class="keywordflow">else</span>
<a name="l00364"></a>00364 Q = D(A[0], A[1]) / B0;
<a name="l00365"></a>00365
<a name="l00366"></a>00366 <span class="comment">// now subtract Q*B from A</span>
<a name="l00367"></a>00367 D p = D::Multiply(B0, Q);
<a name="l00368"></a>00368 D u = (D) A[0] - p.GetLowHalf();
<a name="l00369"></a>00369 A[0] = u.GetLowHalf();
<a name="l00370"></a>00370 u = (D) A[1] - p.GetHighHalf() - u.GetHighHalfAsBorrow() - D::Multiply(B1, Q);
<a name="l00371"></a>00371 A[1] = u.GetLowHalf();
<a name="l00372"></a>00372 A[2] += u.GetHighHalf();
<a name="l00373"></a>00373
<a name="l00374"></a>00374 <span class="comment">// Q <= actual quotient, so fix it</span>
<a name="l00375"></a>00375 <span class="keywordflow">while</span> (A[2] || A[1] > B1 || (A[1]==B1 && A[0]>=B0))
<a name="l00376"></a>00376 {
<a name="l00377"></a>00377 u = (D) A[0] - B0;
<a name="l00378"></a>00378 A[0] = u.GetLowHalf();
<a name="l00379"></a>00379 u = (D) A[1] - B1 - u.GetHighHalfAsBorrow();
<a name="l00380"></a>00380 A[1] = u.GetLowHalf();
<a name="l00381"></a>00381 A[2] += u.GetHighHalf();
<a name="l00382"></a>00382 Q++;
<a name="l00383"></a>00383 assert(Q); <span class="comment">// shouldn't overflow</span>
<a name="l00384"></a>00384 }
<a name="l00385"></a>00385
<a name="l00386"></a>00386 <span class="keywordflow">return</span> Q;
<a name="l00387"></a>00387 }
<a name="l00388"></a>00388
<a name="l00389"></a>00389 <span class="comment">// do a 4 word by 2 word divide, returns 2 word quotient in Q0 and Q1</span>
<a name="l00390"></a>00390 <span class="keyword">template</span> <<span class="keyword">class</span> S, <span class="keyword">class</span> D>
<a name="l00391"></a>00391 <span class="keyword">inline</span> D DivideFourWordsByTwo(S *T, <span class="keyword">const</span> D &Al, <span class="keyword">const</span> D &Ah, <span class="keyword">const</span> D &B)
<a name="l00392"></a>00392 {
<a name="l00393"></a>00393 <span class="keywordflow">if</span> (!B) <span class="comment">// if divisor is 0, we assume divisor==2**(2*WORD_BITS)</span>
<a name="l00394"></a>00394 <span class="keywordflow">return</span> D(Ah.GetLowHalf(), Ah.GetHighHalf());
<a name="l00395"></a>00395 <span class="keywordflow">else</span>
<a name="l00396"></a>00396 {
<a name="l00397"></a>00397 S Q[2];
<a name="l00398"></a>00398 T[0] = Al.GetLowHalf();
<a name="l00399"></a>00399 T[1] = Al.GetHighHalf();
<a name="l00400"></a>00400 T[2] = Ah.GetLowHalf();
<a name="l00401"></a>00401 T[3] = Ah.GetHighHalf();
<a name="l00402"></a>00402 Q[1] = DivideThreeWordsByTwo<S, D>(T+1, B.GetLowHalf(), B.GetHighHalf());
<a name="l00403"></a>00403 Q[0] = DivideThreeWordsByTwo<S, D>(T, B.GetLowHalf(), B.GetHighHalf());
<a name="l00404"></a>00404 <span class="keywordflow">return</span> D(Q[0], Q[1]);
<a name="l00405"></a>00405 }
<a name="l00406"></a>00406 }
<a name="l00407"></a>00407
<a name="l00408"></a>00408 <span class="comment">// returns quotient, which must fit in a word</span>
<a name="l00409"></a>00409 <span class="keyword">inline</span> word DWord::operator/(word a)
<a name="l00410"></a>00410 {
<a name="l00411"></a>00411 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00412"></a>00412 <span class="preprocessor"></span> <span class="keywordflow">return</span> word(m_whole / a);
<a name="l00413"></a>00413 <span class="preprocessor"> #else</span>
<a name="l00414"></a>00414 <span class="preprocessor"></span> hword r[4];
<a name="l00415"></a>00415 <span class="keywordflow">return</span> DivideFourWordsByTwo<hword, Word>(r, m_halfs.low, m_halfs.high, a).GetWhole();
<a name="l00416"></a>00416 <span class="preprocessor"> #endif</span>
<a name="l00417"></a>00417 <span class="preprocessor"></span>}
<a name="l00418"></a>00418
<a name="l00419"></a>00419 <span class="keyword">inline</span> word DWord::operator%(word a)
<a name="l00420"></a>00420 {
<a name="l00421"></a>00421 <span class="preprocessor"> #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE</span>
<a name="l00422"></a>00422 <span class="preprocessor"></span> <span class="keywordflow">return</span> word(m_whole % a);
<a name="l00423"></a>00423 <span class="preprocessor"> #else</span>
<a name="l00424"></a>00424 <span class="preprocessor"></span> <span class="keywordflow">if</span> (a < (word(1) << (WORD_BITS/2)))
<a name="l00425"></a>00425 {
<a name="l00426"></a>00426 hword h = hword(a);
<a name="l00427"></a>00427 word r = m_halfs.high % h;
<a name="l00428"></a>00428 r = ((m_halfs.low >> (WORD_BITS/2)) + (r << (WORD_BITS/2))) % h;
<a name="l00429"></a>00429 <span class="keywordflow">return</span> hword((hword(m_halfs.low) + (r << (WORD_BITS/2))) % h);
<a name="l00430"></a>00430 }
<a name="l00431"></a>00431 <span class="keywordflow">else</span>
<a name="l00432"></a>00432 {
<a name="l00433"></a>00433 hword r[4];
<a name="l00434"></a>00434 DivideFourWordsByTwo<hword, Word>(r, m_halfs.low, m_halfs.high, a);
<a name="l00435"></a>00435 <span class="keywordflow">return</span> <a class="code" href="class_word.html">Word</a>(r[0], r[1]).GetWhole();
<a name="l00436"></a>00436 }
<a name="l00437"></a>00437 <span class="preprocessor"> #endif</span>
<a name="l00438"></a>00438 <span class="preprocessor"></span>}
<a name="l00439"></a>00439
<a name="l00440"></a>00440 <span class="comment">// ********************************************************</span>
<a name="l00441"></a>00441
<a name="l00442"></a>00442 <span class="comment">// use some tricks to share assembly code between MSVC and GCC</span>
<a name="l00443"></a>00443 <span class="preprocessor">#if defined(__GNUC__)</span>
<a name="l00444"></a>00444 <span class="preprocessor"></span><span class="preprocessor"> #define AddPrologue \</span>
<a name="l00445"></a>00445 <span class="preprocessor"> int result; \</span>
<a name="l00446"></a>00446 <span class="preprocessor"> __asm__ __volatile__ \</span>
<a name="l00447"></a>00447 <span class="preprocessor"> ( \</span>
<a name="l00448"></a>00448 <span class="preprocessor"> ".intel_syntax noprefix;"</span>
<a name="l00449"></a>00449 <span class="preprocessor"></span><span class="preprocessor"> #define AddEpilogue \</span>
<a name="l00450"></a>00450 <span class="preprocessor"> ".att_syntax prefix;" \</span>
<a name="l00451"></a>00451 <span class="preprocessor"> : "=a" (result)\</span>
<a name="l00452"></a>00452 <span class="preprocessor"> : "d" (C), "a" (A), "D" (B), "c" (N) \</span>
<a name="l00453"></a>00453 <span class="preprocessor"> : "%esi", "memory", "cc" \</span>
<a name="l00454"></a>00454 <span class="preprocessor"> );\</span>
<a name="l00455"></a>00455 <span class="preprocessor"> return result;</span>
<a name="l00456"></a>00456 <span class="preprocessor"></span><span class="preprocessor"> #define MulPrologue \</span>
<a name="l00457"></a>00457 <span class="preprocessor"> __asm__ __volatile__ \</span>
<a name="l00458"></a>00458 <span class="preprocessor"> ( \</span>
<a name="l00459"></a>00459 <span class="preprocessor"> ".intel_syntax noprefix;" \</span>
<a name="l00460"></a>00460 <span class="preprocessor"> AS1( push ebx) \</span>
<a name="l00461"></a>00461 <span class="preprocessor"> AS2( mov ebx, edx)</span>
<a name="l00462"></a>00462 <span class="preprocessor"></span><span class="preprocessor"> #define MulEpilogue \</span>
<a name="l00463"></a>00463 <span class="preprocessor"> AS1( pop ebx) \</span>
<a name="l00464"></a>00464 <span class="preprocessor"> ".att_syntax prefix;" \</span>
<a name="l00465"></a>00465 <span class="preprocessor"> : \</span>
<a name="l00466"></a>00466 <span class="preprocessor"> : "d" (s_maskLow16), "c" (C), "a" (A), "D" (B) \</span>
<a name="l00467"></a>00467 <span class="preprocessor"> : "%esi", "memory", "cc" \</span>
<a name="l00468"></a>00468 <span class="preprocessor"> );</span>
<a name="l00469"></a>00469 <span class="preprocessor"></span><span class="preprocessor"> #define SquPrologue MulPrologue</span>
<a name="l00470"></a>00470 <span class="preprocessor"></span><span class="preprocessor"> #define SquEpilogue \</span>
<a name="l00471"></a>00471 <span class="preprocessor"> AS1( pop ebx) \</span>
<a name="l00472"></a>00472 <span class="preprocessor"> ".att_syntax prefix;" \</span>
<a name="l00473"></a>00473 <span class="preprocessor"> : \</span>
<a name="l00474"></a>00474 <span class="preprocessor"> : "d" (s_maskLow16), "c" (C), "a" (A) \</span>
<a name="l00475"></a>00475 <span class="preprocessor"> : "%esi", "%edi", "memory", "cc" \</span>
<a name="l00476"></a>00476 <span class="preprocessor"> );</span>
<a name="l00477"></a>00477 <span class="preprocessor"></span><span class="preprocessor"> #define TopPrologue MulPrologue</span>
<a name="l00478"></a>00478 <span class="preprocessor"></span><span class="preprocessor"> #define TopEpilogue \</span>
<a name="l00479"></a>00479 <span class="preprocessor"> AS1( pop ebx) \</span>
<a name="l00480"></a>00480 <span class="preprocessor"> ".att_syntax prefix;" \</span>
<a name="l00481"></a>00481 <span class="preprocessor"> : \</span>
<a name="l00482"></a>00482 <span class="preprocessor"> : "d" (s_maskLow16), "c" (C), "a" (A), "D" (B), "S" (L) \</span>
<a name="l00483"></a>00483 <span class="preprocessor"> : "memory", "cc" \</span>
<a name="l00484"></a>00484 <span class="preprocessor"> );</span>
<a name="l00485"></a>00485 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00486"></a>00486 <span class="preprocessor"></span><span class="preprocessor"> #define AddPrologue \</span>
<a name="l00487"></a>00487 <span class="preprocessor"> __asm push edi \</span>
<a name="l00488"></a>00488 <span class="preprocessor"> __asm push esi \</span>
<a name="l00489"></a>00489 <span class="preprocessor"> __asm mov eax, [esp+12] \</span>
<a name="l00490"></a>00490 <span class="preprocessor"> __asm mov edi, [esp+16]</span>
<a name="l00491"></a>00491 <span class="preprocessor"></span><span class="preprocessor"> #define AddEpilogue \</span>
<a name="l00492"></a>00492 <span class="preprocessor"> __asm pop esi \</span>
<a name="l00493"></a>00493 <span class="preprocessor"> __asm pop edi \</span>
<a name="l00494"></a>00494 <span class="preprocessor"> __asm ret 8</span>
<a name="l00495"></a>00495 <span class="preprocessor"></span><span class="preprocessor">#if _MSC_VER < 1300</span>
<a name="l00496"></a>00496 <span class="preprocessor"></span><span class="preprocessor"> #define SaveEBX __asm push ebx</span>
<a name="l00497"></a>00497 <span class="preprocessor"></span><span class="preprocessor"> #define RestoreEBX __asm pop ebx</span>
<a name="l00498"></a>00498 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00499"></a>00499 <span class="preprocessor"></span><span class="preprocessor"> #define SaveEBX</span>
<a name="l00500"></a>00500 <span class="preprocessor"></span><span class="preprocessor"> #define RestoreEBX</span>
<a name="l00501"></a>00501 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00502"></a>00502 <span class="preprocessor"></span><span class="preprocessor"> #define SquPrologue \</span>
<a name="l00503"></a>00503 <span class="preprocessor"> AS2( mov eax, A) \</span>
<a name="l00504"></a>00504 <span class="preprocessor"> AS2( mov ecx, C) \</span>
<a name="l00505"></a>00505 <span class="preprocessor"> SaveEBX \</span>
<a name="l00506"></a>00506 <span class="preprocessor"> AS2( lea ebx, s_maskLow16)</span>
<a name="l00507"></a>00507 <span class="preprocessor"></span><span class="preprocessor"> #define MulPrologue \</span>
<a name="l00508"></a>00508 <span class="preprocessor"> AS2( mov eax, A) \</span>
<a name="l00509"></a>00509 <span class="preprocessor"> AS2( mov edi, B) \</span>
<a name="l00510"></a>00510 <span class="preprocessor"> AS2( mov ecx, C) \</span>
<a name="l00511"></a>00511 <span class="preprocessor"> SaveEBX \</span>
<a name="l00512"></a>00512 <span class="preprocessor"> AS2( lea ebx, s_maskLow16)</span>
<a name="l00513"></a>00513 <span class="preprocessor"></span><span class="preprocessor"> #define TopPrologue \</span>
<a name="l00514"></a>00514 <span class="preprocessor"> AS2( mov eax, A) \</span>
<a name="l00515"></a>00515 <span class="preprocessor"> AS2( mov edi, B) \</span>
<a name="l00516"></a>00516 <span class="preprocessor"> AS2( mov ecx, C) \</span>
<a name="l00517"></a>00517 <span class="preprocessor"> AS2( mov esi, L) \</span>
<a name="l00518"></a>00518 <span class="preprocessor"> SaveEBX \</span>
<a name="l00519"></a>00519 <span class="preprocessor"> AS2( lea ebx, s_maskLow16)</span>
<a name="l00520"></a>00520 <span class="preprocessor"></span><span class="preprocessor"> #define SquEpilogue RestoreEBX</span>
<a name="l00521"></a>00521 <span class="preprocessor"></span><span class="preprocessor"> #define MulEpilogue RestoreEBX</span>
<a name="l00522"></a>00522 <span class="preprocessor"></span><span class="preprocessor"> #define TopEpilogue RestoreEBX</span>
<a name="l00523"></a>00523 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00524"></a>00524 <span class="preprocessor"></span>
<a name="l00525"></a>00525 <span class="preprocessor">#ifdef CRYPTOPP_X64_MASM_AVAILABLE</span>
<a name="l00526"></a>00526 <span class="preprocessor"></span><span class="keyword">extern</span> <span class="stringliteral">"C"</span> {
<a name="l00527"></a>00527 <span class="keywordtype">int</span> Baseline_Add(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B);
<a name="l00528"></a>00528 <span class="keywordtype">int</span> Baseline_Sub(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B);
<a name="l00529"></a>00529 }
<a name="l00530"></a>00530 <span class="preprocessor">#elif defined(CRYPTOPP_X64_ASM_AVAILABLE) && defined(__GNUC__) && defined(CRYPTOPP_WORD128_AVAILABLE)</span>
<a name="l00531"></a>00531 <span class="preprocessor"></span><span class="keywordtype">int</span> Baseline_Add(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00532"></a>00532 {
<a name="l00533"></a>00533 word result;
<a name="l00534"></a>00534 __asm__ __volatile__
<a name="l00535"></a>00535 (
<a name="l00536"></a>00536 <span class="stringliteral">".intel_syntax;"</span>
<a name="l00537"></a>00537 AS1( neg %1)
<a name="l00538"></a>00538 ASJ( jz, 1, f)
<a name="l00539"></a>00539 AS2( mov %0,[%3+8*%1])
<a name="l00540"></a>00540 AS2( add %0,[%4+8*%1])
<a name="l00541"></a>00541 AS2( mov [%2+8*%1],%0)
<a name="l00542"></a>00542 ASL(0)
<a name="l00543"></a>00543 AS2( mov %0,[%3+8*%1+8])
<a name="l00544"></a>00544 AS2( adc %0,[%4+8*%1+8])
<a name="l00545"></a>00545 AS2( mov [%2+8*%1+8],%0)
<a name="l00546"></a>00546 AS2( lea %1,[%1+2])
<a name="l00547"></a>00547 ASJ( jrcxz, 1, f)
<a name="l00548"></a>00548 AS2( mov %0,[%3+8*%1])
<a name="l00549"></a>00549 AS2( adc %0,[%4+8*%1])
<a name="l00550"></a>00550 AS2( mov [%2+8*%1],%0)
<a name="l00551"></a>00551 ASJ( jmp, 0, b)
<a name="l00552"></a>00552 ASL(1)
<a name="l00553"></a>00553 AS2( mov %0, 0)
<a name="l00554"></a>00554 AS2( adc %0, %0)
<a name="l00555"></a>00555 <span class="stringliteral">".att_syntax;"</span>
<a name="l00556"></a>00556 : <span class="stringliteral">"=&r"</span> (result), <span class="stringliteral">"+c"</span> (N)
<a name="l00557"></a>00557 : <span class="stringliteral">"r"</span> (C+N), <span class="stringliteral">"r"</span> (A+N), <span class="stringliteral">"r"</span> (B+N)
<a name="l00558"></a>00558 : <span class="stringliteral">"memory"</span>, <span class="stringliteral">"cc"</span>
<a name="l00559"></a>00559 );
<a name="l00560"></a>00560 <span class="keywordflow">return</span> (<span class="keywordtype">int</span>)result;
<a name="l00561"></a>00561 }
<a name="l00562"></a>00562
<a name="l00563"></a>00563 <span class="keywordtype">int</span> Baseline_Sub(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00564"></a>00564 {
<a name="l00565"></a>00565 word result;
<a name="l00566"></a>00566 __asm__ __volatile__
<a name="l00567"></a>00567 (
<a name="l00568"></a>00568 <span class="stringliteral">".intel_syntax;"</span>
<a name="l00569"></a>00569 AS1( neg %1)
<a name="l00570"></a>00570 ASJ( jz, 1, f)
<a name="l00571"></a>00571 AS2( mov %0,[%3+8*%1])
<a name="l00572"></a>00572 AS2( sub %0,[%4+8*%1])
<a name="l00573"></a>00573 AS2( mov [%2+8*%1],%0)
<a name="l00574"></a>00574 ASL(0)
<a name="l00575"></a>00575 AS2( mov %0,[%3+8*%1+8])
<a name="l00576"></a>00576 AS2( sbb %0,[%4+8*%1+8])
<a name="l00577"></a>00577 AS2( mov [%2+8*%1+8],%0)
<a name="l00578"></a>00578 AS2( lea %1,[%1+2])
<a name="l00579"></a>00579 ASJ( jrcxz, 1, f)
<a name="l00580"></a>00580 AS2( mov %0,[%3+8*%1])
<a name="l00581"></a>00581 AS2( sbb %0,[%4+8*%1])
<a name="l00582"></a>00582 AS2( mov [%2+8*%1],%0)
<a name="l00583"></a>00583 ASJ( jmp, 0, b)
<a name="l00584"></a>00584 ASL(1)
<a name="l00585"></a>00585 AS2( mov %0, 0)
<a name="l00586"></a>00586 AS2( adc %0, %0)
<a name="l00587"></a>00587 <span class="stringliteral">".att_syntax;"</span>
<a name="l00588"></a>00588 : <span class="stringliteral">"=&r"</span> (result), <span class="stringliteral">"+c"</span> (N)
<a name="l00589"></a>00589 : <span class="stringliteral">"r"</span> (C+N), <span class="stringliteral">"r"</span> (A+N), <span class="stringliteral">"r"</span> (B+N)
<a name="l00590"></a>00590 : <span class="stringliteral">"memory"</span>, <span class="stringliteral">"cc"</span>
<a name="l00591"></a>00591 );
<a name="l00592"></a>00592 <span class="keywordflow">return</span> (<span class="keywordtype">int</span>)result;
<a name="l00593"></a>00593 }
<a name="l00594"></a>00594 <span class="preprocessor">#elif defined(CRYPTOPP_X86_ASM_AVAILABLE) && CRYPTOPP_BOOL_X86</span>
<a name="l00595"></a>00595 <span class="preprocessor"></span>CRYPTOPP_NAKED <span class="keywordtype">int</span> CRYPTOPP_FASTCALL Baseline_Add(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00596"></a>00596 {
<a name="l00597"></a>00597 AddPrologue
<a name="l00598"></a>00598
<a name="l00599"></a>00599 <span class="comment">// now: eax = A, edi = B, edx = C, ecx = N</span>
<a name="l00600"></a>00600 AS2( lea eax, [eax+4*ecx])
<a name="l00601"></a>00601 AS2( lea edi, [edi+4*ecx])
<a name="l00602"></a>00602 AS2( lea edx, [edx+4*ecx])
<a name="l00603"></a>00603
<a name="l00604"></a>00604 AS1( neg ecx) <span class="comment">// ecx is negative index</span>
<a name="l00605"></a>00605 AS2( test ecx, 2) <span class="comment">// this clears carry flag</span>
<a name="l00606"></a>00606 ASJ( jz, 0, f)
<a name="l00607"></a>00607 AS2( sub ecx, 2)
<a name="l00608"></a>00608 ASJ( jmp, 1, f)
<a name="l00609"></a>00609
<a name="l00610"></a>00610 ASL(0)
<a name="l00611"></a>00611 ASJ( jecxz, 2, f) <span class="comment">// loop until ecx overflows and becomes zero</span>
<a name="l00612"></a>00612 AS2( mov esi,[eax+4*ecx])
<a name="l00613"></a>00613 AS2( adc esi,[edi+4*ecx])
<a name="l00614"></a>00614 AS2( mov [edx+4*ecx],esi)
<a name="l00615"></a>00615 AS2( mov esi,[eax+4*ecx+4])
<a name="l00616"></a>00616 AS2( adc esi,[edi+4*ecx+4])
<a name="l00617"></a>00617 AS2( mov [edx+4*ecx+4],esi)
<a name="l00618"></a>00618 ASL(1)
<a name="l00619"></a>00619 AS2( mov esi,[eax+4*ecx+8])
<a name="l00620"></a>00620 AS2( adc esi,[edi+4*ecx+8])
<a name="l00621"></a>00621 AS2( mov [edx+4*ecx+8],esi)
<a name="l00622"></a>00622 AS2( mov esi,[eax+4*ecx+12])
<a name="l00623"></a>00623 AS2( adc esi,[edi+4*ecx+12])
<a name="l00624"></a>00624 AS2( mov [edx+4*ecx+12],esi)
<a name="l00625"></a>00625
<a name="l00626"></a>00626 AS2( lea ecx,[ecx+4]) <span class="comment">// advance index, avoid inc which causes slowdown on Intel Core 2</span>
<a name="l00627"></a>00627 ASJ( jmp, 0, b)
<a name="l00628"></a>00628
<a name="l00629"></a>00629 ASL(2)
<a name="l00630"></a>00630 AS2( mov eax, 0)
<a name="l00631"></a>00631 AS1( setc al) <span class="comment">// store carry into eax (return result register)</span>
<a name="l00632"></a>00632
<a name="l00633"></a>00633 AddEpilogue
<a name="l00634"></a>00634 }
<a name="l00635"></a>00635
<a name="l00636"></a>00636 CRYPTOPP_NAKED <span class="keywordtype">int</span> CRYPTOPP_FASTCALL Baseline_Sub(<span class="keywordtype">size_t</span> N, word *C, const word *A, const word *B)
<a name="l00637"></a>00637 {
<a name="l00638"></a>00638 AddPrologue
<a name="l00639"></a>00639
<a name="l00640"></a>00640 <span class="comment">// now: eax = A, edi = B, edx = C, ecx = N</span>
<a name="l00641"></a>00641 AS2( lea eax, [eax+4*ecx])
<a name="l00642"></a>00642 AS2( lea edi, [edi+4*ecx])
<a name="l00643"></a>00643 AS2( lea edx, [edx+4*ecx])
<a name="l00644"></a>00644
<a name="l00645"></a>00645 AS1( neg ecx) <span class="comment">// ecx is negative index</span>
<a name="l00646"></a>00646 AS2( test ecx, 2) <span class="comment">// this clears carry flag</span>
<a name="l00647"></a>00647 ASJ( jz, 0, f)
<a name="l00648"></a>00648 AS2( sub ecx, 2)
<a name="l00649"></a>00649 ASJ( jmp, 1, f)
<a name="l00650"></a>00650
<a name="l00651"></a>00651 ASL(0)
<a name="l00652"></a>00652 ASJ( jecxz, 2, f) <span class="comment">// loop until ecx overflows and becomes zero</span>
<a name="l00653"></a>00653 AS2( mov esi,[eax+4*ecx])
<a name="l00654"></a>00654 AS2( sbb esi,[edi+4*ecx])
<a name="l00655"></a>00655 AS2( mov [edx+4*ecx],esi)
<a name="l00656"></a>00656 AS2( mov esi,[eax+4*ecx+4])
<a name="l00657"></a>00657 AS2( sbb esi,[edi+4*ecx+4])
<a name="l00658"></a>00658 AS2( mov [edx+4*ecx+4],esi)
<a name="l00659"></a>00659 ASL(1)
<a name="l00660"></a>00660 AS2( mov esi,[eax+4*ecx+8])
<a name="l00661"></a>00661 AS2( sbb esi,[edi+4*ecx+8])
<a name="l00662"></a>00662 AS2( mov [edx+4*ecx+8],esi)
<a name="l00663"></a>00663 AS2( mov esi,[eax+4*ecx+12])
<a name="l00664"></a>00664 AS2( sbb esi,[edi+4*ecx+12])
<a name="l00665"></a>00665 AS2( mov [edx+4*ecx+12],esi)
<a name="l00666"></a>00666
<a name="l00667"></a>00667 AS2( lea ecx,[ecx+4]) <span class="comment">// advance index, avoid inc which causes slowdown on Intel Core 2</span>
<a name="l00668"></a>00668 ASJ( jmp, 0, b)
<a name="l00669"></a>00669
<a name="l00670"></a>00670 ASL(2)
<a name="l00671"></a>00671 AS2( mov eax, 0)
<a name="l00672"></a>00672 AS1( setc al) <span class="comment">// store carry into eax (return result register)</span>
<a name="l00673"></a>00673
<a name="l00674"></a>00674 AddEpilogue
<a name="l00675"></a>00675 }
<a name="l00676"></a>00676
<a name="l00677"></a>00677 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l00678"></a>00678 <span class="preprocessor"></span>CRYPTOPP_NAKED <span class="keywordtype">int</span> CRYPTOPP_FASTCALL SSE2_Add(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00679"></a>00679 {
<a name="l00680"></a>00680 AddPrologue
<a name="l00681"></a>00681
<a name="l00682"></a>00682 <span class="comment">// now: eax = A, edi = B, edx = C, ecx = N</span>
<a name="l00683"></a>00683 AS2( lea eax, [eax+4*ecx])
<a name="l00684"></a>00684 AS2( lea edi, [edi+4*ecx])
<a name="l00685"></a>00685 AS2( lea edx, [edx+4*ecx])
<a name="l00686"></a>00686
<a name="l00687"></a>00687 AS1( neg ecx) <span class="comment">// ecx is negative index</span>
<a name="l00688"></a>00688 AS2( pxor mm2, mm2)
<a name="l00689"></a>00689 ASJ( jz, 2, f)
<a name="l00690"></a>00690 AS2( test ecx, 2) <span class="comment">// this clears carry flag</span>
<a name="l00691"></a>00691 ASJ( jz, 0, f)
<a name="l00692"></a>00692 AS2( sub ecx, 2)
<a name="l00693"></a>00693 ASJ( jmp, 1, f)
<a name="l00694"></a>00694
<a name="l00695"></a>00695 ASL(0)
<a name="l00696"></a>00696 AS2( movd mm0, DWORD PTR [eax+4*ecx])
<a name="l00697"></a>00697 AS2( movd mm1, DWORD PTR [edi+4*ecx])
<a name="l00698"></a>00698 AS2( paddq mm0, mm1)
<a name="l00699"></a>00699 AS2( paddq mm2, mm0)
<a name="l00700"></a>00700 AS2( movd DWORD PTR [edx+4*ecx], mm2)
<a name="l00701"></a>00701 AS2( psrlq mm2, 32)
<a name="l00702"></a>00702
<a name="l00703"></a>00703 AS2( movd mm0, DWORD PTR [eax+4*ecx+4])
<a name="l00704"></a>00704 AS2( movd mm1, DWORD PTR [edi+4*ecx+4])
<a name="l00705"></a>00705 AS2( paddq mm0, mm1)
<a name="l00706"></a>00706 AS2( paddq mm2, mm0)
<a name="l00707"></a>00707 AS2( movd DWORD PTR [edx+4*ecx+4], mm2)
<a name="l00708"></a>00708 AS2( psrlq mm2, 32)
<a name="l00709"></a>00709
<a name="l00710"></a>00710 ASL(1)
<a name="l00711"></a>00711 AS2( movd mm0, DWORD PTR [eax+4*ecx+8])
<a name="l00712"></a>00712 AS2( movd mm1, DWORD PTR [edi+4*ecx+8])
<a name="l00713"></a>00713 AS2( paddq mm0, mm1)
<a name="l00714"></a>00714 AS2( paddq mm2, mm0)
<a name="l00715"></a>00715 AS2( movd DWORD PTR [edx+4*ecx+8], mm2)
<a name="l00716"></a>00716 AS2( psrlq mm2, 32)
<a name="l00717"></a>00717
<a name="l00718"></a>00718 AS2( movd mm0, DWORD PTR [eax+4*ecx+12])
<a name="l00719"></a>00719 AS2( movd mm1, DWORD PTR [edi+4*ecx+12])
<a name="l00720"></a>00720 AS2( paddq mm0, mm1)
<a name="l00721"></a>00721 AS2( paddq mm2, mm0)
<a name="l00722"></a>00722 AS2( movd DWORD PTR [edx+4*ecx+12], mm2)
<a name="l00723"></a>00723 AS2( psrlq mm2, 32)
<a name="l00724"></a>00724
<a name="l00725"></a>00725 AS2( add ecx, 4)
<a name="l00726"></a>00726 ASJ( jnz, 0, b)
<a name="l00727"></a>00727
<a name="l00728"></a>00728 ASL(2)
<a name="l00729"></a>00729 AS2( movd eax, mm2)
<a name="l00730"></a>00730 AS1( emms)
<a name="l00731"></a>00731
<a name="l00732"></a>00732 AddEpilogue
<a name="l00733"></a>00733 }
<a name="l00734"></a>00734 CRYPTOPP_NAKED <span class="keywordtype">int</span> CRYPTOPP_FASTCALL SSE2_Sub(<span class="keywordtype">size_t</span> N, word *C, const word *A, const word *B)
<a name="l00735"></a>00735 {
<a name="l00736"></a>00736 AddPrologue
<a name="l00737"></a>00737
<a name="l00738"></a>00738 <span class="comment">// now: eax = A, edi = B, edx = C, ecx = N</span>
<a name="l00739"></a>00739 AS2( lea eax, [eax+4*ecx])
<a name="l00740"></a>00740 AS2( lea edi, [edi+4*ecx])
<a name="l00741"></a>00741 AS2( lea edx, [edx+4*ecx])
<a name="l00742"></a>00742
<a name="l00743"></a>00743 AS1( neg ecx) <span class="comment">// ecx is negative index</span>
<a name="l00744"></a>00744 AS2( pxor mm2, mm2)
<a name="l00745"></a>00745 ASJ( jz, 2, f)
<a name="l00746"></a>00746 AS2( test ecx, 2) <span class="comment">// this clears carry flag</span>
<a name="l00747"></a>00747 ASJ( jz, 0, f)
<a name="l00748"></a>00748 AS2( sub ecx, 2)
<a name="l00749"></a>00749 ASJ( jmp, 1, f)
<a name="l00750"></a>00750
<a name="l00751"></a>00751 ASL(0)
<a name="l00752"></a>00752 AS2( movd mm0, DWORD PTR [eax+4*ecx])
<a name="l00753"></a>00753 AS2( movd mm1, DWORD PTR [edi+4*ecx])
<a name="l00754"></a>00754 AS2( psubq mm0, mm1)
<a name="l00755"></a>00755 AS2( psubq mm0, mm2)
<a name="l00756"></a>00756 AS2( movd DWORD PTR [edx+4*ecx], mm0)
<a name="l00757"></a>00757 AS2( psrlq mm0, 63)
<a name="l00758"></a>00758
<a name="l00759"></a>00759 AS2( movd mm2, DWORD PTR [eax+4*ecx+4])
<a name="l00760"></a>00760 AS2( movd mm1, DWORD PTR [edi+4*ecx+4])
<a name="l00761"></a>00761 AS2( psubq mm2, mm1)
<a name="l00762"></a>00762 AS2( psubq mm2, mm0)
<a name="l00763"></a>00763 AS2( movd DWORD PTR [edx+4*ecx+4], mm2)
<a name="l00764"></a>00764 AS2( psrlq mm2, 63)
<a name="l00765"></a>00765
<a name="l00766"></a>00766 ASL(1)
<a name="l00767"></a>00767 AS2( movd mm0, DWORD PTR [eax+4*ecx+8])
<a name="l00768"></a>00768 AS2( movd mm1, DWORD PTR [edi+4*ecx+8])
<a name="l00769"></a>00769 AS2( psubq mm0, mm1)
<a name="l00770"></a>00770 AS2( psubq mm0, mm2)
<a name="l00771"></a>00771 AS2( movd DWORD PTR [edx+4*ecx+8], mm0)
<a name="l00772"></a>00772 AS2( psrlq mm0, 63)
<a name="l00773"></a>00773
<a name="l00774"></a>00774 AS2( movd mm2, DWORD PTR [eax+4*ecx+12])
<a name="l00775"></a>00775 AS2( movd mm1, DWORD PTR [edi+4*ecx+12])
<a name="l00776"></a>00776 AS2( psubq mm2, mm1)
<a name="l00777"></a>00777 AS2( psubq mm2, mm0)
<a name="l00778"></a>00778 AS2( movd DWORD PTR [edx+4*ecx+12], mm2)
<a name="l00779"></a>00779 AS2( psrlq mm2, 63)
<a name="l00780"></a>00780
<a name="l00781"></a>00781 AS2( add ecx, 4)
<a name="l00782"></a>00782 ASJ( jnz, 0, b)
<a name="l00783"></a>00783
<a name="l00784"></a>00784 ASL(2)
<a name="l00785"></a>00785 AS2( movd eax, mm2)
<a name="l00786"></a>00786 AS1( emms)
<a name="l00787"></a>00787
<a name="l00788"></a>00788 AddEpilogue
<a name="l00789"></a>00789 }
<a name="l00790"></a>00790 <span class="preprocessor">#endif // #if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE</span>
<a name="l00791"></a>00791 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00792"></a>00792 <span class="preprocessor"></span><span class="keywordtype">int</span> CRYPTOPP_FASTCALL Baseline_Add(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00793"></a>00793 {
<a name="l00794"></a>00794 assert (N%2 == 0);
<a name="l00795"></a>00795
<a name="l00796"></a>00796 Declare2Words(u);
<a name="l00797"></a>00797 AssignWord(u, 0);
<a name="l00798"></a>00798 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=0; i<N; i+=2)
<a name="l00799"></a>00799 {
<a name="l00800"></a>00800 AddWithCarry(u, A[i], B[i]);
<a name="l00801"></a>00801 C[i] = LowWord(u);
<a name="l00802"></a>00802 AddWithCarry(u, A[i+1], B[i+1]);
<a name="l00803"></a>00803 C[i+1] = LowWord(u);
<a name="l00804"></a>00804 }
<a name="l00805"></a>00805 <span class="keywordflow">return</span> int(GetCarry(u));
<a name="l00806"></a>00806 }
<a name="l00807"></a>00807
<a name="l00808"></a>00808 <span class="keywordtype">int</span> CRYPTOPP_FASTCALL Baseline_Sub(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l00809"></a>00809 {
<a name="l00810"></a>00810 assert (N%2 == 0);
<a name="l00811"></a>00811
<a name="l00812"></a>00812 Declare2Words(u);
<a name="l00813"></a>00813 AssignWord(u, 0);
<a name="l00814"></a>00814 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=0; i<N; i+=2)
<a name="l00815"></a>00815 {
<a name="l00816"></a>00816 SubtractWithBorrow(u, A[i], B[i]);
<a name="l00817"></a>00817 C[i] = LowWord(u);
<a name="l00818"></a>00818 SubtractWithBorrow(u, A[i+1], B[i+1]);
<a name="l00819"></a>00819 C[i+1] = LowWord(u);
<a name="l00820"></a>00820 }
<a name="l00821"></a>00821 <span class="keywordflow">return</span> int(GetBorrow(u));
<a name="l00822"></a>00822 }
<a name="l00823"></a>00823 <span class="preprocessor">#endif</span>
<a name="l00824"></a>00824 <span class="preprocessor"></span>
<a name="l00825"></a>00825 <span class="keyword">static</span> word LinearMultiply(word *C, <span class="keyword">const</span> word *A, word B, <span class="keywordtype">size_t</span> N)
<a name="l00826"></a>00826 {
<a name="l00827"></a>00827 word carry=0;
<a name="l00828"></a>00828 <span class="keywordflow">for</span>(<span class="keywordtype">unsigned</span> i=0; i<N; i++)
<a name="l00829"></a>00829 {
<a name="l00830"></a>00830 Declare2Words(p);
<a name="l00831"></a>00831 MultiplyWords(p, A[i], B);
<a name="l00832"></a>00832 Acc2WordsBy1(p, carry);
<a name="l00833"></a>00833 C[i] = LowWord(p);
<a name="l00834"></a>00834 carry = HighWord(p);
<a name="l00835"></a>00835 }
<a name="l00836"></a>00836 <span class="keywordflow">return</span> carry;
<a name="l00837"></a>00837 }
<a name="l00838"></a>00838
<a name="l00839"></a>00839 <span class="preprocessor">#ifndef CRYPTOPP_DOXYGEN_PROCESSING</span>
<a name="l00840"></a>00840 <span class="preprocessor"></span>
<a name="l00841"></a>00841 <span class="preprocessor">#define Mul_2 \</span>
<a name="l00842"></a>00842 <span class="preprocessor"> Mul_Begin(2) \</span>
<a name="l00843"></a>00843 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00844"></a>00844 <span class="preprocessor"> Mul_End(1, 1)</span>
<a name="l00845"></a>00845 <span class="preprocessor"></span>
<a name="l00846"></a>00846 <span class="preprocessor">#define Mul_4 \</span>
<a name="l00847"></a>00847 <span class="preprocessor"> Mul_Begin(4) \</span>
<a name="l00848"></a>00848 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00849"></a>00849 <span class="preprocessor"> Mul_SaveAcc(1, 0, 2) Mul_Acc(1, 1) Mul_Acc(2, 0) \</span>
<a name="l00850"></a>00850 <span class="preprocessor"> Mul_SaveAcc(2, 0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \</span>
<a name="l00851"></a>00851 <span class="preprocessor"> Mul_SaveAcc(3, 1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) \</span>
<a name="l00852"></a>00852 <span class="preprocessor"> Mul_SaveAcc(4, 2, 3) Mul_Acc(3, 2) \</span>
<a name="l00853"></a>00853 <span class="preprocessor"> Mul_End(5, 3)</span>
<a name="l00854"></a>00854 <span class="preprocessor"></span>
<a name="l00855"></a>00855 <span class="preprocessor">#define Mul_8 \</span>
<a name="l00856"></a>00856 <span class="preprocessor"> Mul_Begin(8) \</span>
<a name="l00857"></a>00857 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00858"></a>00858 <span class="preprocessor"> Mul_SaveAcc(1, 0, 2) Mul_Acc(1, 1) Mul_Acc(2, 0) \</span>
<a name="l00859"></a>00859 <span class="preprocessor"> Mul_SaveAcc(2, 0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \</span>
<a name="l00860"></a>00860 <span class="preprocessor"> Mul_SaveAcc(3, 0, 4) Mul_Acc(1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) Mul_Acc(4, 0) \</span>
<a name="l00861"></a>00861 <span class="preprocessor"> Mul_SaveAcc(4, 0, 5) Mul_Acc(1, 4) Mul_Acc(2, 3) Mul_Acc(3, 2) Mul_Acc(4, 1) Mul_Acc(5, 0) \</span>
<a name="l00862"></a>00862 <span class="preprocessor"> Mul_SaveAcc(5, 0, 6) Mul_Acc(1, 5) Mul_Acc(2, 4) Mul_Acc(3, 3) Mul_Acc(4, 2) Mul_Acc(5, 1) Mul_Acc(6, 0) \</span>
<a name="l00863"></a>00863 <span class="preprocessor"> Mul_SaveAcc(6, 0, 7) Mul_Acc(1, 6) Mul_Acc(2, 5) Mul_Acc(3, 4) Mul_Acc(4, 3) Mul_Acc(5, 2) Mul_Acc(6, 1) Mul_Acc(7, 0) \</span>
<a name="l00864"></a>00864 <span class="preprocessor"> Mul_SaveAcc(7, 1, 7) Mul_Acc(2, 6) Mul_Acc(3, 5) Mul_Acc(4, 4) Mul_Acc(5, 3) Mul_Acc(6, 2) Mul_Acc(7, 1) \</span>
<a name="l00865"></a>00865 <span class="preprocessor"> Mul_SaveAcc(8, 2, 7) Mul_Acc(3, 6) Mul_Acc(4, 5) Mul_Acc(5, 4) Mul_Acc(6, 3) Mul_Acc(7, 2) \</span>
<a name="l00866"></a>00866 <span class="preprocessor"> Mul_SaveAcc(9, 3, 7) Mul_Acc(4, 6) Mul_Acc(5, 5) Mul_Acc(6, 4) Mul_Acc(7, 3) \</span>
<a name="l00867"></a>00867 <span class="preprocessor"> Mul_SaveAcc(10, 4, 7) Mul_Acc(5, 6) Mul_Acc(6, 5) Mul_Acc(7, 4) \</span>
<a name="l00868"></a>00868 <span class="preprocessor"> Mul_SaveAcc(11, 5, 7) Mul_Acc(6, 6) Mul_Acc(7, 5) \</span>
<a name="l00869"></a>00869 <span class="preprocessor"> Mul_SaveAcc(12, 6, 7) Mul_Acc(7, 6) \</span>
<a name="l00870"></a>00870 <span class="preprocessor"> Mul_End(13, 7)</span>
<a name="l00871"></a>00871 <span class="preprocessor"></span>
<a name="l00872"></a>00872 <span class="preprocessor">#define Mul_16 \</span>
<a name="l00873"></a>00873 <span class="preprocessor"> Mul_Begin(16) \</span>
<a name="l00874"></a>00874 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00875"></a>00875 <span class="preprocessor"> Mul_SaveAcc(1, 0, 2) Mul_Acc(1, 1) Mul_Acc(2, 0) \</span>
<a name="l00876"></a>00876 <span class="preprocessor"> Mul_SaveAcc(2, 0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \</span>
<a name="l00877"></a>00877 <span class="preprocessor"> Mul_SaveAcc(3, 0, 4) Mul_Acc(1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) Mul_Acc(4, 0) \</span>
<a name="l00878"></a>00878 <span class="preprocessor"> Mul_SaveAcc(4, 0, 5) Mul_Acc(1, 4) Mul_Acc(2, 3) Mul_Acc(3, 2) Mul_Acc(4, 1) Mul_Acc(5, 0) \</span>
<a name="l00879"></a>00879 <span class="preprocessor"> Mul_SaveAcc(5, 0, 6) Mul_Acc(1, 5) Mul_Acc(2, 4) Mul_Acc(3, 3) Mul_Acc(4, 2) Mul_Acc(5, 1) Mul_Acc(6, 0) \</span>
<a name="l00880"></a>00880 <span class="preprocessor"> Mul_SaveAcc(6, 0, 7) Mul_Acc(1, 6) Mul_Acc(2, 5) Mul_Acc(3, 4) Mul_Acc(4, 3) Mul_Acc(5, 2) Mul_Acc(6, 1) Mul_Acc(7, 0) \</span>
<a name="l00881"></a>00881 <span class="preprocessor"> Mul_SaveAcc(7, 0, 8) Mul_Acc(1, 7) Mul_Acc(2, 6) Mul_Acc(3, 5) Mul_Acc(4, 4) Mul_Acc(5, 3) Mul_Acc(6, 2) Mul_Acc(7, 1) Mul_Acc(8, 0) \</span>
<a name="l00882"></a>00882 <span class="preprocessor"> Mul_SaveAcc(8, 0, 9) Mul_Acc(1, 8) Mul_Acc(2, 7) Mul_Acc(3, 6) Mul_Acc(4, 5) Mul_Acc(5, 4) Mul_Acc(6, 3) Mul_Acc(7, 2) Mul_Acc(8, 1) Mul_Acc(9, 0) \</span>
<a name="l00883"></a>00883 <span class="preprocessor"> Mul_SaveAcc(9, 0, 10) Mul_Acc(1, 9) Mul_Acc(2, 8) Mul_Acc(3, 7) Mul_Acc(4, 6) Mul_Acc(5, 5) Mul_Acc(6, 4) Mul_Acc(7, 3) Mul_Acc(8, 2) Mul_Acc(9, 1) Mul_Acc(10, 0) \</span>
<a name="l00884"></a>00884 <span class="preprocessor"> Mul_SaveAcc(10, 0, 11) Mul_Acc(1, 10) Mul_Acc(2, 9) Mul_Acc(3, 8) Mul_Acc(4, 7) Mul_Acc(5, 6) Mul_Acc(6, 5) Mul_Acc(7, 4) Mul_Acc(8, 3) Mul_Acc(9, 2) Mul_Acc(10, 1) Mul_Acc(11, 0) \</span>
<a name="l00885"></a>00885 <span class="preprocessor"> Mul_SaveAcc(11, 0, 12) Mul_Acc(1, 11) Mul_Acc(2, 10) Mul_Acc(3, 9) Mul_Acc(4, 8) Mul_Acc(5, 7) Mul_Acc(6, 6) Mul_Acc(7, 5) Mul_Acc(8, 4) Mul_Acc(9, 3) Mul_Acc(10, 2) Mul_Acc(11, 1) Mul_Acc(12, 0) \</span>
<a name="l00886"></a>00886 <span class="preprocessor"> Mul_SaveAcc(12, 0, 13) Mul_Acc(1, 12) Mul_Acc(2, 11) Mul_Acc(3, 10) Mul_Acc(4, 9) Mul_Acc(5, 8) Mul_Acc(6, 7) Mul_Acc(7, 6) Mul_Acc(8, 5) Mul_Acc(9, 4) Mul_Acc(10, 3) Mul_Acc(11, 2) Mul_Acc(12, 1) Mul_Acc(13, 0) \</span>
<a name="l00887"></a>00887 <span class="preprocessor"> Mul_SaveAcc(13, 0, 14) Mul_Acc(1, 13) Mul_Acc(2, 12) Mul_Acc(3, 11) Mul_Acc(4, 10) Mul_Acc(5, 9) Mul_Acc(6, 8) Mul_Acc(7, 7) Mul_Acc(8, 6) Mul_Acc(9, 5) Mul_Acc(10, 4) Mul_Acc(11, 3) Mul_Acc(12, 2) Mul_Acc(13, 1) Mul_Acc(14, 0) \</span>
<a name="l00888"></a>00888 <span class="preprocessor"> Mul_SaveAcc(14, 0, 15) Mul_Acc(1, 14) Mul_Acc(2, 13) Mul_Acc(3, 12) Mul_Acc(4, 11) Mul_Acc(5, 10) Mul_Acc(6, 9) Mul_Acc(7, 8) Mul_Acc(8, 7) Mul_Acc(9, 6) Mul_Acc(10, 5) Mul_Acc(11, 4) Mul_Acc(12, 3) Mul_Acc(13, 2) Mul_Acc(14, 1) Mul_Acc(15, 0) \</span>
<a name="l00889"></a>00889 <span class="preprocessor"> Mul_SaveAcc(15, 1, 15) Mul_Acc(2, 14) Mul_Acc(3, 13) Mul_Acc(4, 12) Mul_Acc(5, 11) Mul_Acc(6, 10) Mul_Acc(7, 9) Mul_Acc(8, 8) Mul_Acc(9, 7) Mul_Acc(10, 6) Mul_Acc(11, 5) Mul_Acc(12, 4) Mul_Acc(13, 3) Mul_Acc(14, 2) Mul_Acc(15, 1) \</span>
<a name="l00890"></a>00890 <span class="preprocessor"> Mul_SaveAcc(16, 2, 15) Mul_Acc(3, 14) Mul_Acc(4, 13) Mul_Acc(5, 12) Mul_Acc(6, 11) Mul_Acc(7, 10) Mul_Acc(8, 9) Mul_Acc(9, 8) Mul_Acc(10, 7) Mul_Acc(11, 6) Mul_Acc(12, 5) Mul_Acc(13, 4) Mul_Acc(14, 3) Mul_Acc(15, 2) \</span>
<a name="l00891"></a>00891 <span class="preprocessor"> Mul_SaveAcc(17, 3, 15) Mul_Acc(4, 14) Mul_Acc(5, 13) Mul_Acc(6, 12) Mul_Acc(7, 11) Mul_Acc(8, 10) Mul_Acc(9, 9) Mul_Acc(10, 8) Mul_Acc(11, 7) Mul_Acc(12, 6) Mul_Acc(13, 5) Mul_Acc(14, 4) Mul_Acc(15, 3) \</span>
<a name="l00892"></a>00892 <span class="preprocessor"> Mul_SaveAcc(18, 4, 15) Mul_Acc(5, 14) Mul_Acc(6, 13) Mul_Acc(7, 12) Mul_Acc(8, 11) Mul_Acc(9, 10) Mul_Acc(10, 9) Mul_Acc(11, 8) Mul_Acc(12, 7) Mul_Acc(13, 6) Mul_Acc(14, 5) Mul_Acc(15, 4) \</span>
<a name="l00893"></a>00893 <span class="preprocessor"> Mul_SaveAcc(19, 5, 15) Mul_Acc(6, 14) Mul_Acc(7, 13) Mul_Acc(8, 12) Mul_Acc(9, 11) Mul_Acc(10, 10) Mul_Acc(11, 9) Mul_Acc(12, 8) Mul_Acc(13, 7) Mul_Acc(14, 6) Mul_Acc(15, 5) \</span>
<a name="l00894"></a>00894 <span class="preprocessor"> Mul_SaveAcc(20, 6, 15) Mul_Acc(7, 14) Mul_Acc(8, 13) Mul_Acc(9, 12) Mul_Acc(10, 11) Mul_Acc(11, 10) Mul_Acc(12, 9) Mul_Acc(13, 8) Mul_Acc(14, 7) Mul_Acc(15, 6) \</span>
<a name="l00895"></a>00895 <span class="preprocessor"> Mul_SaveAcc(21, 7, 15) Mul_Acc(8, 14) Mul_Acc(9, 13) Mul_Acc(10, 12) Mul_Acc(11, 11) Mul_Acc(12, 10) Mul_Acc(13, 9) Mul_Acc(14, 8) Mul_Acc(15, 7) \</span>
<a name="l00896"></a>00896 <span class="preprocessor"> Mul_SaveAcc(22, 8, 15) Mul_Acc(9, 14) Mul_Acc(10, 13) Mul_Acc(11, 12) Mul_Acc(12, 11) Mul_Acc(13, 10) Mul_Acc(14, 9) Mul_Acc(15, 8) \</span>
<a name="l00897"></a>00897 <span class="preprocessor"> Mul_SaveAcc(23, 9, 15) Mul_Acc(10, 14) Mul_Acc(11, 13) Mul_Acc(12, 12) Mul_Acc(13, 11) Mul_Acc(14, 10) Mul_Acc(15, 9) \</span>
<a name="l00898"></a>00898 <span class="preprocessor"> Mul_SaveAcc(24, 10, 15) Mul_Acc(11, 14) Mul_Acc(12, 13) Mul_Acc(13, 12) Mul_Acc(14, 11) Mul_Acc(15, 10) \</span>
<a name="l00899"></a>00899 <span class="preprocessor"> Mul_SaveAcc(25, 11, 15) Mul_Acc(12, 14) Mul_Acc(13, 13) Mul_Acc(14, 12) Mul_Acc(15, 11) \</span>
<a name="l00900"></a>00900 <span class="preprocessor"> Mul_SaveAcc(26, 12, 15) Mul_Acc(13, 14) Mul_Acc(14, 13) Mul_Acc(15, 12) \</span>
<a name="l00901"></a>00901 <span class="preprocessor"> Mul_SaveAcc(27, 13, 15) Mul_Acc(14, 14) Mul_Acc(15, 13) \</span>
<a name="l00902"></a>00902 <span class="preprocessor"> Mul_SaveAcc(28, 14, 15) Mul_Acc(15, 14) \</span>
<a name="l00903"></a>00903 <span class="preprocessor"> Mul_End(29, 15)</span>
<a name="l00904"></a>00904 <span class="preprocessor"></span>
<a name="l00905"></a>00905 <span class="preprocessor">#define Squ_2 \</span>
<a name="l00906"></a>00906 <span class="preprocessor"> Squ_Begin(2) \</span>
<a name="l00907"></a>00907 <span class="preprocessor"> Squ_End(2)</span>
<a name="l00908"></a>00908 <span class="preprocessor"></span>
<a name="l00909"></a>00909 <span class="preprocessor">#define Squ_4 \</span>
<a name="l00910"></a>00910 <span class="preprocessor"> Squ_Begin(4) \</span>
<a name="l00911"></a>00911 <span class="preprocessor"> Squ_SaveAcc(1, 0, 2) Squ_Diag(1) \</span>
<a name="l00912"></a>00912 <span class="preprocessor"> Squ_SaveAcc(2, 0, 3) Squ_Acc(1, 2) Squ_NonDiag \</span>
<a name="l00913"></a>00913 <span class="preprocessor"> Squ_SaveAcc(3, 1, 3) Squ_Diag(2) \</span>
<a name="l00914"></a>00914 <span class="preprocessor"> Squ_SaveAcc(4, 2, 3) Squ_NonDiag \</span>
<a name="l00915"></a>00915 <span class="preprocessor"> Squ_End(4)</span>
<a name="l00916"></a>00916 <span class="preprocessor"></span>
<a name="l00917"></a>00917 <span class="preprocessor">#define Squ_8 \</span>
<a name="l00918"></a>00918 <span class="preprocessor"> Squ_Begin(8) \</span>
<a name="l00919"></a>00919 <span class="preprocessor"> Squ_SaveAcc(1, 0, 2) Squ_Diag(1) \</span>
<a name="l00920"></a>00920 <span class="preprocessor"> Squ_SaveAcc(2, 0, 3) Squ_Acc(1, 2) Squ_NonDiag \</span>
<a name="l00921"></a>00921 <span class="preprocessor"> Squ_SaveAcc(3, 0, 4) Squ_Acc(1, 3) Squ_Diag(2) \</span>
<a name="l00922"></a>00922 <span class="preprocessor"> Squ_SaveAcc(4, 0, 5) Squ_Acc(1, 4) Squ_Acc(2, 3) Squ_NonDiag \</span>
<a name="l00923"></a>00923 <span class="preprocessor"> Squ_SaveAcc(5, 0, 6) Squ_Acc(1, 5) Squ_Acc(2, 4) Squ_Diag(3) \</span>
<a name="l00924"></a>00924 <span class="preprocessor"> Squ_SaveAcc(6, 0, 7) Squ_Acc(1, 6) Squ_Acc(2, 5) Squ_Acc(3, 4) Squ_NonDiag \</span>
<a name="l00925"></a>00925 <span class="preprocessor"> Squ_SaveAcc(7, 1, 7) Squ_Acc(2, 6) Squ_Acc(3, 5) Squ_Diag(4) \</span>
<a name="l00926"></a>00926 <span class="preprocessor"> Squ_SaveAcc(8, 2, 7) Squ_Acc(3, 6) Squ_Acc(4, 5) Squ_NonDiag \</span>
<a name="l00927"></a>00927 <span class="preprocessor"> Squ_SaveAcc(9, 3, 7) Squ_Acc(4, 6) Squ_Diag(5) \</span>
<a name="l00928"></a>00928 <span class="preprocessor"> Squ_SaveAcc(10, 4, 7) Squ_Acc(5, 6) Squ_NonDiag \</span>
<a name="l00929"></a>00929 <span class="preprocessor"> Squ_SaveAcc(11, 5, 7) Squ_Diag(6) \</span>
<a name="l00930"></a>00930 <span class="preprocessor"> Squ_SaveAcc(12, 6, 7) Squ_NonDiag \</span>
<a name="l00931"></a>00931 <span class="preprocessor"> Squ_End(8)</span>
<a name="l00932"></a>00932 <span class="preprocessor"></span>
<a name="l00933"></a>00933 <span class="preprocessor">#define Squ_16 \</span>
<a name="l00934"></a>00934 <span class="preprocessor"> Squ_Begin(16) \</span>
<a name="l00935"></a>00935 <span class="preprocessor"> Squ_SaveAcc(1, 0, 2) Squ_Diag(1) \</span>
<a name="l00936"></a>00936 <span class="preprocessor"> Squ_SaveAcc(2, 0, 3) Squ_Acc(1, 2) Squ_NonDiag \</span>
<a name="l00937"></a>00937 <span class="preprocessor"> Squ_SaveAcc(3, 0, 4) Squ_Acc(1, 3) Squ_Diag(2) \</span>
<a name="l00938"></a>00938 <span class="preprocessor"> Squ_SaveAcc(4, 0, 5) Squ_Acc(1, 4) Squ_Acc(2, 3) Squ_NonDiag \</span>
<a name="l00939"></a>00939 <span class="preprocessor"> Squ_SaveAcc(5, 0, 6) Squ_Acc(1, 5) Squ_Acc(2, 4) Squ_Diag(3) \</span>
<a name="l00940"></a>00940 <span class="preprocessor"> Squ_SaveAcc(6, 0, 7) Squ_Acc(1, 6) Squ_Acc(2, 5) Squ_Acc(3, 4) Squ_NonDiag \</span>
<a name="l00941"></a>00941 <span class="preprocessor"> Squ_SaveAcc(7, 0, 8) Squ_Acc(1, 7) Squ_Acc(2, 6) Squ_Acc(3, 5) Squ_Diag(4) \</span>
<a name="l00942"></a>00942 <span class="preprocessor"> Squ_SaveAcc(8, 0, 9) Squ_Acc(1, 8) Squ_Acc(2, 7) Squ_Acc(3, 6) Squ_Acc(4, 5) Squ_NonDiag \</span>
<a name="l00943"></a>00943 <span class="preprocessor"> Squ_SaveAcc(9, 0, 10) Squ_Acc(1, 9) Squ_Acc(2, 8) Squ_Acc(3, 7) Squ_Acc(4, 6) Squ_Diag(5) \</span>
<a name="l00944"></a>00944 <span class="preprocessor"> Squ_SaveAcc(10, 0, 11) Squ_Acc(1, 10) Squ_Acc(2, 9) Squ_Acc(3, 8) Squ_Acc(4, 7) Squ_Acc(5, 6) Squ_NonDiag \</span>
<a name="l00945"></a>00945 <span class="preprocessor"> Squ_SaveAcc(11, 0, 12) Squ_Acc(1, 11) Squ_Acc(2, 10) Squ_Acc(3, 9) Squ_Acc(4, 8) Squ_Acc(5, 7) Squ_Diag(6) \</span>
<a name="l00946"></a>00946 <span class="preprocessor"> Squ_SaveAcc(12, 0, 13) Squ_Acc(1, 12) Squ_Acc(2, 11) Squ_Acc(3, 10) Squ_Acc(4, 9) Squ_Acc(5, 8) Squ_Acc(6, 7) Squ_NonDiag \</span>
<a name="l00947"></a>00947 <span class="preprocessor"> Squ_SaveAcc(13, 0, 14) Squ_Acc(1, 13) Squ_Acc(2, 12) Squ_Acc(3, 11) Squ_Acc(4, 10) Squ_Acc(5, 9) Squ_Acc(6, 8) Squ_Diag(7) \</span>
<a name="l00948"></a>00948 <span class="preprocessor"> Squ_SaveAcc(14, 0, 15) Squ_Acc(1, 14) Squ_Acc(2, 13) Squ_Acc(3, 12) Squ_Acc(4, 11) Squ_Acc(5, 10) Squ_Acc(6, 9) Squ_Acc(7, 8) Squ_NonDiag \</span>
<a name="l00949"></a>00949 <span class="preprocessor"> Squ_SaveAcc(15, 1, 15) Squ_Acc(2, 14) Squ_Acc(3, 13) Squ_Acc(4, 12) Squ_Acc(5, 11) Squ_Acc(6, 10) Squ_Acc(7, 9) Squ_Diag(8) \</span>
<a name="l00950"></a>00950 <span class="preprocessor"> Squ_SaveAcc(16, 2, 15) Squ_Acc(3, 14) Squ_Acc(4, 13) Squ_Acc(5, 12) Squ_Acc(6, 11) Squ_Acc(7, 10) Squ_Acc(8, 9) Squ_NonDiag \</span>
<a name="l00951"></a>00951 <span class="preprocessor"> Squ_SaveAcc(17, 3, 15) Squ_Acc(4, 14) Squ_Acc(5, 13) Squ_Acc(6, 12) Squ_Acc(7, 11) Squ_Acc(8, 10) Squ_Diag(9) \</span>
<a name="l00952"></a>00952 <span class="preprocessor"> Squ_SaveAcc(18, 4, 15) Squ_Acc(5, 14) Squ_Acc(6, 13) Squ_Acc(7, 12) Squ_Acc(8, 11) Squ_Acc(9, 10) Squ_NonDiag \</span>
<a name="l00953"></a>00953 <span class="preprocessor"> Squ_SaveAcc(19, 5, 15) Squ_Acc(6, 14) Squ_Acc(7, 13) Squ_Acc(8, 12) Squ_Acc(9, 11) Squ_Diag(10) \</span>
<a name="l00954"></a>00954 <span class="preprocessor"> Squ_SaveAcc(20, 6, 15) Squ_Acc(7, 14) Squ_Acc(8, 13) Squ_Acc(9, 12) Squ_Acc(10, 11) Squ_NonDiag \</span>
<a name="l00955"></a>00955 <span class="preprocessor"> Squ_SaveAcc(21, 7, 15) Squ_Acc(8, 14) Squ_Acc(9, 13) Squ_Acc(10, 12) Squ_Diag(11) \</span>
<a name="l00956"></a>00956 <span class="preprocessor"> Squ_SaveAcc(22, 8, 15) Squ_Acc(9, 14) Squ_Acc(10, 13) Squ_Acc(11, 12) Squ_NonDiag \</span>
<a name="l00957"></a>00957 <span class="preprocessor"> Squ_SaveAcc(23, 9, 15) Squ_Acc(10, 14) Squ_Acc(11, 13) Squ_Diag(12) \</span>
<a name="l00958"></a>00958 <span class="preprocessor"> Squ_SaveAcc(24, 10, 15) Squ_Acc(11, 14) Squ_Acc(12, 13) Squ_NonDiag \</span>
<a name="l00959"></a>00959 <span class="preprocessor"> Squ_SaveAcc(25, 11, 15) Squ_Acc(12, 14) Squ_Diag(13) \</span>
<a name="l00960"></a>00960 <span class="preprocessor"> Squ_SaveAcc(26, 12, 15) Squ_Acc(13, 14) Squ_NonDiag \</span>
<a name="l00961"></a>00961 <span class="preprocessor"> Squ_SaveAcc(27, 13, 15) Squ_Diag(14) \</span>
<a name="l00962"></a>00962 <span class="preprocessor"> Squ_SaveAcc(28, 14, 15) Squ_NonDiag \</span>
<a name="l00963"></a>00963 <span class="preprocessor"> Squ_End(16)</span>
<a name="l00964"></a>00964 <span class="preprocessor"></span>
<a name="l00965"></a>00965 <span class="preprocessor">#define Bot_2 \</span>
<a name="l00966"></a>00966 <span class="preprocessor"> Mul_Begin(2) \</span>
<a name="l00967"></a>00967 <span class="preprocessor"> Bot_SaveAcc(0, 0, 1) Bot_Acc(1, 0) \</span>
<a name="l00968"></a>00968 <span class="preprocessor"> Bot_End(2)</span>
<a name="l00969"></a>00969 <span class="preprocessor"></span>
<a name="l00970"></a>00970 <span class="preprocessor">#define Bot_4 \</span>
<a name="l00971"></a>00971 <span class="preprocessor"> Mul_Begin(4) \</span>
<a name="l00972"></a>00972 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00973"></a>00973 <span class="preprocessor"> Mul_SaveAcc(1, 2, 0) Mul_Acc(1, 1) Mul_Acc(0, 2) \</span>
<a name="l00974"></a>00974 <span class="preprocessor"> Bot_SaveAcc(2, 0, 3) Bot_Acc(1, 2) Bot_Acc(2, 1) Bot_Acc(3, 0) \</span>
<a name="l00975"></a>00975 <span class="preprocessor"> Bot_End(4)</span>
<a name="l00976"></a>00976 <span class="preprocessor"></span>
<a name="l00977"></a>00977 <span class="preprocessor">#define Bot_8 \</span>
<a name="l00978"></a>00978 <span class="preprocessor"> Mul_Begin(8) \</span>
<a name="l00979"></a>00979 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00980"></a>00980 <span class="preprocessor"> Mul_SaveAcc(1, 0, 2) Mul_Acc(1, 1) Mul_Acc(2, 0) \</span>
<a name="l00981"></a>00981 <span class="preprocessor"> Mul_SaveAcc(2, 0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \</span>
<a name="l00982"></a>00982 <span class="preprocessor"> Mul_SaveAcc(3, 0, 4) Mul_Acc(1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) Mul_Acc(4, 0) \</span>
<a name="l00983"></a>00983 <span class="preprocessor"> Mul_SaveAcc(4, 0, 5) Mul_Acc(1, 4) Mul_Acc(2, 3) Mul_Acc(3, 2) Mul_Acc(4, 1) Mul_Acc(5, 0) \</span>
<a name="l00984"></a>00984 <span class="preprocessor"> Mul_SaveAcc(5, 0, 6) Mul_Acc(1, 5) Mul_Acc(2, 4) Mul_Acc(3, 3) Mul_Acc(4, 2) Mul_Acc(5, 1) Mul_Acc(6, 0) \</span>
<a name="l00985"></a>00985 <span class="preprocessor"> Bot_SaveAcc(6, 0, 7) Bot_Acc(1, 6) Bot_Acc(2, 5) Bot_Acc(3, 4) Bot_Acc(4, 3) Bot_Acc(5, 2) Bot_Acc(6, 1) Bot_Acc(7, 0) \</span>
<a name="l00986"></a>00986 <span class="preprocessor"> Bot_End(8)</span>
<a name="l00987"></a>00987 <span class="preprocessor"></span>
<a name="l00988"></a>00988 <span class="preprocessor">#define Bot_16 \</span>
<a name="l00989"></a>00989 <span class="preprocessor"> Mul_Begin(16) \</span>
<a name="l00990"></a>00990 <span class="preprocessor"> Mul_SaveAcc(0, 0, 1) Mul_Acc(1, 0) \</span>
<a name="l00991"></a>00991 <span class="preprocessor"> Mul_SaveAcc(1, 0, 2) Mul_Acc(1, 1) Mul_Acc(2, 0) \</span>
<a name="l00992"></a>00992 <span class="preprocessor"> Mul_SaveAcc(2, 0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \</span>
<a name="l00993"></a>00993 <span class="preprocessor"> Mul_SaveAcc(3, 0, 4) Mul_Acc(1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) Mul_Acc(4, 0) \</span>
<a name="l00994"></a>00994 <span class="preprocessor"> Mul_SaveAcc(4, 0, 5) Mul_Acc(1, 4) Mul_Acc(2, 3) Mul_Acc(3, 2) Mul_Acc(4, 1) Mul_Acc(5, 0) \</span>
<a name="l00995"></a>00995 <span class="preprocessor"> Mul_SaveAcc(5, 0, 6) Mul_Acc(1, 5) Mul_Acc(2, 4) Mul_Acc(3, 3) Mul_Acc(4, 2) Mul_Acc(5, 1) Mul_Acc(6, 0) \</span>
<a name="l00996"></a>00996 <span class="preprocessor"> Mul_SaveAcc(6, 0, 7) Mul_Acc(1, 6) Mul_Acc(2, 5) Mul_Acc(3, 4) Mul_Acc(4, 3) Mul_Acc(5, 2) Mul_Acc(6, 1) Mul_Acc(7, 0) \</span>
<a name="l00997"></a>00997 <span class="preprocessor"> Mul_SaveAcc(7, 0, 8) Mul_Acc(1, 7) Mul_Acc(2, 6) Mul_Acc(3, 5) Mul_Acc(4, 4) Mul_Acc(5, 3) Mul_Acc(6, 2) Mul_Acc(7, 1) Mul_Acc(8, 0) \</span>
<a name="l00998"></a>00998 <span class="preprocessor"> Mul_SaveAcc(8, 0, 9) Mul_Acc(1, 8) Mul_Acc(2, 7) Mul_Acc(3, 6) Mul_Acc(4, 5) Mul_Acc(5, 4) Mul_Acc(6, 3) Mul_Acc(7, 2) Mul_Acc(8, 1) Mul_Acc(9, 0) \</span>
<a name="l00999"></a>00999 <span class="preprocessor"> Mul_SaveAcc(9, 0, 10) Mul_Acc(1, 9) Mul_Acc(2, 8) Mul_Acc(3, 7) Mul_Acc(4, 6) Mul_Acc(5, 5) Mul_Acc(6, 4) Mul_Acc(7, 3) Mul_Acc(8, 2) Mul_Acc(9, 1) Mul_Acc(10, 0) \</span>
<a name="l01000"></a>01000 <span class="preprocessor"> Mul_SaveAcc(10, 0, 11) Mul_Acc(1, 10) Mul_Acc(2, 9) Mul_Acc(3, 8) Mul_Acc(4, 7) Mul_Acc(5, 6) Mul_Acc(6, 5) Mul_Acc(7, 4) Mul_Acc(8, 3) Mul_Acc(9, 2) Mul_Acc(10, 1) Mul_Acc(11, 0) \</span>
<a name="l01001"></a>01001 <span class="preprocessor"> Mul_SaveAcc(11, 0, 12) Mul_Acc(1, 11) Mul_Acc(2, 10) Mul_Acc(3, 9) Mul_Acc(4, 8) Mul_Acc(5, 7) Mul_Acc(6, 6) Mul_Acc(7, 5) Mul_Acc(8, 4) Mul_Acc(9, 3) Mul_Acc(10, 2) Mul_Acc(11, 1) Mul_Acc(12, 0) \</span>
<a name="l01002"></a>01002 <span class="preprocessor"> Mul_SaveAcc(12, 0, 13) Mul_Acc(1, 12) Mul_Acc(2, 11) Mul_Acc(3, 10) Mul_Acc(4, 9) Mul_Acc(5, 8) Mul_Acc(6, 7) Mul_Acc(7, 6) Mul_Acc(8, 5) Mul_Acc(9, 4) Mul_Acc(10, 3) Mul_Acc(11, 2) Mul_Acc(12, 1) Mul_Acc(13, 0) \</span>
<a name="l01003"></a>01003 <span class="preprocessor"> Mul_SaveAcc(13, 0, 14) Mul_Acc(1, 13) Mul_Acc(2, 12) Mul_Acc(3, 11) Mul_Acc(4, 10) Mul_Acc(5, 9) Mul_Acc(6, 8) Mul_Acc(7, 7) Mul_Acc(8, 6) Mul_Acc(9, 5) Mul_Acc(10, 4) Mul_Acc(11, 3) Mul_Acc(12, 2) Mul_Acc(13, 1) Mul_Acc(14, 0) \</span>
<a name="l01004"></a>01004 <span class="preprocessor"> Bot_SaveAcc(14, 0, 15) Bot_Acc(1, 14) Bot_Acc(2, 13) Bot_Acc(3, 12) Bot_Acc(4, 11) Bot_Acc(5, 10) Bot_Acc(6, 9) Bot_Acc(7, 8) Bot_Acc(8, 7) Bot_Acc(9, 6) Bot_Acc(10, 5) Bot_Acc(11, 4) Bot_Acc(12, 3) Bot_Acc(13, 2) Bot_Acc(14, 1) Bot_Acc(15, 0) \</span>
<a name="l01005"></a>01005 <span class="preprocessor"> Bot_End(16)</span>
<a name="l01006"></a>01006 <span class="preprocessor"></span>
<a name="l01007"></a>01007 <span class="preprocessor">#endif</span>
<a name="l01008"></a>01008 <span class="preprocessor"></span>
<a name="l01009"></a>01009 <span class="preprocessor">#if 0</span>
<a name="l01010"></a>01010 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Begin(n) \</span>
<a name="l01011"></a>01011 <span class="preprocessor"> Declare2Words(p) \</span>
<a name="l01012"></a>01012 <span class="preprocessor"> Declare2Words(c) \</span>
<a name="l01013"></a>01013 <span class="preprocessor"> Declare2Words(d) \</span>
<a name="l01014"></a>01014 <span class="preprocessor"> MultiplyWords(p, A[0], B[0]) \</span>
<a name="l01015"></a>01015 <span class="preprocessor"> AssignWord(c, LowWord(p)) \</span>
<a name="l01016"></a>01016 <span class="preprocessor"> AssignWord(d, HighWord(p))</span>
<a name="l01017"></a>01017 <span class="preprocessor"></span>
<a name="l01018"></a>01018 <span class="preprocessor">#define Mul_Acc(i, j) \</span>
<a name="l01019"></a>01019 <span class="preprocessor"> MultiplyWords(p, A[i], B[j]) \</span>
<a name="l01020"></a>01020 <span class="preprocessor"> Acc2WordsBy1(c, LowWord(p)) \</span>
<a name="l01021"></a>01021 <span class="preprocessor"> Acc2WordsBy1(d, HighWord(p))</span>
<a name="l01022"></a>01022 <span class="preprocessor"></span>
<a name="l01023"></a>01023 <span class="preprocessor">#define Mul_SaveAcc(k, i, j) \</span>
<a name="l01024"></a>01024 <span class="preprocessor"> R[k] = LowWord(c); \</span>
<a name="l01025"></a>01025 <span class="preprocessor"> Add2WordsBy1(c, d, HighWord(c)) \</span>
<a name="l01026"></a>01026 <span class="preprocessor"> MultiplyWords(p, A[i], B[j]) \</span>
<a name="l01027"></a>01027 <span class="preprocessor"> AssignWord(d, HighWord(p)) \</span>
<a name="l01028"></a>01028 <span class="preprocessor"> Acc2WordsBy1(c, LowWord(p))</span>
<a name="l01029"></a>01029 <span class="preprocessor"></span>
<a name="l01030"></a>01030 <span class="preprocessor">#define Mul_End(n) \</span>
<a name="l01031"></a>01031 <span class="preprocessor"> R[2*n-3] = LowWord(c); \</span>
<a name="l01032"></a>01032 <span class="preprocessor"> Acc2WordsBy1(d, HighWord(c)) \</span>
<a name="l01033"></a>01033 <span class="preprocessor"> MultiplyWords(p, A[n-1], B[n-1])\</span>
<a name="l01034"></a>01034 <span class="preprocessor"> Acc2WordsBy2(d, p) \</span>
<a name="l01035"></a>01035 <span class="preprocessor"> R[2*n-2] = LowWord(d); \</span>
<a name="l01036"></a>01036 <span class="preprocessor"> R[2*n-1] = HighWord(d);</span>
<a name="l01037"></a>01037 <span class="preprocessor"></span>
<a name="l01038"></a>01038 <span class="preprocessor">#define Bot_SaveAcc(k, i, j) \</span>
<a name="l01039"></a>01039 <span class="preprocessor"> R[k] = LowWord(c); \</span>
<a name="l01040"></a>01040 <span class="preprocessor"> word e = LowWord(d) + HighWord(c); \</span>
<a name="l01041"></a>01041 <span class="preprocessor"> e += A[i] * B[j];</span>
<a name="l01042"></a>01042 <span class="preprocessor"></span>
<a name="l01043"></a>01043 <span class="preprocessor">#define Bot_Acc(i, j) \</span>
<a name="l01044"></a>01044 <span class="preprocessor"> e += A[i] * B[j];</span>
<a name="l01045"></a>01045 <span class="preprocessor"></span>
<a name="l01046"></a>01046 <span class="preprocessor">#define Bot_End(n) \</span>
<a name="l01047"></a>01047 <span class="preprocessor"> R[n-1] = e;</span>
<a name="l01048"></a>01048 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l01049"></a>01049 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Begin(n) \</span>
<a name="l01050"></a>01050 <span class="preprocessor"> Declare2Words(p) \</span>
<a name="l01051"></a>01051 <span class="preprocessor"> word c; \</span>
<a name="l01052"></a>01052 <span class="preprocessor"> Declare2Words(d) \</span>
<a name="l01053"></a>01053 <span class="preprocessor"> MultiplyWords(p, A[0], B[0]) \</span>
<a name="l01054"></a>01054 <span class="preprocessor"> c = LowWord(p); \</span>
<a name="l01055"></a>01055 <span class="preprocessor"> AssignWord(d, HighWord(p))</span>
<a name="l01056"></a>01056 <span class="preprocessor"></span>
<a name="l01057"></a>01057 <span class="preprocessor">#define Mul_Acc(i, j) \</span>
<a name="l01058"></a>01058 <span class="preprocessor"> MulAcc(c, d, A[i], B[j])</span>
<a name="l01059"></a>01059 <span class="preprocessor"></span>
<a name="l01060"></a>01060 <span class="preprocessor">#define Mul_SaveAcc(k, i, j) \</span>
<a name="l01061"></a>01061 <span class="preprocessor"> R[k] = c; \</span>
<a name="l01062"></a>01062 <span class="preprocessor"> c = LowWord(d); \</span>
<a name="l01063"></a>01063 <span class="preprocessor"> AssignWord(d, HighWord(d)) \</span>
<a name="l01064"></a>01064 <span class="preprocessor"> MulAcc(c, d, A[i], B[j])</span>
<a name="l01065"></a>01065 <span class="preprocessor"></span>
<a name="l01066"></a>01066 <span class="preprocessor">#define Mul_End(k, i) \</span>
<a name="l01067"></a>01067 <span class="preprocessor"> R[k] = c; \</span>
<a name="l01068"></a>01068 <span class="preprocessor"> MultiplyWords(p, A[i], B[i]) \</span>
<a name="l01069"></a>01069 <span class="preprocessor"> Acc2WordsBy2(p, d) \</span>
<a name="l01070"></a>01070 <span class="preprocessor"> R[k+1] = LowWord(p); \</span>
<a name="l01071"></a>01071 <span class="preprocessor"> R[k+2] = HighWord(p);</span>
<a name="l01072"></a>01072 <span class="preprocessor"></span>
<a name="l01073"></a>01073 <span class="preprocessor">#define Bot_SaveAcc(k, i, j) \</span>
<a name="l01074"></a>01074 <span class="preprocessor"> R[k] = c; \</span>
<a name="l01075"></a>01075 <span class="preprocessor"> c = LowWord(d); \</span>
<a name="l01076"></a>01076 <span class="preprocessor"> c += A[i] * B[j];</span>
<a name="l01077"></a>01077 <span class="preprocessor"></span>
<a name="l01078"></a>01078 <span class="preprocessor">#define Bot_Acc(i, j) \</span>
<a name="l01079"></a>01079 <span class="preprocessor"> c += A[i] * B[j];</span>
<a name="l01080"></a>01080 <span class="preprocessor"></span>
<a name="l01081"></a>01081 <span class="preprocessor">#define Bot_End(n) \</span>
<a name="l01082"></a>01082 <span class="preprocessor"> R[n-1] = c;</span>
<a name="l01083"></a>01083 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l01084"></a>01084 <span class="preprocessor"></span>
<a name="l01085"></a>01085 <span class="preprocessor">#define Squ_Begin(n) \</span>
<a name="l01086"></a>01086 <span class="preprocessor"> Declare2Words(p) \</span>
<a name="l01087"></a>01087 <span class="preprocessor"> word c; \</span>
<a name="l01088"></a>01088 <span class="preprocessor"> Declare2Words(d) \</span>
<a name="l01089"></a>01089 <span class="preprocessor"> Declare2Words(e) \</span>
<a name="l01090"></a>01090 <span class="preprocessor"> MultiplyWords(p, A[0], A[0]) \</span>
<a name="l01091"></a>01091 <span class="preprocessor"> R[0] = LowWord(p); \</span>
<a name="l01092"></a>01092 <span class="preprocessor"> AssignWord(e, HighWord(p)) \</span>
<a name="l01093"></a>01093 <span class="preprocessor"> MultiplyWords(p, A[0], A[1]) \</span>
<a name="l01094"></a>01094 <span class="preprocessor"> c = LowWord(p); \</span>
<a name="l01095"></a>01095 <span class="preprocessor"> AssignWord(d, HighWord(p)) \</span>
<a name="l01096"></a>01096 <span class="preprocessor"> Squ_NonDiag \</span>
<a name="l01097"></a>01097 <span class="preprocessor"></span>
<a name="l01098"></a>01098 <span class="preprocessor"></span><span class="preprocessor">#define Squ_NonDiag \</span>
<a name="l01099"></a>01099 <span class="preprocessor"> Double3Words(c, d)</span>
<a name="l01100"></a>01100 <span class="preprocessor"></span>
<a name="l01101"></a>01101 <span class="preprocessor">#define Squ_SaveAcc(k, i, j) \</span>
<a name="l01102"></a>01102 <span class="preprocessor"> Acc3WordsBy2(c, d, e) \</span>
<a name="l01103"></a>01103 <span class="preprocessor"> R[k] = c; \</span>
<a name="l01104"></a>01104 <span class="preprocessor"> MultiplyWords(p, A[i], A[j]) \</span>
<a name="l01105"></a>01105 <span class="preprocessor"> c = LowWord(p); \</span>
<a name="l01106"></a>01106 <span class="preprocessor"> AssignWord(d, HighWord(p)) \</span>
<a name="l01107"></a>01107 <span class="preprocessor"></span>
<a name="l01108"></a>01108 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc(i, j) \</span>
<a name="l01109"></a>01109 <span class="preprocessor"> MulAcc(c, d, A[i], A[j])</span>
<a name="l01110"></a>01110 <span class="preprocessor"></span>
<a name="l01111"></a>01111 <span class="preprocessor">#define Squ_Diag(i) \</span>
<a name="l01112"></a>01112 <span class="preprocessor"> Squ_NonDiag \</span>
<a name="l01113"></a>01113 <span class="preprocessor"> MulAcc(c, d, A[i], A[i])</span>
<a name="l01114"></a>01114 <span class="preprocessor"></span>
<a name="l01115"></a>01115 <span class="preprocessor">#define Squ_End(n) \</span>
<a name="l01116"></a>01116 <span class="preprocessor"> Acc3WordsBy2(c, d, e) \</span>
<a name="l01117"></a>01117 <span class="preprocessor"> R[2*n-3] = c; \</span>
<a name="l01118"></a>01118 <span class="preprocessor"> MultiplyWords(p, A[n-1], A[n-1])\</span>
<a name="l01119"></a>01119 <span class="preprocessor"> Acc2WordsBy2(p, e) \</span>
<a name="l01120"></a>01120 <span class="preprocessor"> R[2*n-2] = LowWord(p); \</span>
<a name="l01121"></a>01121 <span class="preprocessor"> R[2*n-1] = HighWord(p);</span>
<a name="l01122"></a>01122 <span class="preprocessor"></span>
<a name="l01123"></a>01123 <span class="keywordtype">void</span> Baseline_Multiply2(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01124"></a>01124 {
<a name="l01125"></a>01125 Mul_2
<a name="l01126"></a>01126 }
<a name="l01127"></a>01127
<a name="l01128"></a>01128 <span class="keywordtype">void</span> Baseline_Multiply4(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01129"></a>01129 {
<a name="l01130"></a>01130 Mul_4
<a name="l01131"></a>01131 }
<a name="l01132"></a>01132
<a name="l01133"></a>01133 <span class="keywordtype">void</span> Baseline_Multiply8(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01134"></a>01134 {
<a name="l01135"></a>01135 Mul_8
<a name="l01136"></a>01136 }
<a name="l01137"></a>01137
<a name="l01138"></a>01138 <span class="keywordtype">void</span> Baseline_Square2(word *R, <span class="keyword">const</span> word *A)
<a name="l01139"></a>01139 {
<a name="l01140"></a>01140 Squ_2
<a name="l01141"></a>01141 }
<a name="l01142"></a>01142
<a name="l01143"></a>01143 <span class="keywordtype">void</span> Baseline_Square4(word *R, <span class="keyword">const</span> word *A)
<a name="l01144"></a>01144 {
<a name="l01145"></a>01145 Squ_4
<a name="l01146"></a>01146 }
<a name="l01147"></a>01147
<a name="l01148"></a>01148 <span class="keywordtype">void</span> Baseline_Square8(word *R, <span class="keyword">const</span> word *A)
<a name="l01149"></a>01149 {
<a name="l01150"></a>01150 Squ_8
<a name="l01151"></a>01151 }
<a name="l01152"></a>01152
<a name="l01153"></a>01153 <span class="keywordtype">void</span> Baseline_MultiplyBottom2(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01154"></a>01154 {
<a name="l01155"></a>01155 Bot_2
<a name="l01156"></a>01156 }
<a name="l01157"></a>01157
<a name="l01158"></a>01158 <span class="keywordtype">void</span> Baseline_MultiplyBottom4(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01159"></a>01159 {
<a name="l01160"></a>01160 Bot_4
<a name="l01161"></a>01161 }
<a name="l01162"></a>01162
<a name="l01163"></a>01163 <span class="keywordtype">void</span> Baseline_MultiplyBottom8(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01164"></a>01164 {
<a name="l01165"></a>01165 Bot_8
<a name="l01166"></a>01166 }
<a name="l01167"></a>01167
<a name="l01168"></a>01168 <span class="preprocessor">#define Top_Begin(n) \</span>
<a name="l01169"></a>01169 <span class="preprocessor"> Declare2Words(p) \</span>
<a name="l01170"></a>01170 <span class="preprocessor"> word c; \</span>
<a name="l01171"></a>01171 <span class="preprocessor"> Declare2Words(d) \</span>
<a name="l01172"></a>01172 <span class="preprocessor"> MultiplyWords(p, A[0], B[n-2]);\</span>
<a name="l01173"></a>01173 <span class="preprocessor"> AssignWord(d, HighWord(p));</span>
<a name="l01174"></a>01174 <span class="preprocessor"></span>
<a name="l01175"></a>01175 <span class="preprocessor">#define Top_Acc(i, j) \</span>
<a name="l01176"></a>01176 <span class="preprocessor"> MultiplyWords(p, A[i], B[j]);\</span>
<a name="l01177"></a>01177 <span class="preprocessor"> Acc2WordsBy1(d, HighWord(p));</span>
<a name="l01178"></a>01178 <span class="preprocessor"></span>
<a name="l01179"></a>01179 <span class="preprocessor">#define Top_SaveAcc0(i, j) \</span>
<a name="l01180"></a>01180 <span class="preprocessor"> c = LowWord(d); \</span>
<a name="l01181"></a>01181 <span class="preprocessor"> AssignWord(d, HighWord(d)) \</span>
<a name="l01182"></a>01182 <span class="preprocessor"> MulAcc(c, d, A[i], B[j])</span>
<a name="l01183"></a>01183 <span class="preprocessor"></span>
<a name="l01184"></a>01184 <span class="preprocessor">#define Top_SaveAcc1(i, j) \</span>
<a name="l01185"></a>01185 <span class="preprocessor"> c = L<c; \</span>
<a name="l01186"></a>01186 <span class="preprocessor"> Acc2WordsBy1(d, c); \</span>
<a name="l01187"></a>01187 <span class="preprocessor"> c = LowWord(d); \</span>
<a name="l01188"></a>01188 <span class="preprocessor"> AssignWord(d, HighWord(d)) \</span>
<a name="l01189"></a>01189 <span class="preprocessor"> MulAcc(c, d, A[i], B[j])</span>
<a name="l01190"></a>01190 <span class="preprocessor"></span>
<a name="l01191"></a>01191 <span class="keywordtype">void</span> Baseline_MultiplyTop2(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, word L)
<a name="l01192"></a>01192 {
<a name="l01193"></a>01193 word T[4];
<a name="l01194"></a>01194 Baseline_Multiply2(T, A, B);
<a name="l01195"></a>01195 R[0] = T[2];
<a name="l01196"></a>01196 R[1] = T[3];
<a name="l01197"></a>01197 }
<a name="l01198"></a>01198
<a name="l01199"></a>01199 <span class="keywordtype">void</span> Baseline_MultiplyTop4(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, word L)
<a name="l01200"></a>01200 {
<a name="l01201"></a>01201 Top_Begin(4)
<a name="l01202"></a>01202 Top_Acc(1, 1) Top_Acc(2, 0) \
<a name="l01203"></a>01203 Top_SaveAcc0(0, 3) Mul_Acc(1, 2) Mul_Acc(2, 1) Mul_Acc(3, 0) \
<a name="l01204"></a>01204 Top_SaveAcc1(1, 3) Mul_Acc(2, 2) Mul_Acc(3, 1) \
<a name="l01205"></a>01205 Mul_SaveAcc(0, 2, 3) Mul_Acc(3, 2) \
<a name="l01206"></a>01206 Mul_End(1, 3)
<a name="l01207"></a>01207 }
<a name="l01208"></a>01208
<a name="l01209"></a>01209 <span class="keywordtype">void</span> Baseline_MultiplyTop8(word *R, const word *A, const word *B, word L)
<a name="l01210"></a>01210 {
<a name="l01211"></a>01211 Top_Begin(8)
<a name="l01212"></a>01212 Top_Acc(1, 5) Top_Acc(2, 4) Top_Acc(3, 3) Top_Acc(4, 2) Top_Acc(5, 1) Top_Acc(6, 0) \
<a name="l01213"></a>01213 Top_SaveAcc0(0, 7) Mul_Acc(1, 6) Mul_Acc(2, 5) Mul_Acc(3, 4) Mul_Acc(4, 3) Mul_Acc(5, 2) Mul_Acc(6, 1) Mul_Acc(7, 0) \
<a name="l01214"></a>01214 Top_SaveAcc1(1, 7) Mul_Acc(2, 6) Mul_Acc(3, 5) Mul_Acc(4, 4) Mul_Acc(5, 3) Mul_Acc(6, 2) Mul_Acc(7, 1) \
<a name="l01215"></a>01215 Mul_SaveAcc(0, 2, 7) Mul_Acc(3, 6) Mul_Acc(4, 5) Mul_Acc(5, 4) Mul_Acc(6, 3) Mul_Acc(7, 2) \
<a name="l01216"></a>01216 Mul_SaveAcc(1, 3, 7) Mul_Acc(4, 6) Mul_Acc(5, 5) Mul_Acc(6, 4) Mul_Acc(7, 3) \
<a name="l01217"></a>01217 Mul_SaveAcc(2, 4, 7) Mul_Acc(5, 6) Mul_Acc(6, 5) Mul_Acc(7, 4) \
<a name="l01218"></a>01218 Mul_SaveAcc(3, 5, 7) Mul_Acc(6, 6) Mul_Acc(7, 5) \
<a name="l01219"></a>01219 Mul_SaveAcc(4, 6, 7) Mul_Acc(7, 6) \
<a name="l01220"></a>01220 Mul_End(5, 7)
<a name="l01221"></a>01221 }
<a name="l01222"></a>01222
<a name="l01223"></a>01223 <span class="preprocessor">#if !CRYPTOPP_INTEGER_SSE2 // save memory by not compiling these functions when SSE2 is available</span>
<a name="l01224"></a>01224 <span class="preprocessor"></span><span class="keywordtype">void</span> Baseline_Multiply16(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01225"></a>01225 {
<a name="l01226"></a>01226 Mul_16
<a name="l01227"></a>01227 }
<a name="l01228"></a>01228
<a name="l01229"></a>01229 <span class="keywordtype">void</span> Baseline_Square16(word *R, <span class="keyword">const</span> word *A)
<a name="l01230"></a>01230 {
<a name="l01231"></a>01231 Squ_16
<a name="l01232"></a>01232 }
<a name="l01233"></a>01233
<a name="l01234"></a>01234 <span class="keywordtype">void</span> Baseline_MultiplyBottom16(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l01235"></a>01235 {
<a name="l01236"></a>01236 Bot_16
<a name="l01237"></a>01237 }
<a name="l01238"></a>01238
<a name="l01239"></a>01239 <span class="keywordtype">void</span> Baseline_MultiplyTop16(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, word L)
<a name="l01240"></a>01240 {
<a name="l01241"></a>01241 Top_Begin(16)
<a name="l01242"></a>01242 Top_Acc(1, 13) Top_Acc(2, 12) Top_Acc(3, 11) Top_Acc(4, 10) Top_Acc(5, 9) Top_Acc(6, 8) Top_Acc(7, 7) Top_Acc(8, 6) Top_Acc(9, 5) Top_Acc(10, 4) Top_Acc(11, 3) Top_Acc(12, 2) Top_Acc(13, 1) Top_Acc(14, 0) \
<a name="l01243"></a>01243 Top_SaveAcc0(0, 15) Mul_Acc(1, 14) Mul_Acc(2, 13) Mul_Acc(3, 12) Mul_Acc(4, 11) Mul_Acc(5, 10) Mul_Acc(6, 9) Mul_Acc(7, 8) Mul_Acc(8, 7) Mul_Acc(9, 6) Mul_Acc(10, 5) Mul_Acc(11, 4) Mul_Acc(12, 3) Mul_Acc(13, 2) Mul_Acc(14, 1) Mul_Acc(15, 0) \
<a name="l01244"></a>01244 Top_SaveAcc1(1, 15) Mul_Acc(2, 14) Mul_Acc(3, 13) Mul_Acc(4, 12) Mul_Acc(5, 11) Mul_Acc(6, 10) Mul_Acc(7, 9) Mul_Acc(8, 8) Mul_Acc(9, 7) Mul_Acc(10, 6) Mul_Acc(11, 5) Mul_Acc(12, 4) Mul_Acc(13, 3) Mul_Acc(14, 2) Mul_Acc(15, 1) \
<a name="l01245"></a>01245 Mul_SaveAcc(0, 2, 15) Mul_Acc(3, 14) Mul_Acc(4, 13) Mul_Acc(5, 12) Mul_Acc(6, 11) Mul_Acc(7, 10) Mul_Acc(8, 9) Mul_Acc(9, 8) Mul_Acc(10, 7) Mul_Acc(11, 6) Mul_Acc(12, 5) Mul_Acc(13, 4) Mul_Acc(14, 3) Mul_Acc(15, 2) \
<a name="l01246"></a>01246 Mul_SaveAcc(1, 3, 15) Mul_Acc(4, 14) Mul_Acc(5, 13) Mul_Acc(6, 12) Mul_Acc(7, 11) Mul_Acc(8, 10) Mul_Acc(9, 9) Mul_Acc(10, 8) Mul_Acc(11, 7) Mul_Acc(12, 6) Mul_Acc(13, 5) Mul_Acc(14, 4) Mul_Acc(15, 3) \
<a name="l01247"></a>01247 Mul_SaveAcc(2, 4, 15) Mul_Acc(5, 14) Mul_Acc(6, 13) Mul_Acc(7, 12) Mul_Acc(8, 11) Mul_Acc(9, 10) Mul_Acc(10, 9) Mul_Acc(11, 8) Mul_Acc(12, 7) Mul_Acc(13, 6) Mul_Acc(14, 5) Mul_Acc(15, 4) \
<a name="l01248"></a>01248 Mul_SaveAcc(3, 5, 15) Mul_Acc(6, 14) Mul_Acc(7, 13) Mul_Acc(8, 12) Mul_Acc(9, 11) Mul_Acc(10, 10) Mul_Acc(11, 9) Mul_Acc(12, 8) Mul_Acc(13, 7) Mul_Acc(14, 6) Mul_Acc(15, 5) \
<a name="l01249"></a>01249 Mul_SaveAcc(4, 6, 15) Mul_Acc(7, 14) Mul_Acc(8, 13) Mul_Acc(9, 12) Mul_Acc(10, 11) Mul_Acc(11, 10) Mul_Acc(12, 9) Mul_Acc(13, 8) Mul_Acc(14, 7) Mul_Acc(15, 6) \
<a name="l01250"></a>01250 Mul_SaveAcc(5, 7, 15) Mul_Acc(8, 14) Mul_Acc(9, 13) Mul_Acc(10, 12) Mul_Acc(11, 11) Mul_Acc(12, 10) Mul_Acc(13, 9) Mul_Acc(14, 8) Mul_Acc(15, 7) \
<a name="l01251"></a>01251 Mul_SaveAcc(6, 8, 15) Mul_Acc(9, 14) Mul_Acc(10, 13) Mul_Acc(11, 12) Mul_Acc(12, 11) Mul_Acc(13, 10) Mul_Acc(14, 9) Mul_Acc(15, 8) \
<a name="l01252"></a>01252 Mul_SaveAcc(7, 9, 15) Mul_Acc(10, 14) Mul_Acc(11, 13) Mul_Acc(12, 12) Mul_Acc(13, 11) Mul_Acc(14, 10) Mul_Acc(15, 9) \
<a name="l01253"></a>01253 Mul_SaveAcc(8, 10, 15) Mul_Acc(11, 14) Mul_Acc(12, 13) Mul_Acc(13, 12) Mul_Acc(14, 11) Mul_Acc(15, 10) \
<a name="l01254"></a>01254 Mul_SaveAcc(9, 11, 15) Mul_Acc(12, 14) Mul_Acc(13, 13) Mul_Acc(14, 12) Mul_Acc(15, 11) \
<a name="l01255"></a>01255 Mul_SaveAcc(10, 12, 15) Mul_Acc(13, 14) Mul_Acc(14, 13) Mul_Acc(15, 12) \
<a name="l01256"></a>01256 Mul_SaveAcc(11, 13, 15) Mul_Acc(14, 14) Mul_Acc(15, 13) \
<a name="l01257"></a>01257 Mul_SaveAcc(12, 14, 15) Mul_Acc(15, 14) \
<a name="l01258"></a>01258 Mul_End(13, 15)
<a name="l01259"></a>01259 }
<a name="l01260"></a>01260 <span class="preprocessor">#endif</span>
<a name="l01261"></a>01261 <span class="preprocessor"></span>
<a name="l01262"></a>01262 <span class="comment">// ********************************************************</span>
<a name="l01263"></a>01263
<a name="l01264"></a>01264 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l01265"></a>01265 <span class="preprocessor"></span>
<a name="l01266"></a>01266 CRYPTOPP_ALIGN_DATA(16) static const word32 s_maskLow16[4] CRYPTOPP_SECTION_ALIGN16 = {0xffff,0xffff,0xffff,0xffff};
<a name="l01267"></a>01267
<a name="l01268"></a>01268 <span class="preprocessor">#undef Mul_Begin</span>
<a name="l01269"></a>01269 <span class="preprocessor"></span><span class="preprocessor">#undef Mul_Acc</span>
<a name="l01270"></a>01270 <span class="preprocessor"></span><span class="preprocessor">#undef Top_Begin</span>
<a name="l01271"></a>01271 <span class="preprocessor"></span><span class="preprocessor">#undef Top_Acc</span>
<a name="l01272"></a>01272 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_Acc</span>
<a name="l01273"></a>01273 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_NonDiag</span>
<a name="l01274"></a>01274 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_Diag</span>
<a name="l01275"></a>01275 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_SaveAcc</span>
<a name="l01276"></a>01276 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_Begin</span>
<a name="l01277"></a>01277 <span class="preprocessor"></span><span class="preprocessor">#undef Mul_SaveAcc</span>
<a name="l01278"></a>01278 <span class="preprocessor"></span><span class="preprocessor">#undef Bot_Acc</span>
<a name="l01279"></a>01279 <span class="preprocessor"></span><span class="preprocessor">#undef Bot_SaveAcc</span>
<a name="l01280"></a>01280 <span class="preprocessor"></span><span class="preprocessor">#undef Bot_End</span>
<a name="l01281"></a>01281 <span class="preprocessor"></span><span class="preprocessor">#undef Squ_End</span>
<a name="l01282"></a>01282 <span class="preprocessor"></span><span class="preprocessor">#undef Mul_End</span>
<a name="l01283"></a>01283 <span class="preprocessor"></span>
<a name="l01284"></a>01284 <span class="preprocessor">#define SSE2_FinalSave(k) \</span>
<a name="l01285"></a>01285 <span class="preprocessor"> AS2( psllq xmm5, 16) \</span>
<a name="l01286"></a>01286 <span class="preprocessor"> AS2( paddq xmm4, xmm5) \</span>
<a name="l01287"></a>01287 <span class="preprocessor"> AS2( movq QWORD PTR [ecx+8*(k)], xmm4)</span>
<a name="l01288"></a>01288 <span class="preprocessor"></span>
<a name="l01289"></a>01289 <span class="preprocessor">#define SSE2_SaveShift(k) \</span>
<a name="l01290"></a>01290 <span class="preprocessor"> AS2( movq xmm0, xmm6) \</span>
<a name="l01291"></a>01291 <span class="preprocessor"> AS2( punpckhqdq xmm6, xmm0) \</span>
<a name="l01292"></a>01292 <span class="preprocessor"> AS2( movq xmm1, xmm7) \</span>
<a name="l01293"></a>01293 <span class="preprocessor"> AS2( punpckhqdq xmm7, xmm1) \</span>
<a name="l01294"></a>01294 <span class="preprocessor"> AS2( paddd xmm6, xmm0) \</span>
<a name="l01295"></a>01295 <span class="preprocessor"> AS2( pslldq xmm6, 4) \</span>
<a name="l01296"></a>01296 <span class="preprocessor"> AS2( paddd xmm7, xmm1) \</span>
<a name="l01297"></a>01297 <span class="preprocessor"> AS2( paddd xmm4, xmm6) \</span>
<a name="l01298"></a>01298 <span class="preprocessor"> AS2( pslldq xmm7, 4) \</span>
<a name="l01299"></a>01299 <span class="preprocessor"> AS2( movq xmm6, xmm4) \</span>
<a name="l01300"></a>01300 <span class="preprocessor"> AS2( paddd xmm5, xmm7) \</span>
<a name="l01301"></a>01301 <span class="preprocessor"> AS2( movq xmm7, xmm5) \</span>
<a name="l01302"></a>01302 <span class="preprocessor"> AS2( movd DWORD PTR [ecx+8*(k)], xmm4) \</span>
<a name="l01303"></a>01303 <span class="preprocessor"> AS2( psrlq xmm6, 16) \</span>
<a name="l01304"></a>01304 <span class="preprocessor"> AS2( paddq xmm6, xmm7) \</span>
<a name="l01305"></a>01305 <span class="preprocessor"> AS2( punpckhqdq xmm4, xmm0) \</span>
<a name="l01306"></a>01306 <span class="preprocessor"> AS2( punpckhqdq xmm5, xmm0) \</span>
<a name="l01307"></a>01307 <span class="preprocessor"> AS2( movq QWORD PTR [ecx+8*(k)+2], xmm6) \</span>
<a name="l01308"></a>01308 <span class="preprocessor"> AS2( psrlq xmm6, 3*16) \</span>
<a name="l01309"></a>01309 <span class="preprocessor"> AS2( paddd xmm4, xmm6) \</span>
<a name="l01310"></a>01310 <span class="preprocessor"></span>
<a name="l01311"></a>01311 <span class="preprocessor"></span><span class="preprocessor">#define Squ_SSE2_SaveShift(k) \</span>
<a name="l01312"></a>01312 <span class="preprocessor"> AS2( movq xmm0, xmm6) \</span>
<a name="l01313"></a>01313 <span class="preprocessor"> AS2( punpckhqdq xmm6, xmm0) \</span>
<a name="l01314"></a>01314 <span class="preprocessor"> AS2( movq xmm1, xmm7) \</span>
<a name="l01315"></a>01315 <span class="preprocessor"> AS2( punpckhqdq xmm7, xmm1) \</span>
<a name="l01316"></a>01316 <span class="preprocessor"> AS2( paddd xmm6, xmm0) \</span>
<a name="l01317"></a>01317 <span class="preprocessor"> AS2( pslldq xmm6, 4) \</span>
<a name="l01318"></a>01318 <span class="preprocessor"> AS2( paddd xmm7, xmm1) \</span>
<a name="l01319"></a>01319 <span class="preprocessor"> AS2( paddd xmm4, xmm6) \</span>
<a name="l01320"></a>01320 <span class="preprocessor"> AS2( pslldq xmm7, 4) \</span>
<a name="l01321"></a>01321 <span class="preprocessor"> AS2( movhlps xmm6, xmm4) \</span>
<a name="l01322"></a>01322 <span class="preprocessor"> AS2( movd DWORD PTR [ecx+8*(k)], xmm4) \</span>
<a name="l01323"></a>01323 <span class="preprocessor"> AS2( paddd xmm5, xmm7) \</span>
<a name="l01324"></a>01324 <span class="preprocessor"> AS2( movhps QWORD PTR [esp+12], xmm5)\</span>
<a name="l01325"></a>01325 <span class="preprocessor"> AS2( psrlq xmm4, 16) \</span>
<a name="l01326"></a>01326 <span class="preprocessor"> AS2( paddq xmm4, xmm5) \</span>
<a name="l01327"></a>01327 <span class="preprocessor"> AS2( movq QWORD PTR [ecx+8*(k)+2], xmm4) \</span>
<a name="l01328"></a>01328 <span class="preprocessor"> AS2( psrlq xmm4, 3*16) \</span>
<a name="l01329"></a>01329 <span class="preprocessor"> AS2( paddd xmm4, xmm6) \</span>
<a name="l01330"></a>01330 <span class="preprocessor"> AS2( movq QWORD PTR [esp+4], xmm4)\</span>
<a name="l01331"></a>01331 <span class="preprocessor"></span>
<a name="l01332"></a>01332 <span class="preprocessor"></span><span class="preprocessor">#define SSE2_FirstMultiply(i) \</span>
<a name="l01333"></a>01333 <span class="preprocessor"> AS2( movdqa xmm7, [esi+(i)*16])\</span>
<a name="l01334"></a>01334 <span class="preprocessor"> AS2( movdqa xmm5, [edi-(i)*16])\</span>
<a name="l01335"></a>01335 <span class="preprocessor"> AS2( pmuludq xmm5, xmm7) \</span>
<a name="l01336"></a>01336 <span class="preprocessor"> AS2( movdqa xmm4, [ebx])\</span>
<a name="l01337"></a>01337 <span class="preprocessor"> AS2( movdqa xmm6, xmm4) \</span>
<a name="l01338"></a>01338 <span class="preprocessor"> AS2( pand xmm4, xmm5) \</span>
<a name="l01339"></a>01339 <span class="preprocessor"> AS2( psrld xmm5, 16) \</span>
<a name="l01340"></a>01340 <span class="preprocessor"> AS2( pmuludq xmm7, [edx-(i)*16])\</span>
<a name="l01341"></a>01341 <span class="preprocessor"> AS2( pand xmm6, xmm7) \</span>
<a name="l01342"></a>01342 <span class="preprocessor"> AS2( psrld xmm7, 16)</span>
<a name="l01343"></a>01343 <span class="preprocessor"></span>
<a name="l01344"></a>01344 <span class="preprocessor">#define Squ_Begin(n) \</span>
<a name="l01345"></a>01345 <span class="preprocessor"> SquPrologue \</span>
<a name="l01346"></a>01346 <span class="preprocessor"> AS2( mov esi, esp)\</span>
<a name="l01347"></a>01347 <span class="preprocessor"> AS2( and esp, 0xfffffff0)\</span>
<a name="l01348"></a>01348 <span class="preprocessor"> AS2( lea edi, [esp-32*n])\</span>
<a name="l01349"></a>01349 <span class="preprocessor"> AS2( sub esp, 32*n+16)\</span>
<a name="l01350"></a>01350 <span class="preprocessor"> AS1( push esi)\</span>
<a name="l01351"></a>01351 <span class="preprocessor"> AS2( mov esi, edi) \</span>
<a name="l01352"></a>01352 <span class="preprocessor"> AS2( xor edx, edx) \</span>
<a name="l01353"></a>01353 <span class="preprocessor"> ASL(1) \</span>
<a name="l01354"></a>01354 <span class="preprocessor"> ASS( pshufd xmm0, [eax+edx], 3,1,2,0) \</span>
<a name="l01355"></a>01355 <span class="preprocessor"> ASS( pshufd xmm1, [eax+edx], 2,0,3,1) \</span>
<a name="l01356"></a>01356 <span class="preprocessor"> AS2( movdqa [edi+2*edx], xmm0) \</span>
<a name="l01357"></a>01357 <span class="preprocessor"> AS2( psrlq xmm0, 32) \</span>
<a name="l01358"></a>01358 <span class="preprocessor"> AS2( movdqa [edi+2*edx+16], xmm0) \</span>
<a name="l01359"></a>01359 <span class="preprocessor"> AS2( movdqa [edi+16*n+2*edx], xmm1) \</span>
<a name="l01360"></a>01360 <span class="preprocessor"> AS2( psrlq xmm1, 32) \</span>
<a name="l01361"></a>01361 <span class="preprocessor"> AS2( movdqa [edi+16*n+2*edx+16], xmm1) \</span>
<a name="l01362"></a>01362 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01363"></a>01363 <span class="preprocessor"> AS2( cmp edx, 8*(n)) \</span>
<a name="l01364"></a>01364 <span class="preprocessor"> ASJ( jne, 1, b) \</span>
<a name="l01365"></a>01365 <span class="preprocessor"> AS2( lea edx, [edi+16*n])\</span>
<a name="l01366"></a>01366 <span class="preprocessor"> SSE2_FirstMultiply(0) \</span>
<a name="l01367"></a>01367 <span class="preprocessor"></span>
<a name="l01368"></a>01368 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc(i) \</span>
<a name="l01369"></a>01369 <span class="preprocessor"> ASL(LSqu##i) \</span>
<a name="l01370"></a>01370 <span class="preprocessor"> AS2( movdqa xmm1, [esi+(i)*16]) \</span>
<a name="l01371"></a>01371 <span class="preprocessor"> AS2( movdqa xmm0, [edi-(i)*16]) \</span>
<a name="l01372"></a>01372 <span class="preprocessor"> AS2( movdqa xmm2, [ebx]) \</span>
<a name="l01373"></a>01373 <span class="preprocessor"> AS2( pmuludq xmm0, xmm1) \</span>
<a name="l01374"></a>01374 <span class="preprocessor"> AS2( pmuludq xmm1, [edx-(i)*16]) \</span>
<a name="l01375"></a>01375 <span class="preprocessor"> AS2( movdqa xmm3, xmm2) \</span>
<a name="l01376"></a>01376 <span class="preprocessor"> AS2( pand xmm2, xmm0) \</span>
<a name="l01377"></a>01377 <span class="preprocessor"> AS2( psrld xmm0, 16) \</span>
<a name="l01378"></a>01378 <span class="preprocessor"> AS2( paddd xmm4, xmm2) \</span>
<a name="l01379"></a>01379 <span class="preprocessor"> AS2( paddd xmm5, xmm0) \</span>
<a name="l01380"></a>01380 <span class="preprocessor"> AS2( pand xmm3, xmm1) \</span>
<a name="l01381"></a>01381 <span class="preprocessor"> AS2( psrld xmm1, 16) \</span>
<a name="l01382"></a>01382 <span class="preprocessor"> AS2( paddd xmm6, xmm3) \</span>
<a name="l01383"></a>01383 <span class="preprocessor"> AS2( paddd xmm7, xmm1) \</span>
<a name="l01384"></a>01384 <span class="preprocessor"></span>
<a name="l01385"></a>01385 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc1(i) </span>
<a name="l01386"></a>01386 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc2(i) ASC(call, LSqu##i)</span>
<a name="l01387"></a>01387 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc3(i) Squ_Acc2(i)</span>
<a name="l01388"></a>01388 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc4(i) Squ_Acc2(i)</span>
<a name="l01389"></a>01389 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc5(i) Squ_Acc2(i)</span>
<a name="l01390"></a>01390 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc6(i) Squ_Acc2(i)</span>
<a name="l01391"></a>01391 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc7(i) Squ_Acc2(i)</span>
<a name="l01392"></a>01392 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Acc8(i) Squ_Acc2(i)</span>
<a name="l01393"></a>01393 <span class="preprocessor"></span>
<a name="l01394"></a>01394 <span class="preprocessor">#define SSE2_End(E, n) \</span>
<a name="l01395"></a>01395 <span class="preprocessor"> SSE2_SaveShift(2*(n)-3) \</span>
<a name="l01396"></a>01396 <span class="preprocessor"> AS2( movdqa xmm7, [esi+16]) \</span>
<a name="l01397"></a>01397 <span class="preprocessor"> AS2( movdqa xmm0, [edi]) \</span>
<a name="l01398"></a>01398 <span class="preprocessor"> AS2( pmuludq xmm0, xmm7) \</span>
<a name="l01399"></a>01399 <span class="preprocessor"> AS2( movdqa xmm2, [ebx]) \</span>
<a name="l01400"></a>01400 <span class="preprocessor"> AS2( pmuludq xmm7, [edx]) \</span>
<a name="l01401"></a>01401 <span class="preprocessor"> AS2( movdqa xmm6, xmm2) \</span>
<a name="l01402"></a>01402 <span class="preprocessor"> AS2( pand xmm2, xmm0) \</span>
<a name="l01403"></a>01403 <span class="preprocessor"> AS2( psrld xmm0, 16) \</span>
<a name="l01404"></a>01404 <span class="preprocessor"> AS2( paddd xmm4, xmm2) \</span>
<a name="l01405"></a>01405 <span class="preprocessor"> AS2( paddd xmm5, xmm0) \</span>
<a name="l01406"></a>01406 <span class="preprocessor"> AS2( pand xmm6, xmm7) \</span>
<a name="l01407"></a>01407 <span class="preprocessor"> AS2( psrld xmm7, 16) \</span>
<a name="l01408"></a>01408 <span class="preprocessor"> SSE2_SaveShift(2*(n)-2) \</span>
<a name="l01409"></a>01409 <span class="preprocessor"> SSE2_FinalSave(2*(n)-1) \</span>
<a name="l01410"></a>01410 <span class="preprocessor"> AS1( pop esp)\</span>
<a name="l01411"></a>01411 <span class="preprocessor"> E</span>
<a name="l01412"></a>01412 <span class="preprocessor"></span>
<a name="l01413"></a>01413 <span class="preprocessor">#define Squ_End(n) SSE2_End(SquEpilogue, n)</span>
<a name="l01414"></a>01414 <span class="preprocessor"></span><span class="preprocessor">#define Mul_End(n) SSE2_End(MulEpilogue, n)</span>
<a name="l01415"></a>01415 <span class="preprocessor"></span><span class="preprocessor">#define Top_End(n) SSE2_End(TopEpilogue, n)</span>
<a name="l01416"></a>01416 <span class="preprocessor"></span>
<a name="l01417"></a>01417 <span class="preprocessor">#define Squ_Column1(k, i) \</span>
<a name="l01418"></a>01418 <span class="preprocessor"> Squ_SSE2_SaveShift(k) \</span>
<a name="l01419"></a>01419 <span class="preprocessor"> AS2( add esi, 16) \</span>
<a name="l01420"></a>01420 <span class="preprocessor"> SSE2_FirstMultiply(1)\</span>
<a name="l01421"></a>01421 <span class="preprocessor"> Squ_Acc##i(i) \</span>
<a name="l01422"></a>01422 <span class="preprocessor"> AS2( paddd xmm4, xmm4) \</span>
<a name="l01423"></a>01423 <span class="preprocessor"> AS2( paddd xmm5, xmm5) \</span>
<a name="l01424"></a>01424 <span class="preprocessor"> AS2( movdqa xmm3, [esi]) \</span>
<a name="l01425"></a>01425 <span class="preprocessor"> AS2( movq xmm1, QWORD PTR [esi+8]) \</span>
<a name="l01426"></a>01426 <span class="preprocessor"> AS2( pmuludq xmm1, xmm3) \</span>
<a name="l01427"></a>01427 <span class="preprocessor"> AS2( pmuludq xmm3, xmm3) \</span>
<a name="l01428"></a>01428 <span class="preprocessor"> AS2( movdqa xmm0, [ebx])\</span>
<a name="l01429"></a>01429 <span class="preprocessor"> AS2( movdqa xmm2, xmm0) \</span>
<a name="l01430"></a>01430 <span class="preprocessor"> AS2( pand xmm0, xmm1) \</span>
<a name="l01431"></a>01431 <span class="preprocessor"> AS2( psrld xmm1, 16) \</span>
<a name="l01432"></a>01432 <span class="preprocessor"> AS2( paddd xmm6, xmm0) \</span>
<a name="l01433"></a>01433 <span class="preprocessor"> AS2( paddd xmm7, xmm1) \</span>
<a name="l01434"></a>01434 <span class="preprocessor"> AS2( pand xmm2, xmm3) \</span>
<a name="l01435"></a>01435 <span class="preprocessor"> AS2( psrld xmm3, 16) \</span>
<a name="l01436"></a>01436 <span class="preprocessor"> AS2( paddd xmm6, xmm6) \</span>
<a name="l01437"></a>01437 <span class="preprocessor"> AS2( paddd xmm7, xmm7) \</span>
<a name="l01438"></a>01438 <span class="preprocessor"> AS2( paddd xmm4, xmm2) \</span>
<a name="l01439"></a>01439 <span class="preprocessor"> AS2( paddd xmm5, xmm3) \</span>
<a name="l01440"></a>01440 <span class="preprocessor"> AS2( movq xmm0, QWORD PTR [esp+4])\</span>
<a name="l01441"></a>01441 <span class="preprocessor"> AS2( movq xmm1, QWORD PTR [esp+12])\</span>
<a name="l01442"></a>01442 <span class="preprocessor"> AS2( paddd xmm4, xmm0)\</span>
<a name="l01443"></a>01443 <span class="preprocessor"> AS2( paddd xmm5, xmm1)\</span>
<a name="l01444"></a>01444 <span class="preprocessor"></span>
<a name="l01445"></a>01445 <span class="preprocessor"></span><span class="preprocessor">#define Squ_Column0(k, i) \</span>
<a name="l01446"></a>01446 <span class="preprocessor"> Squ_SSE2_SaveShift(k) \</span>
<a name="l01447"></a>01447 <span class="preprocessor"> AS2( add edi, 16) \</span>
<a name="l01448"></a>01448 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01449"></a>01449 <span class="preprocessor"> SSE2_FirstMultiply(1)\</span>
<a name="l01450"></a>01450 <span class="preprocessor"> Squ_Acc##i(i) \</span>
<a name="l01451"></a>01451 <span class="preprocessor"> AS2( paddd xmm6, xmm6) \</span>
<a name="l01452"></a>01452 <span class="preprocessor"> AS2( paddd xmm7, xmm7) \</span>
<a name="l01453"></a>01453 <span class="preprocessor"> AS2( paddd xmm4, xmm4) \</span>
<a name="l01454"></a>01454 <span class="preprocessor"> AS2( paddd xmm5, xmm5) \</span>
<a name="l01455"></a>01455 <span class="preprocessor"> AS2( movq xmm0, QWORD PTR [esp+4])\</span>
<a name="l01456"></a>01456 <span class="preprocessor"> AS2( movq xmm1, QWORD PTR [esp+12])\</span>
<a name="l01457"></a>01457 <span class="preprocessor"> AS2( paddd xmm4, xmm0)\</span>
<a name="l01458"></a>01458 <span class="preprocessor"> AS2( paddd xmm5, xmm1)\</span>
<a name="l01459"></a>01459 <span class="preprocessor"></span>
<a name="l01460"></a>01460 <span class="preprocessor"></span><span class="preprocessor">#define SSE2_MulAdd45 \</span>
<a name="l01461"></a>01461 <span class="preprocessor"> AS2( movdqa xmm7, [esi]) \</span>
<a name="l01462"></a>01462 <span class="preprocessor"> AS2( movdqa xmm0, [edi]) \</span>
<a name="l01463"></a>01463 <span class="preprocessor"> AS2( pmuludq xmm0, xmm7) \</span>
<a name="l01464"></a>01464 <span class="preprocessor"> AS2( movdqa xmm2, [ebx]) \</span>
<a name="l01465"></a>01465 <span class="preprocessor"> AS2( pmuludq xmm7, [edx]) \</span>
<a name="l01466"></a>01466 <span class="preprocessor"> AS2( movdqa xmm6, xmm2) \</span>
<a name="l01467"></a>01467 <span class="preprocessor"> AS2( pand xmm2, xmm0) \</span>
<a name="l01468"></a>01468 <span class="preprocessor"> AS2( psrld xmm0, 16) \</span>
<a name="l01469"></a>01469 <span class="preprocessor"> AS2( paddd xmm4, xmm2) \</span>
<a name="l01470"></a>01470 <span class="preprocessor"> AS2( paddd xmm5, xmm0) \</span>
<a name="l01471"></a>01471 <span class="preprocessor"> AS2( pand xmm6, xmm7) \</span>
<a name="l01472"></a>01472 <span class="preprocessor"> AS2( psrld xmm7, 16)</span>
<a name="l01473"></a>01473 <span class="preprocessor"></span>
<a name="l01474"></a>01474 <span class="preprocessor">#define Mul_Begin(n) \</span>
<a name="l01475"></a>01475 <span class="preprocessor"> MulPrologue \</span>
<a name="l01476"></a>01476 <span class="preprocessor"> AS2( mov esi, esp)\</span>
<a name="l01477"></a>01477 <span class="preprocessor"> AS2( and esp, 0xfffffff0)\</span>
<a name="l01478"></a>01478 <span class="preprocessor"> AS2( sub esp, 48*n+16)\</span>
<a name="l01479"></a>01479 <span class="preprocessor"> AS1( push esi)\</span>
<a name="l01480"></a>01480 <span class="preprocessor"> AS2( xor edx, edx) \</span>
<a name="l01481"></a>01481 <span class="preprocessor"> ASL(1) \</span>
<a name="l01482"></a>01482 <span class="preprocessor"> ASS( pshufd xmm0, [eax+edx], 3,1,2,0) \</span>
<a name="l01483"></a>01483 <span class="preprocessor"> ASS( pshufd xmm1, [eax+edx], 2,0,3,1) \</span>
<a name="l01484"></a>01484 <span class="preprocessor"> ASS( pshufd xmm2, [edi+edx], 3,1,2,0) \</span>
<a name="l01485"></a>01485 <span class="preprocessor"> AS2( movdqa [esp+20+2*edx], xmm0) \</span>
<a name="l01486"></a>01486 <span class="preprocessor"> AS2( psrlq xmm0, 32) \</span>
<a name="l01487"></a>01487 <span class="preprocessor"> AS2( movdqa [esp+20+2*edx+16], xmm0) \</span>
<a name="l01488"></a>01488 <span class="preprocessor"> AS2( movdqa [esp+20+16*n+2*edx], xmm1) \</span>
<a name="l01489"></a>01489 <span class="preprocessor"> AS2( psrlq xmm1, 32) \</span>
<a name="l01490"></a>01490 <span class="preprocessor"> AS2( movdqa [esp+20+16*n+2*edx+16], xmm1) \</span>
<a name="l01491"></a>01491 <span class="preprocessor"> AS2( movdqa [esp+20+32*n+2*edx], xmm2) \</span>
<a name="l01492"></a>01492 <span class="preprocessor"> AS2( psrlq xmm2, 32) \</span>
<a name="l01493"></a>01493 <span class="preprocessor"> AS2( movdqa [esp+20+32*n+2*edx+16], xmm2) \</span>
<a name="l01494"></a>01494 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01495"></a>01495 <span class="preprocessor"> AS2( cmp edx, 8*(n)) \</span>
<a name="l01496"></a>01496 <span class="preprocessor"> ASJ( jne, 1, b) \</span>
<a name="l01497"></a>01497 <span class="preprocessor"> AS2( lea edi, [esp+20])\</span>
<a name="l01498"></a>01498 <span class="preprocessor"> AS2( lea edx, [esp+20+16*n])\</span>
<a name="l01499"></a>01499 <span class="preprocessor"> AS2( lea esi, [esp+20+32*n])\</span>
<a name="l01500"></a>01500 <span class="preprocessor"> SSE2_FirstMultiply(0) \</span>
<a name="l01501"></a>01501 <span class="preprocessor"></span>
<a name="l01502"></a>01502 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc(i) \</span>
<a name="l01503"></a>01503 <span class="preprocessor"> ASL(LMul##i) \</span>
<a name="l01504"></a>01504 <span class="preprocessor"> AS2( movdqa xmm1, [esi+i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01505"></a>01505 <span class="preprocessor"> AS2( movdqa xmm0, [edi-i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01506"></a>01506 <span class="preprocessor"> AS2( movdqa xmm2, [ebx]) \</span>
<a name="l01507"></a>01507 <span class="preprocessor"> AS2( pmuludq xmm0, xmm1) \</span>
<a name="l01508"></a>01508 <span class="preprocessor"> AS2( pmuludq xmm1, [edx-i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01509"></a>01509 <span class="preprocessor"> AS2( movdqa xmm3, xmm2) \</span>
<a name="l01510"></a>01510 <span class="preprocessor"> AS2( pand xmm2, xmm0) \</span>
<a name="l01511"></a>01511 <span class="preprocessor"> AS2( psrld xmm0, 16) \</span>
<a name="l01512"></a>01512 <span class="preprocessor"> AS2( paddd xmm4, xmm2) \</span>
<a name="l01513"></a>01513 <span class="preprocessor"> AS2( paddd xmm5, xmm0) \</span>
<a name="l01514"></a>01514 <span class="preprocessor"> AS2( pand xmm3, xmm1) \</span>
<a name="l01515"></a>01515 <span class="preprocessor"> AS2( psrld xmm1, 16) \</span>
<a name="l01516"></a>01516 <span class="preprocessor"> AS2( paddd xmm6, xmm3) \</span>
<a name="l01517"></a>01517 <span class="preprocessor"> AS2( paddd xmm7, xmm1) \</span>
<a name="l01518"></a>01518 <span class="preprocessor"></span>
<a name="l01519"></a>01519 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc1(i) </span>
<a name="l01520"></a>01520 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc2(i) ASC(call, LMul##i)</span>
<a name="l01521"></a>01521 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc3(i) Mul_Acc2(i)</span>
<a name="l01522"></a>01522 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc4(i) Mul_Acc2(i)</span>
<a name="l01523"></a>01523 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc5(i) Mul_Acc2(i)</span>
<a name="l01524"></a>01524 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc6(i) Mul_Acc2(i)</span>
<a name="l01525"></a>01525 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc7(i) Mul_Acc2(i)</span>
<a name="l01526"></a>01526 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc8(i) Mul_Acc2(i)</span>
<a name="l01527"></a>01527 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc9(i) Mul_Acc2(i)</span>
<a name="l01528"></a>01528 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc10(i) Mul_Acc2(i)</span>
<a name="l01529"></a>01529 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc11(i) Mul_Acc2(i)</span>
<a name="l01530"></a>01530 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc12(i) Mul_Acc2(i)</span>
<a name="l01531"></a>01531 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc13(i) Mul_Acc2(i)</span>
<a name="l01532"></a>01532 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc14(i) Mul_Acc2(i)</span>
<a name="l01533"></a>01533 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc15(i) Mul_Acc2(i)</span>
<a name="l01534"></a>01534 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Acc16(i) Mul_Acc2(i)</span>
<a name="l01535"></a>01535 <span class="preprocessor"></span>
<a name="l01536"></a>01536 <span class="preprocessor">#define Mul_Column1(k, i) \</span>
<a name="l01537"></a>01537 <span class="preprocessor"> SSE2_SaveShift(k) \</span>
<a name="l01538"></a>01538 <span class="preprocessor"> AS2( add esi, 16) \</span>
<a name="l01539"></a>01539 <span class="preprocessor"> SSE2_MulAdd45\</span>
<a name="l01540"></a>01540 <span class="preprocessor"> Mul_Acc##i(i) \</span>
<a name="l01541"></a>01541 <span class="preprocessor"></span>
<a name="l01542"></a>01542 <span class="preprocessor"></span><span class="preprocessor">#define Mul_Column0(k, i) \</span>
<a name="l01543"></a>01543 <span class="preprocessor"> SSE2_SaveShift(k) \</span>
<a name="l01544"></a>01544 <span class="preprocessor"> AS2( add edi, 16) \</span>
<a name="l01545"></a>01545 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01546"></a>01546 <span class="preprocessor"> SSE2_MulAdd45\</span>
<a name="l01547"></a>01547 <span class="preprocessor"> Mul_Acc##i(i) \</span>
<a name="l01548"></a>01548 <span class="preprocessor"></span>
<a name="l01549"></a>01549 <span class="preprocessor"></span><span class="preprocessor">#define Bot_Acc(i) \</span>
<a name="l01550"></a>01550 <span class="preprocessor"> AS2( movdqa xmm1, [esi+i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01551"></a>01551 <span class="preprocessor"> AS2( movdqa xmm0, [edi-i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01552"></a>01552 <span class="preprocessor"> AS2( pmuludq xmm0, xmm1) \</span>
<a name="l01553"></a>01553 <span class="preprocessor"> AS2( pmuludq xmm1, [edx-i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01554"></a>01554 <span class="preprocessor"> AS2( paddq xmm4, xmm0) \</span>
<a name="l01555"></a>01555 <span class="preprocessor"> AS2( paddd xmm6, xmm1)</span>
<a name="l01556"></a>01556 <span class="preprocessor"></span>
<a name="l01557"></a>01557 <span class="preprocessor">#define Bot_SaveAcc(k) \</span>
<a name="l01558"></a>01558 <span class="preprocessor"> SSE2_SaveShift(k) \</span>
<a name="l01559"></a>01559 <span class="preprocessor"> AS2( add edi, 16) \</span>
<a name="l01560"></a>01560 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01561"></a>01561 <span class="preprocessor"> AS2( movdqa xmm6, [esi]) \</span>
<a name="l01562"></a>01562 <span class="preprocessor"> AS2( movdqa xmm0, [edi]) \</span>
<a name="l01563"></a>01563 <span class="preprocessor"> AS2( pmuludq xmm0, xmm6) \</span>
<a name="l01564"></a>01564 <span class="preprocessor"> AS2( paddq xmm4, xmm0) \</span>
<a name="l01565"></a>01565 <span class="preprocessor"> AS2( psllq xmm5, 16) \</span>
<a name="l01566"></a>01566 <span class="preprocessor"> AS2( paddq xmm4, xmm5) \</span>
<a name="l01567"></a>01567 <span class="preprocessor"> AS2( pmuludq xmm6, [edx])</span>
<a name="l01568"></a>01568 <span class="preprocessor"></span>
<a name="l01569"></a>01569 <span class="preprocessor">#define Bot_End(n) \</span>
<a name="l01570"></a>01570 <span class="preprocessor"> AS2( movhlps xmm7, xmm6) \</span>
<a name="l01571"></a>01571 <span class="preprocessor"> AS2( paddd xmm6, xmm7) \</span>
<a name="l01572"></a>01572 <span class="preprocessor"> AS2( psllq xmm6, 32) \</span>
<a name="l01573"></a>01573 <span class="preprocessor"> AS2( paddd xmm4, xmm6) \</span>
<a name="l01574"></a>01574 <span class="preprocessor"> AS2( movq QWORD PTR [ecx+8*((n)-1)], xmm4) \</span>
<a name="l01575"></a>01575 <span class="preprocessor"> AS1( pop esp)\</span>
<a name="l01576"></a>01576 <span class="preprocessor"> MulEpilogue</span>
<a name="l01577"></a>01577 <span class="preprocessor"></span>
<a name="l01578"></a>01578 <span class="preprocessor">#define Top_Begin(n) \</span>
<a name="l01579"></a>01579 <span class="preprocessor"> TopPrologue \</span>
<a name="l01580"></a>01580 <span class="preprocessor"> AS2( mov edx, esp)\</span>
<a name="l01581"></a>01581 <span class="preprocessor"> AS2( and esp, 0xfffffff0)\</span>
<a name="l01582"></a>01582 <span class="preprocessor"> AS2( sub esp, 48*n+16)\</span>
<a name="l01583"></a>01583 <span class="preprocessor"> AS1( push edx)\</span>
<a name="l01584"></a>01584 <span class="preprocessor"> AS2( xor edx, edx) \</span>
<a name="l01585"></a>01585 <span class="preprocessor"> ASL(1) \</span>
<a name="l01586"></a>01586 <span class="preprocessor"> ASS( pshufd xmm0, [eax+edx], 3,1,2,0) \</span>
<a name="l01587"></a>01587 <span class="preprocessor"> ASS( pshufd xmm1, [eax+edx], 2,0,3,1) \</span>
<a name="l01588"></a>01588 <span class="preprocessor"> ASS( pshufd xmm2, [edi+edx], 3,1,2,0) \</span>
<a name="l01589"></a>01589 <span class="preprocessor"> AS2( movdqa [esp+20+2*edx], xmm0) \</span>
<a name="l01590"></a>01590 <span class="preprocessor"> AS2( psrlq xmm0, 32) \</span>
<a name="l01591"></a>01591 <span class="preprocessor"> AS2( movdqa [esp+20+2*edx+16], xmm0) \</span>
<a name="l01592"></a>01592 <span class="preprocessor"> AS2( movdqa [esp+20+16*n+2*edx], xmm1) \</span>
<a name="l01593"></a>01593 <span class="preprocessor"> AS2( psrlq xmm1, 32) \</span>
<a name="l01594"></a>01594 <span class="preprocessor"> AS2( movdqa [esp+20+16*n+2*edx+16], xmm1) \</span>
<a name="l01595"></a>01595 <span class="preprocessor"> AS2( movdqa [esp+20+32*n+2*edx], xmm2) \</span>
<a name="l01596"></a>01596 <span class="preprocessor"> AS2( psrlq xmm2, 32) \</span>
<a name="l01597"></a>01597 <span class="preprocessor"> AS2( movdqa [esp+20+32*n+2*edx+16], xmm2) \</span>
<a name="l01598"></a>01598 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01599"></a>01599 <span class="preprocessor"> AS2( cmp edx, 8*(n)) \</span>
<a name="l01600"></a>01600 <span class="preprocessor"> ASJ( jne, 1, b) \</span>
<a name="l01601"></a>01601 <span class="preprocessor"> AS2( mov eax, esi) \</span>
<a name="l01602"></a>01602 <span class="preprocessor"> AS2( lea edi, [esp+20+00*n+16*(n/2-1)])\</span>
<a name="l01603"></a>01603 <span class="preprocessor"> AS2( lea edx, [esp+20+16*n+16*(n/2-1)])\</span>
<a name="l01604"></a>01604 <span class="preprocessor"> AS2( lea esi, [esp+20+32*n+16*(n/2-1)])\</span>
<a name="l01605"></a>01605 <span class="preprocessor"> AS2( pxor xmm4, xmm4)\</span>
<a name="l01606"></a>01606 <span class="preprocessor"> AS2( pxor xmm5, xmm5)</span>
<a name="l01607"></a>01607 <span class="preprocessor"></span>
<a name="l01608"></a>01608 <span class="preprocessor">#define Top_Acc(i) \</span>
<a name="l01609"></a>01609 <span class="preprocessor"> AS2( movq xmm0, QWORD PTR [esi+i/2*(1-(i-2*(i/2))*2)*16+8]) \</span>
<a name="l01610"></a>01610 <span class="preprocessor"> AS2( pmuludq xmm0, [edx-i/2*(1-(i-2*(i/2))*2)*16]) \</span>
<a name="l01611"></a>01611 <span class="preprocessor"> AS2( psrlq xmm0, 48) \</span>
<a name="l01612"></a>01612 <span class="preprocessor"> AS2( paddd xmm5, xmm0)\</span>
<a name="l01613"></a>01613 <span class="preprocessor"></span>
<a name="l01614"></a>01614 <span class="preprocessor"></span><span class="preprocessor">#define Top_Column0(i) \</span>
<a name="l01615"></a>01615 <span class="preprocessor"> AS2( psllq xmm5, 32) \</span>
<a name="l01616"></a>01616 <span class="preprocessor"> AS2( add edi, 16) \</span>
<a name="l01617"></a>01617 <span class="preprocessor"> AS2( add edx, 16) \</span>
<a name="l01618"></a>01618 <span class="preprocessor"> SSE2_MulAdd45\</span>
<a name="l01619"></a>01619 <span class="preprocessor"> Mul_Acc##i(i) \</span>
<a name="l01620"></a>01620 <span class="preprocessor"></span>
<a name="l01621"></a>01621 <span class="preprocessor"></span><span class="preprocessor">#define Top_Column1(i) \</span>
<a name="l01622"></a>01622 <span class="preprocessor"> SSE2_SaveShift(0) \</span>
<a name="l01623"></a>01623 <span class="preprocessor"> AS2( add esi, 16) \</span>
<a name="l01624"></a>01624 <span class="preprocessor"> SSE2_MulAdd45\</span>
<a name="l01625"></a>01625 <span class="preprocessor"> Mul_Acc##i(i) \</span>
<a name="l01626"></a>01626 <span class="preprocessor"> AS2( shr eax, 16) \</span>
<a name="l01627"></a>01627 <span class="preprocessor"> AS2( movd xmm0, eax)\</span>
<a name="l01628"></a>01628 <span class="preprocessor"> AS2( movd xmm1, [ecx+4])\</span>
<a name="l01629"></a>01629 <span class="preprocessor"> AS2( psrld xmm1, 16)\</span>
<a name="l01630"></a>01630 <span class="preprocessor"> AS2( pcmpgtd xmm1, xmm0)\</span>
<a name="l01631"></a>01631 <span class="preprocessor"> AS2( psrld xmm1, 31)\</span>
<a name="l01632"></a>01632 <span class="preprocessor"> AS2( paddd xmm4, xmm1)\</span>
<a name="l01633"></a>01633 <span class="preprocessor"></span>
<a name="l01634"></a>01634 <span class="preprocessor"></span><span class="keywordtype">void</span> SSE2_Square4(word *C, <span class="keyword">const</span> word *A)
<a name="l01635"></a>01635 {
<a name="l01636"></a>01636 Squ_Begin(2)
<a name="l01637"></a>01637 Squ_Column0(0, 1)
<a name="l01638"></a>01638 Squ_End(2)
<a name="l01639"></a>01639 }
<a name="l01640"></a>01640
<a name="l01641"></a>01641 <span class="keywordtype">void</span> SSE2_Square8(word *C, const word *A)
<a name="l01642"></a>01642 {
<a name="l01643"></a>01643 Squ_Begin(4)
<a name="l01644"></a>01644 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01645"></a>01645 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01646"></a>01646 Squ_Acc(2)
<a name="l01647"></a>01647 AS1( ret) ASL(0)
<a name="l01648"></a>01648 <span class="preprocessor">#endif</span>
<a name="l01649"></a>01649 <span class="preprocessor"></span> Squ_Column0(0, 1)
<a name="l01650"></a>01650 Squ_Column1(1, 1)
<a name="l01651"></a>01651 Squ_Column0(2, 2)
<a name="l01652"></a>01652 Squ_Column1(3, 1)
<a name="l01653"></a>01653 Squ_Column0(4, 1)
<a name="l01654"></a>01654 Squ_End(4)
<a name="l01655"></a>01655 }
<a name="l01656"></a>01656
<a name="l01657"></a>01657 <span class="keywordtype">void</span> SSE2_Square16(word *C, const word *A)
<a name="l01658"></a>01658 {
<a name="l01659"></a>01659 Squ_Begin(8)
<a name="l01660"></a>01660 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01661"></a>01661 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01662"></a>01662 Squ_Acc(4) Squ_Acc(3) Squ_Acc(2)
<a name="l01663"></a>01663 AS1( ret) ASL(0)
<a name="l01664"></a>01664 <span class="preprocessor">#endif</span>
<a name="l01665"></a>01665 <span class="preprocessor"></span> Squ_Column0(0, 1)
<a name="l01666"></a>01666 Squ_Column1(1, 1)
<a name="l01667"></a>01667 Squ_Column0(2, 2)
<a name="l01668"></a>01668 Squ_Column1(3, 2)
<a name="l01669"></a>01669 Squ_Column0(4, 3)
<a name="l01670"></a>01670 Squ_Column1(5, 3)
<a name="l01671"></a>01671 Squ_Column0(6, 4)
<a name="l01672"></a>01672 Squ_Column1(7, 3)
<a name="l01673"></a>01673 Squ_Column0(8, 3)
<a name="l01674"></a>01674 Squ_Column1(9, 2)
<a name="l01675"></a>01675 Squ_Column0(10, 2)
<a name="l01676"></a>01676 Squ_Column1(11, 1)
<a name="l01677"></a>01677 Squ_Column0(12, 1)
<a name="l01678"></a>01678 Squ_End(8)
<a name="l01679"></a>01679 }
<a name="l01680"></a>01680
<a name="l01681"></a>01681 <span class="keywordtype">void</span> SSE2_Square32(word *C, const word *A)
<a name="l01682"></a>01682 {
<a name="l01683"></a>01683 Squ_Begin(16)
<a name="l01684"></a>01684 ASJ( jmp, 0, f)
<a name="l01685"></a>01685 Squ_Acc(8) Squ_Acc(7) Squ_Acc(6) Squ_Acc(5) Squ_Acc(4) Squ_Acc(3) Squ_Acc(2)
<a name="l01686"></a>01686 AS1( ret) ASL(0)
<a name="l01687"></a>01687 Squ_Column0(0, 1)
<a name="l01688"></a>01688 Squ_Column1(1, 1)
<a name="l01689"></a>01689 Squ_Column0(2, 2)
<a name="l01690"></a>01690 Squ_Column1(3, 2)
<a name="l01691"></a>01691 Squ_Column0(4, 3)
<a name="l01692"></a>01692 Squ_Column1(5, 3)
<a name="l01693"></a>01693 Squ_Column0(6, 4)
<a name="l01694"></a>01694 Squ_Column1(7, 4)
<a name="l01695"></a>01695 Squ_Column0(8, 5)
<a name="l01696"></a>01696 Squ_Column1(9, 5)
<a name="l01697"></a>01697 Squ_Column0(10, 6)
<a name="l01698"></a>01698 Squ_Column1(11, 6)
<a name="l01699"></a>01699 Squ_Column0(12, 7)
<a name="l01700"></a>01700 Squ_Column1(13, 7)
<a name="l01701"></a>01701 Squ_Column0(14, 8)
<a name="l01702"></a>01702 Squ_Column1(15, 7)
<a name="l01703"></a>01703 Squ_Column0(16, 7)
<a name="l01704"></a>01704 Squ_Column1(17, 6)
<a name="l01705"></a>01705 Squ_Column0(18, 6)
<a name="l01706"></a>01706 Squ_Column1(19, 5)
<a name="l01707"></a>01707 Squ_Column0(20, 5)
<a name="l01708"></a>01708 Squ_Column1(21, 4)
<a name="l01709"></a>01709 Squ_Column0(22, 4)
<a name="l01710"></a>01710 Squ_Column1(23, 3)
<a name="l01711"></a>01711 Squ_Column0(24, 3)
<a name="l01712"></a>01712 Squ_Column1(25, 2)
<a name="l01713"></a>01713 Squ_Column0(26, 2)
<a name="l01714"></a>01714 Squ_Column1(27, 1)
<a name="l01715"></a>01715 Squ_Column0(28, 1)
<a name="l01716"></a>01716 Squ_End(16)
<a name="l01717"></a>01717 }
<a name="l01718"></a>01718
<a name="l01719"></a>01719 <span class="keywordtype">void</span> SSE2_Multiply4(word *C, const word *A, const word *B)
<a name="l01720"></a>01720 {
<a name="l01721"></a>01721 Mul_Begin(2)
<a name="l01722"></a>01722 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01723"></a>01723 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01724"></a>01724 Mul_Acc(2)
<a name="l01725"></a>01725 AS1( ret) ASL(0)
<a name="l01726"></a>01726 <span class="preprocessor">#endif</span>
<a name="l01727"></a>01727 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01728"></a>01728 Mul_End(2)
<a name="l01729"></a>01729 }
<a name="l01730"></a>01730
<a name="l01731"></a>01731 <span class="keywordtype">void</span> SSE2_Multiply8(word *C, const word *A, const word *B)
<a name="l01732"></a>01732 {
<a name="l01733"></a>01733 Mul_Begin(4)
<a name="l01734"></a>01734 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01735"></a>01735 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01736"></a>01736 Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01737"></a>01737 AS1( ret) ASL(0)
<a name="l01738"></a>01738 <span class="preprocessor">#endif</span>
<a name="l01739"></a>01739 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01740"></a>01740 Mul_Column1(1, 3)
<a name="l01741"></a>01741 Mul_Column0(2, 4)
<a name="l01742"></a>01742 Mul_Column1(3, 3)
<a name="l01743"></a>01743 Mul_Column0(4, 2)
<a name="l01744"></a>01744 Mul_End(4)
<a name="l01745"></a>01745 }
<a name="l01746"></a>01746
<a name="l01747"></a>01747 <span class="keywordtype">void</span> SSE2_Multiply16(word *C, const word *A, const word *B)
<a name="l01748"></a>01748 {
<a name="l01749"></a>01749 Mul_Begin(8)
<a name="l01750"></a>01750 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01751"></a>01751 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01752"></a>01752 Mul_Acc(8) Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01753"></a>01753 AS1( ret) ASL(0)
<a name="l01754"></a>01754 <span class="preprocessor">#endif</span>
<a name="l01755"></a>01755 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01756"></a>01756 Mul_Column1(1, 3)
<a name="l01757"></a>01757 Mul_Column0(2, 4)
<a name="l01758"></a>01758 Mul_Column1(3, 5)
<a name="l01759"></a>01759 Mul_Column0(4, 6)
<a name="l01760"></a>01760 Mul_Column1(5, 7)
<a name="l01761"></a>01761 Mul_Column0(6, 8)
<a name="l01762"></a>01762 Mul_Column1(7, 7)
<a name="l01763"></a>01763 Mul_Column0(8, 6)
<a name="l01764"></a>01764 Mul_Column1(9, 5)
<a name="l01765"></a>01765 Mul_Column0(10, 4)
<a name="l01766"></a>01766 Mul_Column1(11, 3)
<a name="l01767"></a>01767 Mul_Column0(12, 2)
<a name="l01768"></a>01768 Mul_End(8)
<a name="l01769"></a>01769 }
<a name="l01770"></a>01770
<a name="l01771"></a>01771 <span class="keywordtype">void</span> SSE2_Multiply32(word *C, const word *A, const word *B)
<a name="l01772"></a>01772 {
<a name="l01773"></a>01773 Mul_Begin(16)
<a name="l01774"></a>01774 ASJ( jmp, 0, f)
<a name="l01775"></a>01775 Mul_Acc(16) Mul_Acc(15) Mul_Acc(14) Mul_Acc(13) Mul_Acc(12) Mul_Acc(11) Mul_Acc(10) Mul_Acc(9) Mul_Acc(8) Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01776"></a>01776 AS1( ret) ASL(0)
<a name="l01777"></a>01777 Mul_Column0(0, 2)
<a name="l01778"></a>01778 Mul_Column1(1, 3)
<a name="l01779"></a>01779 Mul_Column0(2, 4)
<a name="l01780"></a>01780 Mul_Column1(3, 5)
<a name="l01781"></a>01781 Mul_Column0(4, 6)
<a name="l01782"></a>01782 Mul_Column1(5, 7)
<a name="l01783"></a>01783 Mul_Column0(6, 8)
<a name="l01784"></a>01784 Mul_Column1(7, 9)
<a name="l01785"></a>01785 Mul_Column0(8, 10)
<a name="l01786"></a>01786 Mul_Column1(9, 11)
<a name="l01787"></a>01787 Mul_Column0(10, 12)
<a name="l01788"></a>01788 Mul_Column1(11, 13)
<a name="l01789"></a>01789 Mul_Column0(12, 14)
<a name="l01790"></a>01790 Mul_Column1(13, 15)
<a name="l01791"></a>01791 Mul_Column0(14, 16)
<a name="l01792"></a>01792 Mul_Column1(15, 15)
<a name="l01793"></a>01793 Mul_Column0(16, 14)
<a name="l01794"></a>01794 Mul_Column1(17, 13)
<a name="l01795"></a>01795 Mul_Column0(18, 12)
<a name="l01796"></a>01796 Mul_Column1(19, 11)
<a name="l01797"></a>01797 Mul_Column0(20, 10)
<a name="l01798"></a>01798 Mul_Column1(21, 9)
<a name="l01799"></a>01799 Mul_Column0(22, 8)
<a name="l01800"></a>01800 Mul_Column1(23, 7)
<a name="l01801"></a>01801 Mul_Column0(24, 6)
<a name="l01802"></a>01802 Mul_Column1(25, 5)
<a name="l01803"></a>01803 Mul_Column0(26, 4)
<a name="l01804"></a>01804 Mul_Column1(27, 3)
<a name="l01805"></a>01805 Mul_Column0(28, 2)
<a name="l01806"></a>01806 Mul_End(16)
<a name="l01807"></a>01807 }
<a name="l01808"></a>01808
<a name="l01809"></a>01809 <span class="keywordtype">void</span> SSE2_MultiplyBottom4(word *C, const word *A, const word *B)
<a name="l01810"></a>01810 {
<a name="l01811"></a>01811 Mul_Begin(2)
<a name="l01812"></a>01812 Bot_SaveAcc(0) Bot_Acc(2)
<a name="l01813"></a>01813 Bot_End(2)
<a name="l01814"></a>01814 }
<a name="l01815"></a>01815
<a name="l01816"></a>01816 <span class="keywordtype">void</span> SSE2_MultiplyBottom8(word *C, const word *A, const word *B)
<a name="l01817"></a>01817 {
<a name="l01818"></a>01818 Mul_Begin(4)
<a name="l01819"></a>01819 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01820"></a>01820 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01821"></a>01821 Mul_Acc(3) Mul_Acc(2)
<a name="l01822"></a>01822 AS1( ret) ASL(0)
<a name="l01823"></a>01823 <span class="preprocessor">#endif</span>
<a name="l01824"></a>01824 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01825"></a>01825 Mul_Column1(1, 3)
<a name="l01826"></a>01826 Bot_SaveAcc(2) Bot_Acc(4) Bot_Acc(3) Bot_Acc(2)
<a name="l01827"></a>01827 Bot_End(4)
<a name="l01828"></a>01828 }
<a name="l01829"></a>01829
<a name="l01830"></a>01830 <span class="keywordtype">void</span> SSE2_MultiplyBottom16(word *C, const word *A, const word *B)
<a name="l01831"></a>01831 {
<a name="l01832"></a>01832 Mul_Begin(8)
<a name="l01833"></a>01833 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01834"></a>01834 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01835"></a>01835 Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01836"></a>01836 AS1( ret) ASL(0)
<a name="l01837"></a>01837 <span class="preprocessor">#endif</span>
<a name="l01838"></a>01838 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01839"></a>01839 Mul_Column1(1, 3)
<a name="l01840"></a>01840 Mul_Column0(2, 4)
<a name="l01841"></a>01841 Mul_Column1(3, 5)
<a name="l01842"></a>01842 Mul_Column0(4, 6)
<a name="l01843"></a>01843 Mul_Column1(5, 7)
<a name="l01844"></a>01844 Bot_SaveAcc(6) Bot_Acc(8) Bot_Acc(7) Bot_Acc(6) Bot_Acc(5) Bot_Acc(4) Bot_Acc(3) Bot_Acc(2)
<a name="l01845"></a>01845 Bot_End(8)
<a name="l01846"></a>01846 }
<a name="l01847"></a>01847
<a name="l01848"></a>01848 <span class="keywordtype">void</span> SSE2_MultiplyBottom32(word *C, const word *A, const word *B)
<a name="l01849"></a>01849 {
<a name="l01850"></a>01850 Mul_Begin(16)
<a name="l01851"></a>01851 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01852"></a>01852 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01853"></a>01853 Mul_Acc(15) Mul_Acc(14) Mul_Acc(13) Mul_Acc(12) Mul_Acc(11) Mul_Acc(10) Mul_Acc(9) Mul_Acc(8) Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01854"></a>01854 AS1( ret) ASL(0)
<a name="l01855"></a>01855 <span class="preprocessor">#endif</span>
<a name="l01856"></a>01856 <span class="preprocessor"></span> Mul_Column0(0, 2)
<a name="l01857"></a>01857 Mul_Column1(1, 3)
<a name="l01858"></a>01858 Mul_Column0(2, 4)
<a name="l01859"></a>01859 Mul_Column1(3, 5)
<a name="l01860"></a>01860 Mul_Column0(4, 6)
<a name="l01861"></a>01861 Mul_Column1(5, 7)
<a name="l01862"></a>01862 Mul_Column0(6, 8)
<a name="l01863"></a>01863 Mul_Column1(7, 9)
<a name="l01864"></a>01864 Mul_Column0(8, 10)
<a name="l01865"></a>01865 Mul_Column1(9, 11)
<a name="l01866"></a>01866 Mul_Column0(10, 12)
<a name="l01867"></a>01867 Mul_Column1(11, 13)
<a name="l01868"></a>01868 Mul_Column0(12, 14)
<a name="l01869"></a>01869 Mul_Column1(13, 15)
<a name="l01870"></a>01870 Bot_SaveAcc(14) Bot_Acc(16) Bot_Acc(15) Bot_Acc(14) Bot_Acc(13) Bot_Acc(12) Bot_Acc(11) Bot_Acc(10) Bot_Acc(9) Bot_Acc(8) Bot_Acc(7) Bot_Acc(6) Bot_Acc(5) Bot_Acc(4) Bot_Acc(3) Bot_Acc(2)
<a name="l01871"></a>01871 Bot_End(16)
<a name="l01872"></a>01872 }
<a name="l01873"></a>01873
<a name="l01874"></a>01874 <span class="keywordtype">void</span> SSE2_MultiplyTop8(word *C, const word *A, const word *B, word L)
<a name="l01875"></a>01875 {
<a name="l01876"></a>01876 Top_Begin(4)
<a name="l01877"></a>01877 Top_Acc(3) Top_Acc(2) Top_Acc(1)
<a name="l01878"></a>01878 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01879"></a>01879 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01880"></a>01880 Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01881"></a>01881 AS1( ret) ASL(0)
<a name="l01882"></a>01882 <span class="preprocessor">#endif</span>
<a name="l01883"></a>01883 <span class="preprocessor"></span> Top_Column0(4)
<a name="l01884"></a>01884 Top_Column1(3)
<a name="l01885"></a>01885 Mul_Column0(0, 2)
<a name="l01886"></a>01886 Top_End(2)
<a name="l01887"></a>01887 }
<a name="l01888"></a>01888
<a name="l01889"></a>01889 <span class="keywordtype">void</span> SSE2_MultiplyTop16(word *C, const word *A, const word *B, word L)
<a name="l01890"></a>01890 {
<a name="l01891"></a>01891 Top_Begin(8)
<a name="l01892"></a>01892 Top_Acc(7) Top_Acc(6) Top_Acc(5) Top_Acc(4) Top_Acc(3) Top_Acc(2) Top_Acc(1)
<a name="l01893"></a>01893 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01894"></a>01894 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01895"></a>01895 Mul_Acc(8) Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01896"></a>01896 AS1( ret) ASL(0)
<a name="l01897"></a>01897 <span class="preprocessor">#endif</span>
<a name="l01898"></a>01898 <span class="preprocessor"></span> Top_Column0(8)
<a name="l01899"></a>01899 Top_Column1(7)
<a name="l01900"></a>01900 Mul_Column0(0, 6)
<a name="l01901"></a>01901 Mul_Column1(1, 5)
<a name="l01902"></a>01902 Mul_Column0(2, 4)
<a name="l01903"></a>01903 Mul_Column1(3, 3)
<a name="l01904"></a>01904 Mul_Column0(4, 2)
<a name="l01905"></a>01905 Top_End(4)
<a name="l01906"></a>01906 }
<a name="l01907"></a>01907
<a name="l01908"></a>01908 <span class="keywordtype">void</span> SSE2_MultiplyTop32(word *C, const word *A, const word *B, word L)
<a name="l01909"></a>01909 {
<a name="l01910"></a>01910 Top_Begin(16)
<a name="l01911"></a>01911 Top_Acc(15) Top_Acc(14) Top_Acc(13) Top_Acc(12) Top_Acc(11) Top_Acc(10) Top_Acc(9) Top_Acc(8) Top_Acc(7) Top_Acc(6) Top_Acc(5) Top_Acc(4) Top_Acc(3) Top_Acc(2) Top_Acc(1)
<a name="l01912"></a>01912 <span class="preprocessor">#ifndef __GNUC__</span>
<a name="l01913"></a>01913 <span class="preprocessor"></span> ASJ( jmp, 0, f)
<a name="l01914"></a>01914 Mul_Acc(16) Mul_Acc(15) Mul_Acc(14) Mul_Acc(13) Mul_Acc(12) Mul_Acc(11) Mul_Acc(10) Mul_Acc(9) Mul_Acc(8) Mul_Acc(7) Mul_Acc(6) Mul_Acc(5) Mul_Acc(4) Mul_Acc(3) Mul_Acc(2)
<a name="l01915"></a>01915 AS1( ret) ASL(0)
<a name="l01916"></a>01916 <span class="preprocessor">#endif</span>
<a name="l01917"></a>01917 <span class="preprocessor"></span> Top_Column0(16)
<a name="l01918"></a>01918 Top_Column1(15)
<a name="l01919"></a>01919 Mul_Column0(0, 14)
<a name="l01920"></a>01920 Mul_Column1(1, 13)
<a name="l01921"></a>01921 Mul_Column0(2, 12)
<a name="l01922"></a>01922 Mul_Column1(3, 11)
<a name="l01923"></a>01923 Mul_Column0(4, 10)
<a name="l01924"></a>01924 Mul_Column1(5, 9)
<a name="l01925"></a>01925 Mul_Column0(6, 8)
<a name="l01926"></a>01926 Mul_Column1(7, 7)
<a name="l01927"></a>01927 Mul_Column0(8, 6)
<a name="l01928"></a>01928 Mul_Column1(9, 5)
<a name="l01929"></a>01929 Mul_Column0(10, 4)
<a name="l01930"></a>01930 Mul_Column1(11, 3)
<a name="l01931"></a>01931 Mul_Column0(12, 2)
<a name="l01932"></a>01932 Top_End(8)
<a name="l01933"></a>01933 }
<a name="l01934"></a>01934
<a name="l01935"></a>01935 <span class="preprocessor">#endif // #if CRYPTOPP_INTEGER_SSE2</span>
<a name="l01936"></a>01936 <span class="preprocessor"></span>
<a name="l01937"></a>01937 <span class="comment">// ********************************************************</span>
<a name="l01938"></a>01938
<a name="l01939"></a>01939 <span class="keyword">typedef</span> int (CRYPTOPP_FASTCALL * PAdd)(<span class="keywordtype">size_t</span> N, word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B);
<a name="l01940"></a>01940 <span class="keyword">typedef</span> void (* PMul)(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B);
<a name="l01941"></a>01941 <span class="keyword">typedef</span> void (* PSqu)(word *C, <span class="keyword">const</span> word *A);
<a name="l01942"></a>01942 <span class="keyword">typedef</span> void (* PMulTop)(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, word L);
<a name="l01943"></a>01943
<a name="l01944"></a>01944 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l01945"></a>01945 <span class="preprocessor"></span><span class="keyword">static</span> PAdd s_pAdd = &Baseline_Add, s_pSub = &Baseline_Sub;
<a name="l01946"></a>01946 <span class="keyword">static</span> <span class="keywordtype">size_t</span> s_recursionLimit = 8;
<a name="l01947"></a>01947 <span class="preprocessor">#else</span>
<a name="l01948"></a>01948 <span class="preprocessor"></span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">size_t</span> s_recursionLimit = 16;
<a name="l01949"></a>01949 <span class="preprocessor">#endif</span>
<a name="l01950"></a>01950 <span class="preprocessor"></span>
<a name="l01951"></a>01951 <span class="keyword">static</span> PMul s_pMul[9], s_pBot[9];
<a name="l01952"></a>01952 <span class="keyword">static</span> PSqu s_pSqu[9];
<a name="l01953"></a>01953 <span class="keyword">static</span> PMulTop s_pTop[9];
<a name="l01954"></a>01954
<a name="l01955"></a>01955 <span class="keyword">static</span> <span class="keywordtype">void</span> SetFunctionPointers()
<a name="l01956"></a>01956 {
<a name="l01957"></a>01957 s_pMul[0] = &Baseline_Multiply2;
<a name="l01958"></a>01958 s_pBot[0] = &Baseline_MultiplyBottom2;
<a name="l01959"></a>01959 s_pSqu[0] = &Baseline_Square2;
<a name="l01960"></a>01960 s_pTop[0] = &Baseline_MultiplyTop2;
<a name="l01961"></a>01961 s_pTop[1] = &Baseline_MultiplyTop4;
<a name="l01962"></a>01962
<a name="l01963"></a>01963 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l01964"></a>01964 <span class="preprocessor"></span> <span class="keywordflow">if</span> (HasSSE2())
<a name="l01965"></a>01965 {
<a name="l01966"></a>01966 <span class="preprocessor">#if _MSC_VER != 1200 || defined(NDEBUG)</span>
<a name="l01967"></a>01967 <span class="preprocessor"></span> <span class="keywordflow">if</span> (IsP4())
<a name="l01968"></a>01968 {
<a name="l01969"></a>01969 s_pAdd = &SSE2_Add;
<a name="l01970"></a>01970 s_pSub = &SSE2_Sub;
<a name="l01971"></a>01971 }
<a name="l01972"></a>01972 <span class="preprocessor">#endif</span>
<a name="l01973"></a>01973 <span class="preprocessor"></span>
<a name="l01974"></a>01974 s_recursionLimit = 32;
<a name="l01975"></a>01975
<a name="l01976"></a>01976 s_pMul[1] = &SSE2_Multiply4;
<a name="l01977"></a>01977 s_pMul[2] = &SSE2_Multiply8;
<a name="l01978"></a>01978 s_pMul[4] = &SSE2_Multiply16;
<a name="l01979"></a>01979 s_pMul[8] = &SSE2_Multiply32;
<a name="l01980"></a>01980
<a name="l01981"></a>01981 s_pBot[1] = &SSE2_MultiplyBottom4;
<a name="l01982"></a>01982 s_pBot[2] = &SSE2_MultiplyBottom8;
<a name="l01983"></a>01983 s_pBot[4] = &SSE2_MultiplyBottom16;
<a name="l01984"></a>01984 s_pBot[8] = &SSE2_MultiplyBottom32;
<a name="l01985"></a>01985
<a name="l01986"></a>01986 s_pSqu[1] = &SSE2_Square4;
<a name="l01987"></a>01987 s_pSqu[2] = &SSE2_Square8;
<a name="l01988"></a>01988 s_pSqu[4] = &SSE2_Square16;
<a name="l01989"></a>01989 s_pSqu[8] = &SSE2_Square32;
<a name="l01990"></a>01990
<a name="l01991"></a>01991 s_pTop[2] = &SSE2_MultiplyTop8;
<a name="l01992"></a>01992 s_pTop[4] = &SSE2_MultiplyTop16;
<a name="l01993"></a>01993 s_pTop[8] = &SSE2_MultiplyTop32;
<a name="l01994"></a>01994 }
<a name="l01995"></a>01995 <span class="keywordflow">else</span>
<a name="l01996"></a>01996 <span class="preprocessor">#endif</span>
<a name="l01997"></a>01997 <span class="preprocessor"></span> {
<a name="l01998"></a>01998 s_pMul[1] = &Baseline_Multiply4;
<a name="l01999"></a>01999 s_pMul[2] = &Baseline_Multiply8;
<a name="l02000"></a>02000
<a name="l02001"></a>02001 s_pBot[1] = &Baseline_MultiplyBottom4;
<a name="l02002"></a>02002 s_pBot[2] = &Baseline_MultiplyBottom8;
<a name="l02003"></a>02003
<a name="l02004"></a>02004 s_pSqu[1] = &Baseline_Square4;
<a name="l02005"></a>02005 s_pSqu[2] = &Baseline_Square8;
<a name="l02006"></a>02006
<a name="l02007"></a>02007 s_pTop[2] = &Baseline_MultiplyTop8;
<a name="l02008"></a>02008
<a name="l02009"></a>02009 <span class="preprocessor">#if !CRYPTOPP_INTEGER_SSE2</span>
<a name="l02010"></a>02010 <span class="preprocessor"></span> s_pMul[4] = &Baseline_Multiply16;
<a name="l02011"></a>02011 s_pBot[4] = &Baseline_MultiplyBottom16;
<a name="l02012"></a>02012 s_pSqu[4] = &Baseline_Square16;
<a name="l02013"></a>02013 s_pTop[4] = &Baseline_MultiplyTop16;
<a name="l02014"></a>02014 <span class="preprocessor">#endif</span>
<a name="l02015"></a>02015 <span class="preprocessor"></span> }
<a name="l02016"></a>02016 }
<a name="l02017"></a>02017
<a name="l02018"></a>02018 <span class="keyword">inline</span> <span class="keywordtype">int</span> Add(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02019"></a>02019 {
<a name="l02020"></a>02020 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l02021"></a>02021 <span class="preprocessor"></span> <span class="keywordflow">return</span> s_pAdd(N, C, A, B);
<a name="l02022"></a>02022 <span class="preprocessor">#else</span>
<a name="l02023"></a>02023 <span class="preprocessor"></span> <span class="keywordflow">return</span> Baseline_Add(N, C, A, B);
<a name="l02024"></a>02024 <span class="preprocessor">#endif</span>
<a name="l02025"></a>02025 <span class="preprocessor"></span>}
<a name="l02026"></a>02026
<a name="l02027"></a>02027 <span class="keyword">inline</span> <span class="keywordtype">int</span> Subtract(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02028"></a>02028 {
<a name="l02029"></a>02029 <span class="preprocessor">#if CRYPTOPP_INTEGER_SSE2</span>
<a name="l02030"></a>02030 <span class="preprocessor"></span> <span class="keywordflow">return</span> s_pSub(N, C, A, B);
<a name="l02031"></a>02031 <span class="preprocessor">#else</span>
<a name="l02032"></a>02032 <span class="preprocessor"></span> <span class="keywordflow">return</span> Baseline_Sub(N, C, A, B);
<a name="l02033"></a>02033 <span class="preprocessor">#endif</span>
<a name="l02034"></a>02034 <span class="preprocessor"></span>}
<a name="l02035"></a>02035
<a name="l02036"></a>02036 <span class="comment">// ********************************************************</span>
<a name="l02037"></a>02037
<a name="l02038"></a>02038
<a name="l02039"></a>02039 <span class="preprocessor">#define A0 A</span>
<a name="l02040"></a>02040 <span class="preprocessor"></span><span class="preprocessor">#define A1 (A+N2)</span>
<a name="l02041"></a>02041 <span class="preprocessor"></span><span class="preprocessor">#define B0 B</span>
<a name="l02042"></a>02042 <span class="preprocessor"></span><span class="preprocessor">#define B1 (B+N2)</span>
<a name="l02043"></a>02043 <span class="preprocessor"></span>
<a name="l02044"></a>02044 <span class="preprocessor">#define T0 T</span>
<a name="l02045"></a>02045 <span class="preprocessor"></span><span class="preprocessor">#define T1 (T+N2)</span>
<a name="l02046"></a>02046 <span class="preprocessor"></span><span class="preprocessor">#define T2 (T+N)</span>
<a name="l02047"></a>02047 <span class="preprocessor"></span><span class="preprocessor">#define T3 (T+N+N2)</span>
<a name="l02048"></a>02048 <span class="preprocessor"></span>
<a name="l02049"></a>02049 <span class="preprocessor">#define R0 R</span>
<a name="l02050"></a>02050 <span class="preprocessor"></span><span class="preprocessor">#define R1 (R+N2)</span>
<a name="l02051"></a>02051 <span class="preprocessor"></span><span class="preprocessor">#define R2 (R+N)</span>
<a name="l02052"></a>02052 <span class="preprocessor"></span><span class="preprocessor">#define R3 (R+N+N2)</span>
<a name="l02053"></a>02053 <span class="preprocessor"></span>
<a name="l02054"></a>02054 <span class="comment">// R[2*N] - result = A*B</span>
<a name="l02055"></a>02055 <span class="comment">// T[2*N] - temporary work space</span>
<a name="l02056"></a>02056 <span class="comment">// A[N] --- multiplier</span>
<a name="l02057"></a>02057 <span class="comment">// B[N] --- multiplicant</span>
<a name="l02058"></a>02058
<a name="l02059"></a>02059 <span class="keywordtype">void</span> RecursiveMultiply(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02060"></a>02060 {
<a name="l02061"></a>02061 assert(N>=2 && N%2==0);
<a name="l02062"></a>02062
<a name="l02063"></a>02063 <span class="keywordflow">if</span> (N <= s_recursionLimit)
<a name="l02064"></a>02064 s_pMul[N/4](R, A, B);
<a name="l02065"></a>02065 <span class="keywordflow">else</span>
<a name="l02066"></a>02066 {
<a name="l02067"></a>02067 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02068"></a>02068
<a name="l02069"></a>02069 <span class="keywordtype">size_t</span> AN2 = Compare(A0, A1, N2) > 0 ? 0 : N2;
<a name="l02070"></a>02070 Subtract(R0, A + AN2, A + (N2 ^ AN2), N2);
<a name="l02071"></a>02071
<a name="l02072"></a>02072 <span class="keywordtype">size_t</span> BN2 = Compare(B0, B1, N2) > 0 ? 0 : N2;
<a name="l02073"></a>02073 Subtract(R1, B + BN2, B + (N2 ^ BN2), N2);
<a name="l02074"></a>02074
<a name="l02075"></a>02075 RecursiveMultiply(R2, T2, A1, B1, N2);
<a name="l02076"></a>02076 RecursiveMultiply(T0, T2, R0, R1, N2);
<a name="l02077"></a>02077 RecursiveMultiply(R0, T2, A0, B0, N2);
<a name="l02078"></a>02078
<a name="l02079"></a>02079 <span class="comment">// now T[01] holds (A1-A0)*(B0-B1), R[01] holds A0*B0, R[23] holds A1*B1</span>
<a name="l02080"></a>02080
<a name="l02081"></a>02081 <span class="keywordtype">int</span> c2 = Add(R2, R2, R1, N2);
<a name="l02082"></a>02082 <span class="keywordtype">int</span> c3 = c2;
<a name="l02083"></a>02083 c2 += Add(R1, R2, R0, N2);
<a name="l02084"></a>02084 c3 += Add(R2, R2, R3, N2);
<a name="l02085"></a>02085
<a name="l02086"></a>02086 <span class="keywordflow">if</span> (AN2 == BN2)
<a name="l02087"></a>02087 c3 -= Subtract(R1, R1, T0, N);
<a name="l02088"></a>02088 <span class="keywordflow">else</span>
<a name="l02089"></a>02089 c3 += Add(R1, R1, T0, N);
<a name="l02090"></a>02090
<a name="l02091"></a>02091 c3 += Increment(R2, N2, c2);
<a name="l02092"></a>02092 assert (c3 >= 0 && c3 <= 2);
<a name="l02093"></a>02093 Increment(R3, N2, c3);
<a name="l02094"></a>02094 }
<a name="l02095"></a>02095 }
<a name="l02096"></a>02096
<a name="l02097"></a>02097 <span class="comment">// R[2*N] - result = A*A</span>
<a name="l02098"></a>02098 <span class="comment">// T[2*N] - temporary work space</span>
<a name="l02099"></a>02099 <span class="comment">// A[N] --- number to be squared</span>
<a name="l02100"></a>02100
<a name="l02101"></a>02101 <span class="keywordtype">void</span> RecursiveSquare(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> N)
<a name="l02102"></a>02102 {
<a name="l02103"></a>02103 assert(N && N%2==0);
<a name="l02104"></a>02104
<a name="l02105"></a>02105 <span class="keywordflow">if</span> (N <= s_recursionLimit)
<a name="l02106"></a>02106 s_pSqu[N/4](R, A);
<a name="l02107"></a>02107 <span class="keywordflow">else</span>
<a name="l02108"></a>02108 {
<a name="l02109"></a>02109 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02110"></a>02110
<a name="l02111"></a>02111 RecursiveSquare(R0, T2, A0, N2);
<a name="l02112"></a>02112 RecursiveSquare(R2, T2, A1, N2);
<a name="l02113"></a>02113 RecursiveMultiply(T0, T2, A0, A1, N2);
<a name="l02114"></a>02114
<a name="l02115"></a>02115 <span class="keywordtype">int</span> carry = Add(R1, R1, T0, N);
<a name="l02116"></a>02116 carry += Add(R1, R1, T0, N);
<a name="l02117"></a>02117 Increment(R3, N2, carry);
<a name="l02118"></a>02118 }
<a name="l02119"></a>02119 }
<a name="l02120"></a>02120
<a name="l02121"></a>02121 <span class="comment">// R[N] - bottom half of A*B</span>
<a name="l02122"></a>02122 <span class="comment">// T[3*N/2] - temporary work space</span>
<a name="l02123"></a>02123 <span class="comment">// A[N] - multiplier</span>
<a name="l02124"></a>02124 <span class="comment">// B[N] - multiplicant</span>
<a name="l02125"></a>02125
<a name="l02126"></a>02126 <span class="keywordtype">void</span> RecursiveMultiplyBottom(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02127"></a>02127 {
<a name="l02128"></a>02128 assert(N>=2 && N%2==0);
<a name="l02129"></a>02129
<a name="l02130"></a>02130 <span class="keywordflow">if</span> (N <= s_recursionLimit)
<a name="l02131"></a>02131 s_pBot[N/4](R, A, B);
<a name="l02132"></a>02132 <span class="keywordflow">else</span>
<a name="l02133"></a>02133 {
<a name="l02134"></a>02134 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02135"></a>02135
<a name="l02136"></a>02136 RecursiveMultiply(R, T, A0, B0, N2);
<a name="l02137"></a>02137 RecursiveMultiplyBottom(T0, T1, A1, B0, N2);
<a name="l02138"></a>02138 Add(R1, R1, T0, N2);
<a name="l02139"></a>02139 RecursiveMultiplyBottom(T0, T1, A0, B1, N2);
<a name="l02140"></a>02140 Add(R1, R1, T0, N2);
<a name="l02141"></a>02141 }
<a name="l02142"></a>02142 }
<a name="l02143"></a>02143
<a name="l02144"></a>02144 <span class="comment">// R[N] --- upper half of A*B</span>
<a name="l02145"></a>02145 <span class="comment">// T[2*N] - temporary work space</span>
<a name="l02146"></a>02146 <span class="comment">// L[N] --- lower half of A*B</span>
<a name="l02147"></a>02147 <span class="comment">// A[N] --- multiplier</span>
<a name="l02148"></a>02148 <span class="comment">// B[N] --- multiplicant</span>
<a name="l02149"></a>02149
<a name="l02150"></a>02150 <span class="keywordtype">void</span> MultiplyTop(word *R, word *T, <span class="keyword">const</span> word *L, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02151"></a>02151 {
<a name="l02152"></a>02152 assert(N>=2 && N%2==0);
<a name="l02153"></a>02153
<a name="l02154"></a>02154 <span class="keywordflow">if</span> (N <= s_recursionLimit)
<a name="l02155"></a>02155 s_pTop[N/4](R, A, B, L[N-1]);
<a name="l02156"></a>02156 <span class="keywordflow">else</span>
<a name="l02157"></a>02157 {
<a name="l02158"></a>02158 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02159"></a>02159
<a name="l02160"></a>02160 <span class="keywordtype">size_t</span> AN2 = Compare(A0, A1, N2) > 0 ? 0 : N2;
<a name="l02161"></a>02161 Subtract(R0, A + AN2, A + (N2 ^ AN2), N2);
<a name="l02162"></a>02162
<a name="l02163"></a>02163 <span class="keywordtype">size_t</span> BN2 = Compare(B0, B1, N2) > 0 ? 0 : N2;
<a name="l02164"></a>02164 Subtract(R1, B + BN2, B + (N2 ^ BN2), N2);
<a name="l02165"></a>02165
<a name="l02166"></a>02166 RecursiveMultiply(T0, T2, R0, R1, N2);
<a name="l02167"></a>02167 RecursiveMultiply(R0, T2, A1, B1, N2);
<a name="l02168"></a>02168
<a name="l02169"></a>02169 <span class="comment">// now T[01] holds (A1-A0)*(B0-B1) = A1*B0+A0*B1-A1*B1-A0*B0, R[01] holds A1*B1</span>
<a name="l02170"></a>02170
<a name="l02171"></a>02171 <span class="keywordtype">int</span> t, c3;
<a name="l02172"></a>02172 <span class="keywordtype">int</span> c2 = Subtract(T2, L+N2, L, N2);
<a name="l02173"></a>02173
<a name="l02174"></a>02174 <span class="keywordflow">if</span> (AN2 == BN2)
<a name="l02175"></a>02175 {
<a name="l02176"></a>02176 c2 -= Add(T2, T2, T0, N2);
<a name="l02177"></a>02177 t = (Compare(T2, R0, N2) == -1);
<a name="l02178"></a>02178 c3 = t - Subtract(T2, T2, T1, N2);
<a name="l02179"></a>02179 }
<a name="l02180"></a>02180 <span class="keywordflow">else</span>
<a name="l02181"></a>02181 {
<a name="l02182"></a>02182 c2 += Subtract(T2, T2, T0, N2);
<a name="l02183"></a>02183 t = (Compare(T2, R0, N2) == -1);
<a name="l02184"></a>02184 c3 = t + Add(T2, T2, T1, N2);
<a name="l02185"></a>02185 }
<a name="l02186"></a>02186
<a name="l02187"></a>02187 c2 += t;
<a name="l02188"></a>02188 <span class="keywordflow">if</span> (c2 >= 0)
<a name="l02189"></a>02189 c3 += Increment(T2, N2, c2);
<a name="l02190"></a>02190 <span class="keywordflow">else</span>
<a name="l02191"></a>02191 c3 -= Decrement(T2, N2, -c2);
<a name="l02192"></a>02192 c3 += Add(R0, T2, R1, N2);
<a name="l02193"></a>02193
<a name="l02194"></a>02194 assert (c3 >= 0 && c3 <= 2);
<a name="l02195"></a>02195 Increment(R1, N2, c3);
<a name="l02196"></a>02196 }
<a name="l02197"></a>02197 }
<a name="l02198"></a>02198
<a name="l02199"></a>02199 <span class="keyword">inline</span> <span class="keywordtype">void</span> Multiply(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02200"></a>02200 {
<a name="l02201"></a>02201 RecursiveMultiply(R, T, A, B, N);
<a name="l02202"></a>02202 }
<a name="l02203"></a>02203
<a name="l02204"></a>02204 <span class="keyword">inline</span> <span class="keywordtype">void</span> <a class="code" href="class_square.html" title="Square">Square</a>(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> N)
<a name="l02205"></a>02205 {
<a name="l02206"></a>02206 RecursiveSquare(R, T, A, N);
<a name="l02207"></a>02207 }
<a name="l02208"></a>02208
<a name="l02209"></a>02209 <span class="keyword">inline</span> <span class="keywordtype">void</span> MultiplyBottom(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02210"></a>02210 {
<a name="l02211"></a>02211 RecursiveMultiplyBottom(R, T, A, B, N);
<a name="l02212"></a>02212 }
<a name="l02213"></a>02213
<a name="l02214"></a>02214 <span class="comment">// R[NA+NB] - result = A*B</span>
<a name="l02215"></a>02215 <span class="comment">// T[NA+NB] - temporary work space</span>
<a name="l02216"></a>02216 <span class="comment">// A[NA] ---- multiplier</span>
<a name="l02217"></a>02217 <span class="comment">// B[NB] ---- multiplicant</span>
<a name="l02218"></a>02218
<a name="l02219"></a>02219 <span class="keywordtype">void</span> AsymmetricMultiply(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> NA, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> NB)
<a name="l02220"></a>02220 {
<a name="l02221"></a>02221 <span class="keywordflow">if</span> (NA == NB)
<a name="l02222"></a>02222 {
<a name="l02223"></a>02223 <span class="keywordflow">if</span> (A == B)
<a name="l02224"></a>02224 <a class="code" href="class_square.html" title="Square">Square</a>(R, T, A, NA);
<a name="l02225"></a>02225 <span class="keywordflow">else</span>
<a name="l02226"></a>02226 Multiply(R, T, A, B, NA);
<a name="l02227"></a>02227
<a name="l02228"></a>02228 <span class="keywordflow">return</span>;
<a name="l02229"></a>02229 }
<a name="l02230"></a>02230
<a name="l02231"></a>02231 <span class="keywordflow">if</span> (NA > NB)
<a name="l02232"></a>02232 {
<a name="l02233"></a>02233 std::swap(A, B);
<a name="l02234"></a>02234 std::swap(NA, NB);
<a name="l02235"></a>02235 }
<a name="l02236"></a>02236
<a name="l02237"></a>02237 assert(NB % NA == 0);
<a name="l02238"></a>02238
<a name="l02239"></a>02239 <span class="keywordflow">if</span> (NA==2 && !A[1])
<a name="l02240"></a>02240 {
<a name="l02241"></a>02241 <span class="keywordflow">switch</span> (A[0])
<a name="l02242"></a>02242 {
<a name="l02243"></a>02243 <span class="keywordflow">case</span> 0:
<a name="l02244"></a>02244 SetWords(R, 0, NB+2);
<a name="l02245"></a>02245 <span class="keywordflow">return</span>;
<a name="l02246"></a>02246 <span class="keywordflow">case</span> 1:
<a name="l02247"></a>02247 CopyWords(R, B, NB);
<a name="l02248"></a>02248 R[NB] = R[NB+1] = 0;
<a name="l02249"></a>02249 <span class="keywordflow">return</span>;
<a name="l02250"></a>02250 <span class="keywordflow">default</span>:
<a name="l02251"></a>02251 R[NB] = LinearMultiply(R, B, A[0], NB);
<a name="l02252"></a>02252 R[NB+1] = 0;
<a name="l02253"></a>02253 <span class="keywordflow">return</span>;
<a name="l02254"></a>02254 }
<a name="l02255"></a>02255 }
<a name="l02256"></a>02256
<a name="l02257"></a>02257 <span class="keywordtype">size_t</span> i;
<a name="l02258"></a>02258 <span class="keywordflow">if</span> ((NB/NA)%2 == 0)
<a name="l02259"></a>02259 {
<a name="l02260"></a>02260 Multiply(R, T, A, B, NA);
<a name="l02261"></a>02261 CopyWords(T+2*NA, R+NA, NA);
<a name="l02262"></a>02262
<a name="l02263"></a>02263 <span class="keywordflow">for</span> (i=2*NA; i<NB; i+=2*NA)
<a name="l02264"></a>02264 Multiply(T+NA+i, T, A, B+i, NA);
<a name="l02265"></a>02265 <span class="keywordflow">for</span> (i=NA; i<NB; i+=2*NA)
<a name="l02266"></a>02266 Multiply(R+i, T, A, B+i, NA);
<a name="l02267"></a>02267 }
<a name="l02268"></a>02268 <span class="keywordflow">else</span>
<a name="l02269"></a>02269 {
<a name="l02270"></a>02270 <span class="keywordflow">for</span> (i=0; i<NB; i+=2*NA)
<a name="l02271"></a>02271 Multiply(R+i, T, A, B+i, NA);
<a name="l02272"></a>02272 <span class="keywordflow">for</span> (i=NA; i<NB; i+=2*NA)
<a name="l02273"></a>02273 Multiply(T+NA+i, T, A, B+i, NA);
<a name="l02274"></a>02274 }
<a name="l02275"></a>02275
<a name="l02276"></a>02276 <span class="keywordflow">if</span> (Add(R+NA, R+NA, T+2*NA, NB-NA))
<a name="l02277"></a>02277 Increment(R+NB, NA);
<a name="l02278"></a>02278 }
<a name="l02279"></a>02279
<a name="l02280"></a>02280 <span class="comment">// R[N] ----- result = A inverse mod 2**(WORD_BITS*N)</span>
<a name="l02281"></a>02281 <span class="comment">// T[3*N/2] - temporary work space</span>
<a name="l02282"></a>02282 <span class="comment">// A[N] ----- an odd number as input</span>
<a name="l02283"></a>02283
<a name="l02284"></a>02284 <span class="keywordtype">void</span> RecursiveInverseModPower2(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> N)
<a name="l02285"></a>02285 {
<a name="l02286"></a>02286 <span class="keywordflow">if</span> (N==2)
<a name="l02287"></a>02287 {
<a name="l02288"></a>02288 T[0] = AtomicInverseModPower2(A[0]);
<a name="l02289"></a>02289 T[1] = 0;
<a name="l02290"></a>02290 s_pBot[0](T+2, T, A);
<a name="l02291"></a>02291 TwosComplement(T+2, 2);
<a name="l02292"></a>02292 Increment(T+2, 2, 2);
<a name="l02293"></a>02293 s_pBot[0](R, T, T+2);
<a name="l02294"></a>02294 }
<a name="l02295"></a>02295 <span class="keywordflow">else</span>
<a name="l02296"></a>02296 {
<a name="l02297"></a>02297 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02298"></a>02298 RecursiveInverseModPower2(R0, T0, A0, N2);
<a name="l02299"></a>02299 T0[0] = 1;
<a name="l02300"></a>02300 SetWords(T0+1, 0, N2-1);
<a name="l02301"></a>02301 MultiplyTop(R1, T1, T0, R0, A0, N2);
<a name="l02302"></a>02302 MultiplyBottom(T0, T1, R0, A1, N2);
<a name="l02303"></a>02303 Add(T0, R1, T0, N2);
<a name="l02304"></a>02304 TwosComplement(T0, N2);
<a name="l02305"></a>02305 MultiplyBottom(R1, T1, R0, T0, N2);
<a name="l02306"></a>02306 }
<a name="l02307"></a>02307 }
<a name="l02308"></a>02308
<a name="l02309"></a>02309 <span class="comment">// R[N] --- result = X/(2**(WORD_BITS*N)) mod M</span>
<a name="l02310"></a>02310 <span class="comment">// T[3*N] - temporary work space</span>
<a name="l02311"></a>02311 <span class="comment">// X[2*N] - number to be reduced</span>
<a name="l02312"></a>02312 <span class="comment">// M[N] --- modulus</span>
<a name="l02313"></a>02313 <span class="comment">// U[N] --- multiplicative inverse of M mod 2**(WORD_BITS*N)</span>
<a name="l02314"></a>02314
<a name="l02315"></a>02315 <span class="keywordtype">void</span> MontgomeryReduce(word *R, word *T, word *X, <span class="keyword">const</span> word *M, <span class="keyword">const</span> word *U, <span class="keywordtype">size_t</span> N)
<a name="l02316"></a>02316 {
<a name="l02317"></a>02317 <span class="preprocessor">#if 1</span>
<a name="l02318"></a>02318 <span class="preprocessor"></span> MultiplyBottom(R, T, X, U, N);
<a name="l02319"></a>02319 MultiplyTop(T, T+N, X, R, M, N);
<a name="l02320"></a>02320 word borrow = Subtract(T, X+N, T, N);
<a name="l02321"></a>02321 <span class="comment">// defend against timing attack by doing this Add even when not needed</span>
<a name="l02322"></a>02322 word carry = Add(T+N, T, M, N);
<a name="l02323"></a>02323 assert(carry | !borrow);
<a name="l02324"></a>02324 CopyWords(R, T + ((0-borrow) & N), N);
<a name="l02325"></a>02325 <span class="preprocessor">#elif 0</span>
<a name="l02326"></a>02326 <span class="preprocessor"></span> <span class="keyword">const</span> word u = 0-U[0];
<a name="l02327"></a>02327 Declare2Words(p)
<a name="l02328"></a>02328 for (<span class="keywordtype">size_t</span> i=0; i<N; i++)
<a name="l02329"></a>02329 {
<a name="l02330"></a>02330 <span class="keyword">const</span> word t = u * X[i];
<a name="l02331"></a>02331 word c = 0;
<a name="l02332"></a>02332 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> j=0; j<N; j+=2)
<a name="l02333"></a>02333 {
<a name="l02334"></a>02334 MultiplyWords(p, t, M[j]);
<a name="l02335"></a>02335 Acc2WordsBy1(p, X[i+j]);
<a name="l02336"></a>02336 Acc2WordsBy1(p, c);
<a name="l02337"></a>02337 X[i+j] = LowWord(p);
<a name="l02338"></a>02338 c = HighWord(p);
<a name="l02339"></a>02339 MultiplyWords(p, t, M[j+1]);
<a name="l02340"></a>02340 Acc2WordsBy1(p, X[i+j+1]);
<a name="l02341"></a>02341 Acc2WordsBy1(p, c);
<a name="l02342"></a>02342 X[i+j+1] = LowWord(p);
<a name="l02343"></a>02343 c = HighWord(p);
<a name="l02344"></a>02344 }
<a name="l02345"></a>02345
<a name="l02346"></a>02346 <span class="keywordflow">if</span> (Increment(X+N+i, N-i, c))
<a name="l02347"></a>02347 <span class="keywordflow">while</span> (!Subtract(X+N, X+N, M, N)) {}
<a name="l02348"></a>02348 }
<a name="l02349"></a>02349
<a name="l02350"></a>02350 memcpy(R, X+N, N*WORD_SIZE);
<a name="l02351"></a>02351 <span class="preprocessor">#else</span>
<a name="l02352"></a>02352 <span class="preprocessor"></span> __m64 u = _mm_cvtsi32_si64(0-U[0]), p;
<a name="l02353"></a>02353 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=0; i<N; i++)
<a name="l02354"></a>02354 {
<a name="l02355"></a>02355 __m64 t = _mm_cvtsi32_si64(X[i]);
<a name="l02356"></a>02356 t = _mm_mul_su32(t, u);
<a name="l02357"></a>02357 __m64 c = _mm_setzero_si64();
<a name="l02358"></a>02358 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> j=0; j<N; j+=2)
<a name="l02359"></a>02359 {
<a name="l02360"></a>02360 p = _mm_mul_su32(t, _mm_cvtsi32_si64(M[j]));
<a name="l02361"></a>02361 p = _mm_add_si64(p, _mm_cvtsi32_si64(X[i+j]));
<a name="l02362"></a>02362 c = _mm_add_si64(c, p);
<a name="l02363"></a>02363 X[i+j] = _mm_cvtsi64_si32(c);
<a name="l02364"></a>02364 c = _mm_srli_si64(c, 32);
<a name="l02365"></a>02365 p = _mm_mul_su32(t, _mm_cvtsi32_si64(M[j+1]));
<a name="l02366"></a>02366 p = _mm_add_si64(p, _mm_cvtsi32_si64(X[i+j+1]));
<a name="l02367"></a>02367 c = _mm_add_si64(c, p);
<a name="l02368"></a>02368 X[i+j+1] = _mm_cvtsi64_si32(c);
<a name="l02369"></a>02369 c = _mm_srli_si64(c, 32);
<a name="l02370"></a>02370 }
<a name="l02371"></a>02371
<a name="l02372"></a>02372 <span class="keywordflow">if</span> (Increment(X+N+i, N-i, _mm_cvtsi64_si32(c)))
<a name="l02373"></a>02373 <span class="keywordflow">while</span> (!Subtract(X+N, X+N, M, N)) {}
<a name="l02374"></a>02374 }
<a name="l02375"></a>02375
<a name="l02376"></a>02376 memcpy(R, X+N, N*WORD_SIZE);
<a name="l02377"></a>02377 _mm_empty();
<a name="l02378"></a>02378 <span class="preprocessor">#endif</span>
<a name="l02379"></a>02379 <span class="preprocessor"></span>}
<a name="l02380"></a>02380
<a name="l02381"></a>02381 <span class="comment">// R[N] --- result = X/(2**(WORD_BITS*N/2)) mod M</span>
<a name="l02382"></a>02382 <span class="comment">// T[2*N] - temporary work space</span>
<a name="l02383"></a>02383 <span class="comment">// X[2*N] - number to be reduced</span>
<a name="l02384"></a>02384 <span class="comment">// M[N] --- modulus</span>
<a name="l02385"></a>02385 <span class="comment">// U[N/2] - multiplicative inverse of M mod 2**(WORD_BITS*N/2)</span>
<a name="l02386"></a>02386 <span class="comment">// V[N] --- 2**(WORD_BITS*3*N/2) mod M</span>
<a name="l02387"></a>02387
<a name="l02388"></a>02388 <span class="keywordtype">void</span> HalfMontgomeryReduce(word *R, word *T, <span class="keyword">const</span> word *X, <span class="keyword">const</span> word *M, <span class="keyword">const</span> word *U, <span class="keyword">const</span> word *V, <span class="keywordtype">size_t</span> N)
<a name="l02389"></a>02389 {
<a name="l02390"></a>02390 assert(N%2==0 && N>=4);
<a name="l02391"></a>02391
<a name="l02392"></a>02392 <span class="preprocessor">#define M0 M</span>
<a name="l02393"></a>02393 <span class="preprocessor"></span><span class="preprocessor">#define M1 (M+N2)</span>
<a name="l02394"></a>02394 <span class="preprocessor"></span><span class="preprocessor">#define V0 V</span>
<a name="l02395"></a>02395 <span class="preprocessor"></span><span class="preprocessor">#define V1 (V+N2)</span>
<a name="l02396"></a>02396 <span class="preprocessor"></span>
<a name="l02397"></a>02397 <span class="preprocessor">#define X0 X</span>
<a name="l02398"></a>02398 <span class="preprocessor"></span><span class="preprocessor">#define X1 (X+N2)</span>
<a name="l02399"></a>02399 <span class="preprocessor"></span><span class="preprocessor">#define X2 (X+N)</span>
<a name="l02400"></a>02400 <span class="preprocessor"></span><span class="preprocessor">#define X3 (X+N+N2)</span>
<a name="l02401"></a>02401 <span class="preprocessor"></span>
<a name="l02402"></a>02402 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N2 = N/2;
<a name="l02403"></a>02403 Multiply(T0, T2, V0, X3, N2);
<a name="l02404"></a>02404 <span class="keywordtype">int</span> c2 = Add(T0, T0, X0, N);
<a name="l02405"></a>02405 MultiplyBottom(T3, T2, T0, U, N2);
<a name="l02406"></a>02406 MultiplyTop(T2, R, T0, T3, M0, N2);
<a name="l02407"></a>02407 c2 -= Subtract(T2, T1, T2, N2);
<a name="l02408"></a>02408 Multiply(T0, R, T3, M1, N2);
<a name="l02409"></a>02409 c2 -= Subtract(T0, T2, T0, N2);
<a name="l02410"></a>02410 <span class="keywordtype">int</span> c3 = -(int)Subtract(T1, X2, T1, N2);
<a name="l02411"></a>02411 Multiply(R0, T2, V1, X3, N2);
<a name="l02412"></a>02412 c3 += Add(R, R, T, N);
<a name="l02413"></a>02413
<a name="l02414"></a>02414 <span class="keywordflow">if</span> (c2>0)
<a name="l02415"></a>02415 c3 += Increment(R1, N2);
<a name="l02416"></a>02416 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (c2<0)
<a name="l02417"></a>02417 c3 -= Decrement(R1, N2, -c2);
<a name="l02418"></a>02418
<a name="l02419"></a>02419 assert(c3>=-1 && c3<=1);
<a name="l02420"></a>02420 <span class="keywordflow">if</span> (c3>0)
<a name="l02421"></a>02421 Subtract(R, R, M, N);
<a name="l02422"></a>02422 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (c3<0)
<a name="l02423"></a>02423 Add(R, R, M, N);
<a name="l02424"></a>02424
<a name="l02425"></a>02425 <span class="preprocessor">#undef M0</span>
<a name="l02426"></a>02426 <span class="preprocessor"></span><span class="preprocessor">#undef M1</span>
<a name="l02427"></a>02427 <span class="preprocessor"></span><span class="preprocessor">#undef V0</span>
<a name="l02428"></a>02428 <span class="preprocessor"></span><span class="preprocessor">#undef V1</span>
<a name="l02429"></a>02429 <span class="preprocessor"></span>
<a name="l02430"></a>02430 <span class="preprocessor">#undef X0</span>
<a name="l02431"></a>02431 <span class="preprocessor"></span><span class="preprocessor">#undef X1</span>
<a name="l02432"></a>02432 <span class="preprocessor"></span><span class="preprocessor">#undef X2</span>
<a name="l02433"></a>02433 <span class="preprocessor"></span><span class="preprocessor">#undef X3</span>
<a name="l02434"></a>02434 <span class="preprocessor"></span>}
<a name="l02435"></a>02435
<a name="l02436"></a>02436 <span class="preprocessor">#undef A0</span>
<a name="l02437"></a>02437 <span class="preprocessor"></span><span class="preprocessor">#undef A1</span>
<a name="l02438"></a>02438 <span class="preprocessor"></span><span class="preprocessor">#undef B0</span>
<a name="l02439"></a>02439 <span class="preprocessor"></span><span class="preprocessor">#undef B1</span>
<a name="l02440"></a>02440 <span class="preprocessor"></span>
<a name="l02441"></a>02441 <span class="preprocessor">#undef T0</span>
<a name="l02442"></a>02442 <span class="preprocessor"></span><span class="preprocessor">#undef T1</span>
<a name="l02443"></a>02443 <span class="preprocessor"></span><span class="preprocessor">#undef T2</span>
<a name="l02444"></a>02444 <span class="preprocessor"></span><span class="preprocessor">#undef T3</span>
<a name="l02445"></a>02445 <span class="preprocessor"></span>
<a name="l02446"></a>02446 <span class="preprocessor">#undef R0</span>
<a name="l02447"></a>02447 <span class="preprocessor"></span><span class="preprocessor">#undef R1</span>
<a name="l02448"></a>02448 <span class="preprocessor"></span><span class="preprocessor">#undef R2</span>
<a name="l02449"></a>02449 <span class="preprocessor"></span><span class="preprocessor">#undef R3</span>
<a name="l02450"></a>02450 <span class="preprocessor"></span>
<a name="l02451"></a>02451 <span class="comment">/*</span>
<a name="l02452"></a>02452 <span class="comment">// do a 3 word by 2 word divide, returns quotient and leaves remainder in A</span>
<a name="l02453"></a>02453 <span class="comment">static word SubatomicDivide(word *A, word B0, word B1)</span>
<a name="l02454"></a>02454 <span class="comment">{</span>
<a name="l02455"></a>02455 <span class="comment"> // assert {A[2],A[1]} < {B1,B0}, so quotient can fit in a word</span>
<a name="l02456"></a>02456 <span class="comment"> assert(A[2] < B1 || (A[2]==B1 && A[1] < B0));</span>
<a name="l02457"></a>02457 <span class="comment"></span>
<a name="l02458"></a>02458 <span class="comment"> // estimate the quotient: do a 2 word by 1 word divide</span>
<a name="l02459"></a>02459 <span class="comment"> word Q;</span>
<a name="l02460"></a>02460 <span class="comment"> if (B1+1 == 0)</span>
<a name="l02461"></a>02461 <span class="comment"> Q = A[2];</span>
<a name="l02462"></a>02462 <span class="comment"> else</span>
<a name="l02463"></a>02463 <span class="comment"> Q = DWord(A[1], A[2]).DividedBy(B1+1);</span>
<a name="l02464"></a>02464 <span class="comment"></span>
<a name="l02465"></a>02465 <span class="comment"> // now subtract Q*B from A</span>
<a name="l02466"></a>02466 <span class="comment"> DWord p = DWord::Multiply(B0, Q);</span>
<a name="l02467"></a>02467 <span class="comment"> DWord u = (DWord) A[0] - p.GetLowHalf();</span>
<a name="l02468"></a>02468 <span class="comment"> A[0] = u.GetLowHalf();</span>
<a name="l02469"></a>02469 <span class="comment"> u = (DWord) A[1] - p.GetHighHalf() - u.GetHighHalfAsBorrow() - DWord::Multiply(B1, Q);</span>
<a name="l02470"></a>02470 <span class="comment"> A[1] = u.GetLowHalf();</span>
<a name="l02471"></a>02471 <span class="comment"> A[2] += u.GetHighHalf();</span>
<a name="l02472"></a>02472 <span class="comment"></span>
<a name="l02473"></a>02473 <span class="comment"> // Q <= actual quotient, so fix it</span>
<a name="l02474"></a>02474 <span class="comment"> while (A[2] || A[1] > B1 || (A[1]==B1 && A[0]>=B0))</span>
<a name="l02475"></a>02475 <span class="comment"> {</span>
<a name="l02476"></a>02476 <span class="comment"> u = (DWord) A[0] - B0;</span>
<a name="l02477"></a>02477 <span class="comment"> A[0] = u.GetLowHalf();</span>
<a name="l02478"></a>02478 <span class="comment"> u = (DWord) A[1] - B1 - u.GetHighHalfAsBorrow();</span>
<a name="l02479"></a>02479 <span class="comment"> A[1] = u.GetLowHalf();</span>
<a name="l02480"></a>02480 <span class="comment"> A[2] += u.GetHighHalf();</span>
<a name="l02481"></a>02481 <span class="comment"> Q++;</span>
<a name="l02482"></a>02482 <span class="comment"> assert(Q); // shouldn't overflow</span>
<a name="l02483"></a>02483 <span class="comment"> }</span>
<a name="l02484"></a>02484 <span class="comment"></span>
<a name="l02485"></a>02485 <span class="comment"> return Q;</span>
<a name="l02486"></a>02486 <span class="comment">}</span>
<a name="l02487"></a>02487 <span class="comment"></span>
<a name="l02488"></a>02488 <span class="comment">// do a 4 word by 2 word divide, returns 2 word quotient in Q0 and Q1</span>
<a name="l02489"></a>02489 <span class="comment">static inline void AtomicDivide(word *Q, const word *A, const word *B)</span>
<a name="l02490"></a>02490 <span class="comment">{</span>
<a name="l02491"></a>02491 <span class="comment"> if (!B[0] && !B[1]) // if divisor is 0, we assume divisor==2**(2*WORD_BITS)</span>
<a name="l02492"></a>02492 <span class="comment"> {</span>
<a name="l02493"></a>02493 <span class="comment"> Q[0] = A[2];</span>
<a name="l02494"></a>02494 <span class="comment"> Q[1] = A[3];</span>
<a name="l02495"></a>02495 <span class="comment"> }</span>
<a name="l02496"></a>02496 <span class="comment"> else</span>
<a name="l02497"></a>02497 <span class="comment"> {</span>
<a name="l02498"></a>02498 <span class="comment"> word T[4];</span>
<a name="l02499"></a>02499 <span class="comment"> T[0] = A[0]; T[1] = A[1]; T[2] = A[2]; T[3] = A[3];</span>
<a name="l02500"></a>02500 <span class="comment"> Q[1] = SubatomicDivide(T+1, B[0], B[1]);</span>
<a name="l02501"></a>02501 <span class="comment"> Q[0] = SubatomicDivide(T, B[0], B[1]);</span>
<a name="l02502"></a>02502 <span class="comment"></span>
<a name="l02503"></a>02503 <span class="comment">#ifndef NDEBUG</span>
<a name="l02504"></a>02504 <span class="comment"> // multiply quotient and divisor and add remainder, make sure it equals dividend</span>
<a name="l02505"></a>02505 <span class="comment"> assert(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));</span>
<a name="l02506"></a>02506 <span class="comment"> word P[4];</span>
<a name="l02507"></a>02507 <span class="comment"> LowLevel::Multiply2(P, Q, B);</span>
<a name="l02508"></a>02508 <span class="comment"> Add(P, P, T, 4);</span>
<a name="l02509"></a>02509 <span class="comment"> assert(memcmp(P, A, 4*WORD_SIZE)==0);</span>
<a name="l02510"></a>02510 <span class="comment">#endif</span>
<a name="l02511"></a>02511 <span class="comment"> }</span>
<a name="l02512"></a>02512 <span class="comment">}</span>
<a name="l02513"></a>02513 <span class="comment">*/</span>
<a name="l02514"></a>02514
<a name="l02515"></a>02515 <span class="keyword">static</span> <span class="keyword">inline</span> <span class="keywordtype">void</span> AtomicDivide(word *Q, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
<a name="l02516"></a>02516 {
<a name="l02517"></a>02517 word T[4];
<a name="l02518"></a>02518 <a class="code" href="class_d_word.html">DWord</a> q = DivideFourWordsByTwo<word, DWord>(T, <a class="code" href="class_d_word.html">DWord</a>(A[0], A[1]), <a class="code" href="class_d_word.html">DWord</a>(A[2], A[3]), <a class="code" href="class_d_word.html">DWord</a>(B[0], B[1]));
<a name="l02519"></a>02519 Q[0] = q.GetLowHalf();
<a name="l02520"></a>02520 Q[1] = q.GetHighHalf();
<a name="l02521"></a>02521
<a name="l02522"></a>02522 <span class="preprocessor">#ifndef NDEBUG</span>
<a name="l02523"></a>02523 <span class="preprocessor"></span> <span class="keywordflow">if</span> (B[0] || B[1])
<a name="l02524"></a>02524 {
<a name="l02525"></a>02525 <span class="comment">// multiply quotient and divisor and add remainder, make sure it equals dividend</span>
<a name="l02526"></a>02526 assert(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));
<a name="l02527"></a>02527 word P[4];
<a name="l02528"></a>02528 s_pMul[0](P, Q, B);
<a name="l02529"></a>02529 Add(P, P, T, 4);
<a name="l02530"></a>02530 assert(memcmp(P, A, 4*WORD_SIZE)==0);
<a name="l02531"></a>02531 }
<a name="l02532"></a>02532 <span class="preprocessor">#endif</span>
<a name="l02533"></a>02533 <span class="preprocessor"></span>}
<a name="l02534"></a>02534
<a name="l02535"></a>02535 <span class="comment">// for use by Divide(), corrects the underestimated quotient {Q1,Q0}</span>
<a name="l02536"></a>02536 <span class="keyword">static</span> <span class="keywordtype">void</span> CorrectQuotientEstimate(word *R, word *T, word *Q, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> N)
<a name="l02537"></a>02537 {
<a name="l02538"></a>02538 assert(N && N%2==0);
<a name="l02539"></a>02539
<a name="l02540"></a>02540 AsymmetricMultiply(T, T+N+2, Q, 2, B, N);
<a name="l02541"></a>02541
<a name="l02542"></a>02542 word borrow = Subtract(R, R, T, N+2);
<a name="l02543"></a>02543 assert(!borrow && !R[N+1]);
<a name="l02544"></a>02544
<a name="l02545"></a>02545 <span class="keywordflow">while</span> (R[N] || Compare(R, B, N) >= 0)
<a name="l02546"></a>02546 {
<a name="l02547"></a>02547 R[N] -= Subtract(R, R, B, N);
<a name="l02548"></a>02548 Q[1] += (++Q[0]==0);
<a name="l02549"></a>02549 assert(Q[0] || Q[1]); <span class="comment">// no overflow</span>
<a name="l02550"></a>02550 }
<a name="l02551"></a>02551 }
<a name="l02552"></a>02552
<a name="l02553"></a>02553 <span class="comment">// R[NB] -------- remainder = A%B</span>
<a name="l02554"></a>02554 <span class="comment">// Q[NA-NB+2] --- quotient = A/B</span>
<a name="l02555"></a>02555 <span class="comment">// T[NA+3*(NB+2)] - temp work space</span>
<a name="l02556"></a>02556 <span class="comment">// A[NA] -------- dividend</span>
<a name="l02557"></a>02557 <span class="comment">// B[NB] -------- divisor</span>
<a name="l02558"></a>02558
<a name="l02559"></a>02559 <span class="keywordtype">void</span> Divide(word *R, word *Q, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> NA, <span class="keyword">const</span> word *B, <span class="keywordtype">size_t</span> NB)
<a name="l02560"></a>02560 {
<a name="l02561"></a>02561 assert(NA && NB && NA%2==0 && NB%2==0);
<a name="l02562"></a>02562 assert(B[NB-1] || B[NB-2]);
<a name="l02563"></a>02563 assert(NB <= NA);
<a name="l02564"></a>02564
<a name="l02565"></a>02565 <span class="comment">// set up temporary work space</span>
<a name="l02566"></a>02566 word *<span class="keyword">const</span> TA=T;
<a name="l02567"></a>02567 word *<span class="keyword">const</span> TB=T+NA+2;
<a name="l02568"></a>02568 word *<span class="keyword">const</span> TP=T+NA+2+NB;
<a name="l02569"></a>02569
<a name="l02570"></a>02570 <span class="comment">// copy B into TB and normalize it so that TB has highest bit set to 1</span>
<a name="l02571"></a>02571 <span class="keywordtype">unsigned</span> shiftWords = (B[NB-1]==0);
<a name="l02572"></a>02572 TB[0] = TB[NB-1] = 0;
<a name="l02573"></a>02573 CopyWords(TB+shiftWords, B, NB-shiftWords);
<a name="l02574"></a>02574 <span class="keywordtype">unsigned</span> shiftBits = WORD_BITS - BitPrecision(TB[NB-1]);
<a name="l02575"></a>02575 assert(shiftBits < WORD_BITS);
<a name="l02576"></a>02576 ShiftWordsLeftByBits(TB, NB, shiftBits);
<a name="l02577"></a>02577
<a name="l02578"></a>02578 <span class="comment">// copy A into TA and normalize it</span>
<a name="l02579"></a>02579 TA[0] = TA[NA] = TA[NA+1] = 0;
<a name="l02580"></a>02580 CopyWords(TA+shiftWords, A, NA);
<a name="l02581"></a>02581 ShiftWordsLeftByBits(TA, NA+2, shiftBits);
<a name="l02582"></a>02582
<a name="l02583"></a>02583 <span class="keywordflow">if</span> (TA[NA+1]==0 && TA[NA] <= 1)
<a name="l02584"></a>02584 {
<a name="l02585"></a>02585 Q[NA-NB+1] = Q[NA-NB] = 0;
<a name="l02586"></a>02586 <span class="keywordflow">while</span> (TA[NA] || Compare(TA+NA-NB, TB, NB) >= 0)
<a name="l02587"></a>02587 {
<a name="l02588"></a>02588 TA[NA] -= Subtract(TA+NA-NB, TA+NA-NB, TB, NB);
<a name="l02589"></a>02589 ++Q[NA-NB];
<a name="l02590"></a>02590 }
<a name="l02591"></a>02591 }
<a name="l02592"></a>02592 <span class="keywordflow">else</span>
<a name="l02593"></a>02593 {
<a name="l02594"></a>02594 NA+=2;
<a name="l02595"></a>02595 assert(Compare(TA+NA-NB, TB, NB) < 0);
<a name="l02596"></a>02596 }
<a name="l02597"></a>02597
<a name="l02598"></a>02598 word BT[2];
<a name="l02599"></a>02599 BT[0] = TB[NB-2] + 1;
<a name="l02600"></a>02600 BT[1] = TB[NB-1] + (BT[0]==0);
<a name="l02601"></a>02601
<a name="l02602"></a>02602 <span class="comment">// start reducing TA mod TB, 2 words at a time</span>
<a name="l02603"></a>02603 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=NA-2; i>=NB; i-=2)
<a name="l02604"></a>02604 {
<a name="l02605"></a>02605 AtomicDivide(Q+i-NB, TA+i-2, BT);
<a name="l02606"></a>02606 CorrectQuotientEstimate(TA+i-NB, TP, Q+i-NB, TB, NB);
<a name="l02607"></a>02607 }
<a name="l02608"></a>02608
<a name="l02609"></a>02609 <span class="comment">// copy TA into R, and denormalize it</span>
<a name="l02610"></a>02610 CopyWords(R, TA+shiftWords, NB);
<a name="l02611"></a>02611 ShiftWordsRightByBits(R, NB, shiftBits);
<a name="l02612"></a>02612 }
<a name="l02613"></a>02613
<a name="l02614"></a>02614 <span class="keyword">static</span> <span class="keyword">inline</span> <span class="keywordtype">size_t</span> EvenWordCount(<span class="keyword">const</span> word *X, <span class="keywordtype">size_t</span> N)
<a name="l02615"></a>02615 {
<a name="l02616"></a>02616 <span class="keywordflow">while</span> (N && X[N-2]==0 && X[N-1]==0)
<a name="l02617"></a>02617 N-=2;
<a name="l02618"></a>02618 <span class="keywordflow">return</span> N;
<a name="l02619"></a>02619 }
<a name="l02620"></a>02620
<a name="l02621"></a>02621 <span class="comment">// return k</span>
<a name="l02622"></a>02622 <span class="comment">// R[N] --- result = A^(-1) * 2^k mod M</span>
<a name="l02623"></a>02623 <span class="comment">// T[4*N] - temporary work space</span>
<a name="l02624"></a>02624 <span class="comment">// A[NA] -- number to take inverse of</span>
<a name="l02625"></a>02625 <span class="comment">// M[N] --- modulus</span>
<a name="l02626"></a>02626
<a name="l02627"></a>02627 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> AlmostInverse(word *R, word *T, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> NA, <span class="keyword">const</span> word *M, <span class="keywordtype">size_t</span> N)
<a name="l02628"></a>02628 {
<a name="l02629"></a>02629 assert(NA<=N && N && N%2==0);
<a name="l02630"></a>02630
<a name="l02631"></a>02631 word *b = T;
<a name="l02632"></a>02632 word *c = T+N;
<a name="l02633"></a>02633 word *f = T+2*N;
<a name="l02634"></a>02634 word *g = T+3*N;
<a name="l02635"></a>02635 <span class="keywordtype">size_t</span> bcLen=2, fgLen=EvenWordCount(M, N);
<a name="l02636"></a>02636 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> k=0;
<a name="l02637"></a>02637 <span class="keywordtype">bool</span> s=<span class="keyword">false</span>;
<a name="l02638"></a>02638
<a name="l02639"></a>02639 SetWords(T, 0, 3*N);
<a name="l02640"></a>02640 b[0]=1;
<a name="l02641"></a>02641 CopyWords(f, A, NA);
<a name="l02642"></a>02642 CopyWords(g, M, N);
<a name="l02643"></a>02643
<a name="l02644"></a>02644 <span class="keywordflow">while</span> (1)
<a name="l02645"></a>02645 {
<a name="l02646"></a>02646 word t=f[0];
<a name="l02647"></a>02647 <span class="keywordflow">while</span> (!t)
<a name="l02648"></a>02648 {
<a name="l02649"></a>02649 <span class="keywordflow">if</span> (EvenWordCount(f, fgLen)==0)
<a name="l02650"></a>02650 {
<a name="l02651"></a>02651 SetWords(R, 0, N);
<a name="l02652"></a>02652 <span class="keywordflow">return</span> 0;
<a name="l02653"></a>02653 }
<a name="l02654"></a>02654
<a name="l02655"></a>02655 ShiftWordsRightByWords(f, fgLen, 1);
<a name="l02656"></a>02656 bcLen += 2 * (c[bcLen-1] != 0);
<a name="l02657"></a>02657 assert(bcLen <= N);
<a name="l02658"></a>02658 ShiftWordsLeftByWords(c, bcLen, 1);
<a name="l02659"></a>02659 k+=WORD_BITS;
<a name="l02660"></a>02660 t=f[0];
<a name="l02661"></a>02661 }
<a name="l02662"></a>02662
<a name="l02663"></a>02663 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i = TrailingZeros(t);
<a name="l02664"></a>02664 t >>= i;
<a name="l02665"></a>02665 k += i;
<a name="l02666"></a>02666
<a name="l02667"></a>02667 <span class="keywordflow">if</span> (t==1 && f[1]==0 && EvenWordCount(f+2, fgLen-2)==0)
<a name="l02668"></a>02668 {
<a name="l02669"></a>02669 <span class="keywordflow">if</span> (s)
<a name="l02670"></a>02670 Subtract(R, M, b, N);
<a name="l02671"></a>02671 <span class="keywordflow">else</span>
<a name="l02672"></a>02672 CopyWords(R, b, N);
<a name="l02673"></a>02673 <span class="keywordflow">return</span> k;
<a name="l02674"></a>02674 }
<a name="l02675"></a>02675
<a name="l02676"></a>02676 ShiftWordsRightByBits(f, fgLen, i);
<a name="l02677"></a>02677 t = ShiftWordsLeftByBits(c, bcLen, i);
<a name="l02678"></a>02678 c[bcLen] += t;
<a name="l02679"></a>02679 bcLen += 2 * (t!=0);
<a name="l02680"></a>02680 assert(bcLen <= N);
<a name="l02681"></a>02681
<a name="l02682"></a>02682 <span class="keywordtype">bool</span> swap = Compare(f, g, fgLen)==-1;
<a name="l02683"></a>02683 ConditionalSwapPointers(swap, f, g);
<a name="l02684"></a>02684 ConditionalSwapPointers(swap, b, c);
<a name="l02685"></a>02685 s ^= swap;
<a name="l02686"></a>02686
<a name="l02687"></a>02687 fgLen -= 2 * !(f[fgLen-2] | f[fgLen-1]);
<a name="l02688"></a>02688
<a name="l02689"></a>02689 Subtract(f, f, g, fgLen);
<a name="l02690"></a>02690 t = Add(b, b, c, bcLen);
<a name="l02691"></a>02691 b[bcLen] += t;
<a name="l02692"></a>02692 bcLen += 2*t;
<a name="l02693"></a>02693 assert(bcLen <= N);
<a name="l02694"></a>02694 }
<a name="l02695"></a>02695 }
<a name="l02696"></a>02696
<a name="l02697"></a>02697 <span class="comment">// R[N] - result = A/(2^k) mod M</span>
<a name="l02698"></a>02698 <span class="comment">// A[N] - input</span>
<a name="l02699"></a>02699 <span class="comment">// M[N] - modulus</span>
<a name="l02700"></a>02700
<a name="l02701"></a>02701 <span class="keywordtype">void</span> DivideByPower2Mod(word *R, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> k, <span class="keyword">const</span> word *M, <span class="keywordtype">size_t</span> N)
<a name="l02702"></a>02702 {
<a name="l02703"></a>02703 CopyWords(R, A, N);
<a name="l02704"></a>02704
<a name="l02705"></a>02705 <span class="keywordflow">while</span> (k--)
<a name="l02706"></a>02706 {
<a name="l02707"></a>02707 <span class="keywordflow">if</span> (R[0]%2==0)
<a name="l02708"></a>02708 ShiftWordsRightByBits(R, N, 1);
<a name="l02709"></a>02709 <span class="keywordflow">else</span>
<a name="l02710"></a>02710 {
<a name="l02711"></a>02711 word carry = Add(R, R, M, N);
<a name="l02712"></a>02712 ShiftWordsRightByBits(R, N, 1);
<a name="l02713"></a>02713 R[N-1] += carry<<(WORD_BITS-1);
<a name="l02714"></a>02714 }
<a name="l02715"></a>02715 }
<a name="l02716"></a>02716 }
<a name="l02717"></a>02717
<a name="l02718"></a>02718 <span class="comment">// R[N] - result = A*(2^k) mod M</span>
<a name="l02719"></a>02719 <span class="comment">// A[N] - input</span>
<a name="l02720"></a>02720 <span class="comment">// M[N] - modulus</span>
<a name="l02721"></a>02721
<a name="l02722"></a>02722 <span class="keywordtype">void</span> MultiplyByPower2Mod(word *R, <span class="keyword">const</span> word *A, <span class="keywordtype">size_t</span> k, <span class="keyword">const</span> word *M, <span class="keywordtype">size_t</span> N)
<a name="l02723"></a>02723 {
<a name="l02724"></a>02724 CopyWords(R, A, N);
<a name="l02725"></a>02725
<a name="l02726"></a>02726 <span class="keywordflow">while</span> (k--)
<a name="l02727"></a>02727 <span class="keywordflow">if</span> (ShiftWordsLeftByBits(R, N, 1) || Compare(R, M, N)>=0)
<a name="l02728"></a>02728 Subtract(R, R, M, N);
<a name="l02729"></a>02729 }
<a name="l02730"></a>02730
<a name="l02731"></a>02731 <span class="comment">// ******************************************************************</span>
<a name="l02732"></a>02732
<a name="l02733"></a>02733 InitializeInteger::InitializeInteger()
<a name="l02734"></a>02734 {
<a name="l02735"></a>02735 <span class="keywordflow">if</span> (!g_pAssignIntToInteger)
<a name="l02736"></a>02736 {
<a name="l02737"></a>02737 SetFunctionPointers();
<a name="l02738"></a>02738 g_pAssignIntToInteger = AssignIntToInteger;
<a name="l02739"></a>02739 }
<a name="l02740"></a>02740 }
<a name="l02741"></a>02741
<a name="l02742"></a>02742 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> RoundupSizeTable[] = {2, 2, 2, 4, 4, 8, 8, 8, 8};
<a name="l02743"></a>02743
<a name="l02744"></a>02744 <span class="keyword">static</span> <span class="keyword">inline</span> <span class="keywordtype">size_t</span> RoundupSize(<span class="keywordtype">size_t</span> n)
<a name="l02745"></a>02745 {
<a name="l02746"></a>02746 <span class="keywordflow">if</span> (n<=8)
<a name="l02747"></a>02747 <span class="keywordflow">return</span> RoundupSizeTable[n];
<a name="l02748"></a>02748 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (n<=16)
<a name="l02749"></a>02749 <span class="keywordflow">return</span> 16;
<a name="l02750"></a>02750 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (n<=32)
<a name="l02751"></a>02751 <span class="keywordflow">return</span> 32;
<a name="l02752"></a>02752 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (n<=64)
<a name="l02753"></a>02753 <span class="keywordflow">return</span> 64;
<a name="l02754"></a>02754 <span class="keywordflow">else</span> <span class="keywordflow">return</span> size_t(1) << BitPrecision(n-1);
<a name="l02755"></a>02755 }
<a name="l02756"></a>02756
<a name="l02757"></a><a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a">02757</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>()
<a name="l02758"></a>02758 : reg(2), sign(POSITIVE)
<a name="l02759"></a>02759 {
<a name="l02760"></a>02760 reg[0] = reg[1] = 0;
<a name="l02761"></a>02761 }
<a name="l02762"></a>02762
<a name="l02763"></a><a class="code" href="class_integer.html#a9e86175b4b1fb79321736974846fce70">02763</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)
<a name="l02764"></a>02764 : reg(RoundupSize(t.WordCount())), sign(t.sign)
<a name="l02765"></a>02765 {
<a name="l02766"></a>02766 CopyWords(reg, t.reg, reg.size());
<a name="l02767"></a>02767 }
<a name="l02768"></a>02768
<a name="l02769"></a><a class="code" href="class_integer.html#a15a70886677caedd35492b495c5290e6">02769</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(Sign s, lword value)
<a name="l02770"></a>02770 : reg(2), sign(s)
<a name="l02771"></a>02771 {
<a name="l02772"></a>02772 reg[0] = word(value);
<a name="l02773"></a>02773 reg[1] = word(SafeRightShift<WORD_BITS>(value));
<a name="l02774"></a>02774 }
<a name="l02775"></a>02775
<a name="l02776"></a><a class="code" href="class_integer.html#ab0536c16f441f1b5abcb2019f7d52e17">02776</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<span class="keywordtype">signed</span> <span class="keywordtype">long</span> value)
<a name="l02777"></a>02777 : reg(2)
<a name="l02778"></a>02778 {
<a name="l02779"></a>02779 <span class="keywordflow">if</span> (value >= 0)
<a name="l02780"></a>02780 sign = POSITIVE;
<a name="l02781"></a>02781 <span class="keywordflow">else</span>
<a name="l02782"></a>02782 {
<a name="l02783"></a>02783 sign = NEGATIVE;
<a name="l02784"></a>02784 value = -value;
<a name="l02785"></a>02785 }
<a name="l02786"></a>02786 reg[0] = word(value);
<a name="l02787"></a>02787 reg[1] = word(SafeRightShift<WORD_BITS>((<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>)value));
<a name="l02788"></a>02788 }
<a name="l02789"></a>02789
<a name="l02790"></a><a class="code" href="class_integer.html#a834c31dcb78213e008b342c97764fd5d">02790</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(Sign s, word high, word low)
<a name="l02791"></a>02791 : reg(2), sign(s)
<a name="l02792"></a>02792 {
<a name="l02793"></a>02793 reg[0] = low;
<a name="l02794"></a>02794 reg[1] = high;
<a name="l02795"></a>02795 }
<a name="l02796"></a>02796
<a name="l02797"></a><a class="code" href="class_integer.html#abc8abb12371da5c520d15efd64532697">02797</a> <span class="keywordtype">bool</span> <a class="code" href="class_integer.html#abc8abb12371da5c520d15efd64532697" title="return true if *this can be represented as a signed long">Integer::IsConvertableToLong</a>()<span class="keyword"> const</span>
<a name="l02798"></a>02798 <span class="keyword"></span>{
<a name="l02799"></a>02799 <span class="keywordflow">if</span> (<a class="code" href="class_integer.html#aea4f2d31725ab02c67d9ea0288767670" title="number of significant bytes = ceiling(BitCount()/8)">ByteCount</a>() > <span class="keyword">sizeof</span>(<span class="keywordtype">long</span>))
<a name="l02800"></a>02800 <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l02801"></a>02801
<a name="l02802"></a>02802 <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> value = (<span class="keywordtype">unsigned</span> long)reg[0];
<a name="l02803"></a>02803 value += SafeLeftShift<WORD_BITS, unsigned long>((<span class="keywordtype">unsigned</span> long)reg[1]);
<a name="l02804"></a>02804
<a name="l02805"></a>02805 <span class="keywordflow">if</span> (sign==POSITIVE)
<a name="l02806"></a>02806 <span class="keywordflow">return</span> (<span class="keywordtype">signed</span> <span class="keywordtype">long</span>)value >= 0;
<a name="l02807"></a>02807 <span class="keywordflow">else</span>
<a name="l02808"></a>02808 <span class="keywordflow">return</span> -(<span class="keywordtype">signed</span> long)value < 0;
<a name="l02809"></a>02809 }
<a name="l02810"></a>02810
<a name="l02811"></a><a class="code" href="class_integer.html#a9c689da5ded6e077a203b122deec519f">02811</a> <span class="keywordtype">signed</span> <span class="keywordtype">long</span> <a class="code" href="class_integer.html#a9c689da5ded6e077a203b122deec519f" title="return equivalent signed long if possible, otherwise undefined">Integer::ConvertToLong</a>()<span class="keyword"> const</span>
<a name="l02812"></a>02812 <span class="keyword"></span>{
<a name="l02813"></a>02813 assert(<a class="code" href="class_integer.html#abc8abb12371da5c520d15efd64532697" title="return true if *this can be represented as a signed long">IsConvertableToLong</a>());
<a name="l02814"></a>02814
<a name="l02815"></a>02815 <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> value = (<span class="keywordtype">unsigned</span> long)reg[0];
<a name="l02816"></a>02816 value += SafeLeftShift<WORD_BITS, unsigned long>((<span class="keywordtype">unsigned</span> long)reg[1]);
<a name="l02817"></a>02817 <span class="keywordflow">return</span> sign==POSITIVE ? value : -(<span class="keywordtype">signed</span> long)value;
<a name="l02818"></a>02818 }
<a name="l02819"></a>02819
<a name="l02820"></a><a class="code" href="class_integer.html#a39fee8047d003a1d6044da4b5025f3ce">02820</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &encodedInteger, <span class="keywordtype">size_t</span> byteCount, Signedness s)
<a name="l02821"></a>02821 {
<a name="l02822"></a>02822 Decode(encodedInteger, byteCount, s);
<a name="l02823"></a>02823 }
<a name="l02824"></a>02824
<a name="l02825"></a><a class="code" href="class_integer.html#a19c0d3273fcc216a5849527c7ba759d8">02825</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<span class="keyword">const</span> byte *encodedInteger, <span class="keywordtype">size_t</span> byteCount, Signedness s)
<a name="l02826"></a>02826 {
<a name="l02827"></a>02827 Decode(encodedInteger, byteCount, s);
<a name="l02828"></a>02828 }
<a name="l02829"></a>02829
<a name="l02830"></a><a class="code" href="class_integer.html#a81d3973655b9f9d358de31ca4d0215c1">02830</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)
<a name="l02831"></a>02831 {
<a name="l02832"></a>02832 BERDecode(bt);
<a name="l02833"></a>02833 }
<a name="l02834"></a>02834
<a name="l02835"></a><a class="code" href="class_integer.html#aeb4abb834e9e897a28850d2081f3fa63">02835</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng, <span class="keywordtype">size_t</span> bitcount)
<a name="l02836"></a>02836 {
<a name="l02837"></a>02837 Randomize(rng, bitcount);
<a name="l02838"></a>02838 }
<a name="l02839"></a>02839
<a name="l02840"></a><a class="code" href="class_integer.html#a88a110cb9f89a8810c228ad00cea18c2">02840</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &min, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &max, RandomNumberType rnType, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &equiv, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &mod)
<a name="l02841"></a>02841 {
<a name="l02842"></a>02842 <span class="keywordflow">if</span> (!Randomize(rng, min, max, rnType, equiv, mod))
<a name="l02843"></a>02843 <span class="keywordflow">throw</span> <a class="code" href="class_integer_1_1_random_number_not_found.html">Integer::RandomNumberNotFound</a>();
<a name="l02844"></a>02844 }
<a name="l02845"></a>02845
<a name="l02846"></a><a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c">02846</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> <a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Integer::Power2</a>(<span class="keywordtype">size_t</span> e)
<a name="l02847"></a>02847 {
<a name="l02848"></a>02848 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> r((word)0, BitsToWords(e+1));
<a name="l02849"></a>02849 r.<a class="code" href="class_integer.html#a2f0d5fae94eba0c55da9bd1c5138d155" title="set the n-th bit to value">SetBit</a>(e);
<a name="l02850"></a>02850 <span class="keywordflow">return</span> r;
<a name="l02851"></a>02851 }
<a name="l02852"></a>02852
<a name="l02853"></a>02853 <span class="keyword">template</span> <<span class="keywordtype">long</span> i>
<a name="l02854"></a><a class="code" href="struct_new_integer.html">02854</a> <span class="keyword">struct </span><a class="code" href="struct_new_integer.html">NewInteger</a>
<a name="l02855"></a>02855 {
<a name="l02856"></a>02856 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> * operator()()<span class="keyword"> const</span>
<a name="l02857"></a>02857 <span class="keyword"> </span>{
<a name="l02858"></a>02858 <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>(i);
<a name="l02859"></a>02859 }
<a name="l02860"></a>02860 };
<a name="l02861"></a>02861
<a name="l02862"></a><a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175">02862</a> <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &<a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Integer::Zero</a>()
<a name="l02863"></a>02863 {
<a name="l02864"></a>02864 <span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<Integer></a>().Ref();
<a name="l02865"></a>02865 }
<a name="l02866"></a>02866
<a name="l02867"></a><a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638">02867</a> <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &<a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">Integer::One</a>()
<a name="l02868"></a>02868 {
<a name="l02869"></a>02869 <span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<Integer, NewInteger<1></a> >().Ref();
<a name="l02870"></a>02870 }
<a name="l02871"></a>02871
<a name="l02872"></a><a class="code" href="class_integer.html#af0cb74a45a48e677952166bdac9d82d7">02872</a> <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &<a class="code" href="class_integer.html#af0cb74a45a48e677952166bdac9d82d7" title="avoid calling constructors for these frequently used integers">Integer::Two</a>()
<a name="l02873"></a>02873 {
<a name="l02874"></a>02874 <span class="keywordflow">return</span> <a class="code" href="class_singleton.html">Singleton<Integer, NewInteger<2></a> >().Ref();
<a name="l02875"></a>02875 }
<a name="l02876"></a>02876
<a name="l02877"></a>02877 <span class="keywordtype">bool</span> Integer::operator!()<span class="keyword"> const</span>
<a name="l02878"></a>02878 <span class="keyword"></span>{
<a name="l02879"></a>02879 <span class="keywordflow">return</span> IsNegative() ? <span class="keyword">false</span> : (reg[0]==0 && <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>()==0);
<a name="l02880"></a>02880 }
<a name="l02881"></a>02881
<a name="l02882"></a>02882 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator=(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)
<a name="l02883"></a>02883 {
<a name="l02884"></a>02884 <span class="keywordflow">if</span> (<span class="keyword">this</span> != &t)
<a name="l02885"></a>02885 {
<a name="l02886"></a>02886 <span class="keywordflow">if</span> (reg.size() != t.reg.size() || t.reg[t.reg.size()/2] == 0)
<a name="l02887"></a>02887 reg.<a class="code" href="class_sec_block.html#a90d46e577c951d81a2d25a4742a3e979" title="change size, without preserving contents">New</a>(RoundupSize(t.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>()));
<a name="l02888"></a>02888 CopyWords(reg, t.reg, reg.size());
<a name="l02889"></a>02889 sign = t.sign;
<a name="l02890"></a>02890 }
<a name="l02891"></a>02891 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l02892"></a>02892 }
<a name="l02893"></a>02893
<a name="l02894"></a><a class="code" href="class_integer.html#a2814c3b82849bd8f6f44cc36974f1717">02894</a> <span class="keywordtype">bool</span> <a class="code" href="class_integer.html#a2814c3b82849bd8f6f44cc36974f1717" title="return the i-th bit, i=0 being the least significant bit">Integer::GetBit</a>(<span class="keywordtype">size_t</span> n)<span class="keyword"> const</span>
<a name="l02895"></a>02895 <span class="keyword"></span>{
<a name="l02896"></a>02896 <span class="keywordflow">if</span> (n/WORD_BITS >= reg.size())
<a name="l02897"></a>02897 <span class="keywordflow">return</span> 0;
<a name="l02898"></a>02898 <span class="keywordflow">else</span>
<a name="l02899"></a>02899 <span class="keywordflow">return</span> bool((reg[n/WORD_BITS] >> (n % WORD_BITS)) & 1);
<a name="l02900"></a>02900 }
<a name="l02901"></a>02901
<a name="l02902"></a><a class="code" href="class_integer.html#a2f0d5fae94eba0c55da9bd1c5138d155">02902</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a2f0d5fae94eba0c55da9bd1c5138d155" title="set the n-th bit to value">Integer::SetBit</a>(<span class="keywordtype">size_t</span> n, <span class="keywordtype">bool</span> value)
<a name="l02903"></a>02903 {
<a name="l02904"></a>02904 <span class="keywordflow">if</span> (value)
<a name="l02905"></a>02905 {
<a name="l02906"></a>02906 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(RoundupSize(BitsToWords(n+1)));
<a name="l02907"></a>02907 reg[n/WORD_BITS] |= (word(1) << (n%WORD_BITS));
<a name="l02908"></a>02908 }
<a name="l02909"></a>02909 <span class="keywordflow">else</span>
<a name="l02910"></a>02910 {
<a name="l02911"></a>02911 <span class="keywordflow">if</span> (n/WORD_BITS < reg.size())
<a name="l02912"></a>02912 reg[n/WORD_BITS] &= ~(word(1) << (n%WORD_BITS));
<a name="l02913"></a>02913 }
<a name="l02914"></a>02914 }
<a name="l02915"></a>02915
<a name="l02916"></a><a class="code" href="class_integer.html#a95fad23b0d8a06325ca2893300c9b45e">02916</a> byte <a class="code" href="class_integer.html#a95fad23b0d8a06325ca2893300c9b45e" title="return the i-th byte">Integer::GetByte</a>(<span class="keywordtype">size_t</span> n)<span class="keyword"> const</span>
<a name="l02917"></a>02917 <span class="keyword"></span>{
<a name="l02918"></a>02918 <span class="keywordflow">if</span> (n/WORD_SIZE >= reg.size())
<a name="l02919"></a>02919 <span class="keywordflow">return</span> 0;
<a name="l02920"></a>02920 <span class="keywordflow">else</span>
<a name="l02921"></a>02921 <span class="keywordflow">return</span> byte(reg[n/WORD_SIZE] >> ((n%WORD_SIZE)*8));
<a name="l02922"></a>02922 }
<a name="l02923"></a>02923
<a name="l02924"></a><a class="code" href="class_integer.html#a0ff987d783a61f52c8c5d57b324a8d45">02924</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a0ff987d783a61f52c8c5d57b324a8d45" title="set the n-th byte to value">Integer::SetByte</a>(<span class="keywordtype">size_t</span> n, byte value)
<a name="l02925"></a>02925 {
<a name="l02926"></a>02926 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(RoundupSize(BytesToWords(n+1)));
<a name="l02927"></a>02927 reg[n/WORD_SIZE] &= ~(word(0xff) << 8*(n%WORD_SIZE));
<a name="l02928"></a>02928 reg[n/WORD_SIZE] |= (word(value) << 8*(n%WORD_SIZE));
<a name="l02929"></a>02929 }
<a name="l02930"></a>02930
<a name="l02931"></a><a class="code" href="class_integer.html#a66049970ba544ce8178f9c7d69776b23">02931</a> lword <a class="code" href="class_integer.html#a66049970ba544ce8178f9c7d69776b23" title="return n lowest bits of *this >> i">Integer::GetBits</a>(<span class="keywordtype">size_t</span> i, <span class="keywordtype">size_t</span> n)<span class="keyword"> const</span>
<a name="l02932"></a>02932 <span class="keyword"></span>{
<a name="l02933"></a>02933 lword v = 0;
<a name="l02934"></a>02934 assert(n <= <span class="keyword">sizeof</span>(v)*8);
<a name="l02935"></a>02935 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> j=0; j<n; j++)
<a name="l02936"></a>02936 v |= lword(<a class="code" href="class_integer.html#a2814c3b82849bd8f6f44cc36974f1717" title="return the i-th bit, i=0 being the least significant bit">GetBit</a>(i+j)) << j;
<a name="l02937"></a>02937 <span class="keywordflow">return</span> v;
<a name="l02938"></a>02938 }
<a name="l02939"></a>02939
<a name="l02940"></a>02940 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::operator-()<span class="keyword"> const</span>
<a name="l02941"></a>02941 <span class="keyword"></span>{
<a name="l02942"></a>02942 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> result(*<span class="keyword">this</span>);
<a name="l02943"></a>02943 result.Negate();
<a name="l02944"></a>02944 <span class="keywordflow">return</span> result;
<a name="l02945"></a>02945 }
<a name="l02946"></a>02946
<a name="l02947"></a>02947 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::AbsoluteValue()<span class="keyword"> const</span>
<a name="l02948"></a>02948 <span class="keyword"></span>{
<a name="l02949"></a>02949 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> result(*<span class="keyword">this</span>);
<a name="l02950"></a>02950 result.sign = POSITIVE;
<a name="l02951"></a>02951 <span class="keywordflow">return</span> result;
<a name="l02952"></a>02952 }
<a name="l02953"></a>02953
<a name="l02954"></a>02954 <span class="keywordtype">void</span> Integer::swap(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)
<a name="l02955"></a>02955 {
<a name="l02956"></a>02956 reg.<a class="code" href="class_sec_block.html#a3872f50f03372fa859803971961f02cd" title="swap contents and size with another SecBlock">swap</a>(a.reg);
<a name="l02957"></a>02957 std::swap(sign, a.sign);
<a name="l02958"></a>02958 }
<a name="l02959"></a>02959
<a name="l02960"></a>02960 <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(word value, <span class="keywordtype">size_t</span> length)
<a name="l02961"></a>02961 : reg(RoundupSize(length)), sign(POSITIVE)
<a name="l02962"></a>02962 {
<a name="l02963"></a>02963 reg[0] = value;
<a name="l02964"></a>02964 SetWords(reg+1, 0, reg.size()-1);
<a name="l02965"></a>02965 }
<a name="l02966"></a>02966
<a name="l02967"></a>02967 <span class="keyword">template</span> <<span class="keyword">class</span> T>
<a name="l02968"></a>02968 <span class="keyword">static</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> StringToInteger(<span class="keyword">const</span> T *str)
<a name="l02969"></a>02969 {
<a name="l02970"></a>02970 <span class="keywordtype">int</span> radix;
<a name="l02971"></a>02971 <span class="comment">// GCC workaround</span>
<a name="l02972"></a>02972 <span class="comment">// std::char_traits<wchar_t>::length() not defined in GCC 3.2 and STLport 4.5.3</span>
<a name="l02973"></a>02973 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length;
<a name="l02974"></a>02974 <span class="keywordflow">for</span> (length = 0; str[length] != 0; length++) {}
<a name="l02975"></a>02975
<a name="l02976"></a>02976 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> v;
<a name="l02977"></a>02977
<a name="l02978"></a>02978 <span class="keywordflow">if</span> (length == 0)
<a name="l02979"></a>02979 <span class="keywordflow">return</span> v;
<a name="l02980"></a>02980
<a name="l02981"></a>02981 <span class="keywordflow">switch</span> (str[length-1])
<a name="l02982"></a>02982 {
<a name="l02983"></a>02983 <span class="keywordflow">case</span> <span class="charliteral">'h'</span>:
<a name="l02984"></a>02984 <span class="keywordflow">case</span> <span class="charliteral">'H'</span>:
<a name="l02985"></a>02985 radix=16;
<a name="l02986"></a>02986 <span class="keywordflow">break</span>;
<a name="l02987"></a>02987 <span class="keywordflow">case</span> <span class="charliteral">'o'</span>:
<a name="l02988"></a>02988 <span class="keywordflow">case</span> <span class="charliteral">'O'</span>:
<a name="l02989"></a>02989 radix=8;
<a name="l02990"></a>02990 <span class="keywordflow">break</span>;
<a name="l02991"></a>02991 <span class="keywordflow">case</span> <span class="charliteral">'b'</span>:
<a name="l02992"></a>02992 <span class="keywordflow">case</span> <span class="charliteral">'B'</span>:
<a name="l02993"></a>02993 radix=2;
<a name="l02994"></a>02994 <span class="keywordflow">break</span>;
<a name="l02995"></a>02995 <span class="keywordflow">default</span>:
<a name="l02996"></a>02996 radix=10;
<a name="l02997"></a>02997 }
<a name="l02998"></a>02998
<a name="l02999"></a>02999 <span class="keywordflow">if</span> (length > 2 && str[0] == <span class="charliteral">'0'</span> && str[1] == <span class="charliteral">'x'</span>)
<a name="l03000"></a>03000 radix = 16;
<a name="l03001"></a>03001
<a name="l03002"></a>03002 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> i=0; i<length; i++)
<a name="l03003"></a>03003 {
<a name="l03004"></a>03004 <span class="keywordtype">int</span> digit;
<a name="l03005"></a>03005
<a name="l03006"></a>03006 <span class="keywordflow">if</span> (str[i] >= <span class="charliteral">'0'</span> && str[i] <= <span class="charliteral">'9'</span>)
<a name="l03007"></a>03007 digit = str[i] - <span class="charliteral">'0'</span>;
<a name="l03008"></a>03008 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (str[i] >= <span class="charliteral">'A'</span> && str[i] <= <span class="charliteral">'F'</span>)
<a name="l03009"></a>03009 digit = str[i] - <span class="charliteral">'A'</span> + 10;
<a name="l03010"></a>03010 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (str[i] >= <span class="charliteral">'a'</span> && str[i] <= <span class="charliteral">'f'</span>)
<a name="l03011"></a>03011 digit = str[i] - <span class="charliteral">'a'</span> + 10;
<a name="l03012"></a>03012 <span class="keywordflow">else</span>
<a name="l03013"></a>03013 digit = radix;
<a name="l03014"></a>03014
<a name="l03015"></a>03015 <span class="keywordflow">if</span> (digit < radix)
<a name="l03016"></a>03016 {
<a name="l03017"></a>03017 v *= radix;
<a name="l03018"></a>03018 v += digit;
<a name="l03019"></a>03019 }
<a name="l03020"></a>03020 }
<a name="l03021"></a>03021
<a name="l03022"></a>03022 <span class="keywordflow">if</span> (str[0] == <span class="charliteral">'-'</span>)
<a name="l03023"></a>03023 v.Negate();
<a name="l03024"></a>03024
<a name="l03025"></a>03025 <span class="keywordflow">return</span> v;
<a name="l03026"></a>03026 }
<a name="l03027"></a>03027
<a name="l03028"></a><a class="code" href="class_integer.html#a9e8bf8c72458dff4ceb5d6cdf9e5c97a">03028</a> <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *str)
<a name="l03029"></a>03029 : reg(2), sign(POSITIVE)
<a name="l03030"></a>03030 {
<a name="l03031"></a>03031 *<span class="keyword">this</span> = StringToInteger(str);
<a name="l03032"></a>03032 }
<a name="l03033"></a>03033
<a name="l03034"></a>03034 <a class="code" href="class_integer.html#a7fcab0564d7270017ebcca55bae1a17a" title="creates the zero integer">Integer::Integer</a>(<span class="keyword">const</span> <span class="keywordtype">wchar_t</span> *str)
<a name="l03035"></a>03035 : reg(2), sign(POSITIVE)
<a name="l03036"></a>03036 {
<a name="l03037"></a>03037 *<span class="keyword">this</span> = StringToInteger(str);
<a name="l03038"></a>03038 }
<a name="l03039"></a>03039
<a name="l03040"></a><a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396">03040</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">Integer::WordCount</a>()<span class="keyword"> const</span>
<a name="l03041"></a>03041 <span class="keyword"></span>{
<a name="l03042"></a>03042 <span class="keywordflow">return</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>)CountWords(reg, reg.size());
<a name="l03043"></a>03043 }
<a name="l03044"></a>03044
<a name="l03045"></a><a class="code" href="class_integer.html#aea4f2d31725ab02c67d9ea0288767670">03045</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_integer.html#aea4f2d31725ab02c67d9ea0288767670" title="number of significant bytes = ceiling(BitCount()/8)">Integer::ByteCount</a>()<span class="keyword"> const</span>
<a name="l03046"></a>03046 <span class="keyword"></span>{
<a name="l03047"></a>03047 <span class="keywordtype">unsigned</span> wordCount = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03048"></a>03048 <span class="keywordflow">if</span> (wordCount)
<a name="l03049"></a>03049 <span class="keywordflow">return</span> (wordCount-1)*WORD_SIZE + BytePrecision(reg[wordCount-1]);
<a name="l03050"></a>03050 <span class="keywordflow">else</span>
<a name="l03051"></a>03051 <span class="keywordflow">return</span> 0;
<a name="l03052"></a>03052 }
<a name="l03053"></a>03053
<a name="l03054"></a><a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d">03054</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d" title="number of significant bits = floor(log2(abs(*this))) + 1">Integer::BitCount</a>()<span class="keyword"> const</span>
<a name="l03055"></a>03055 <span class="keyword"></span>{
<a name="l03056"></a>03056 <span class="keywordtype">unsigned</span> wordCount = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03057"></a>03057 <span class="keywordflow">if</span> (wordCount)
<a name="l03058"></a>03058 <span class="keywordflow">return</span> (wordCount-1)*WORD_BITS + BitPrecision(reg[wordCount-1]);
<a name="l03059"></a>03059 <span class="keywordflow">else</span>
<a name="l03060"></a>03060 <span class="keywordflow">return</span> 0;
<a name="l03061"></a>03061 }
<a name="l03062"></a>03062
<a name="l03063"></a>03063 <span class="keywordtype">void</span> Integer::Decode(<span class="keyword">const</span> byte *input, <span class="keywordtype">size_t</span> inputLen, Signedness s)
<a name="l03064"></a>03064 {
<a name="l03065"></a>03065 <a class="code" href="class_string_store.html" title="string-based implementation of Store interface">StringStore</a> store(input, inputLen);
<a name="l03066"></a>03066 Decode(store, inputLen, s);
<a name="l03067"></a>03067 }
<a name="l03068"></a>03068
<a name="l03069"></a>03069 <span class="keywordtype">void</span> Integer::Decode(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt, <span class="keywordtype">size_t</span> inputLen, Signedness s)
<a name="l03070"></a>03070 {
<a name="l03071"></a>03071 assert(bt.<a class="code" href="class_buffered_transformation.html#a6ec48acd2d2bda08baa4baa1c9a8a99c" title="returns number of bytes that is currently ready for retrieval">MaxRetrievable</a>() >= inputLen);
<a name="l03072"></a>03072
<a name="l03073"></a>03073 byte b;
<a name="l03074"></a>03074 bt.<a class="code" href="class_buffered_transformation.html#a5fa048faf8c043ad57ae0a8911070090" title="peek at the next byte without removing it from the output buffer">Peek</a>(b);
<a name="l03075"></a>03075 sign = ((s==SIGNED) && (b & 0x80)) ? NEGATIVE : POSITIVE;
<a name="l03076"></a>03076
<a name="l03077"></a>03077 <span class="keywordflow">while</span> (inputLen>0 && (sign==POSITIVE ? b==0 : b==0xff))
<a name="l03078"></a>03078 {
<a name="l03079"></a>03079 bt.<a class="code" href="class_buffered_transformation.html#a0c25529ded99db20ad35ccef3f7234e6" title="discard skipMax bytes from the output buffer">Skip</a>(1);
<a name="l03080"></a>03080 inputLen--;
<a name="l03081"></a>03081 bt.<a class="code" href="class_buffered_transformation.html#a5fa048faf8c043ad57ae0a8911070090" title="peek at the next byte without removing it from the output buffer">Peek</a>(b);
<a name="l03082"></a>03082 }
<a name="l03083"></a>03083
<a name="l03084"></a>03084 reg.<a class="code" href="class_sec_block.html#a2d78e75002fd02e5b89bd72a9e65e769" title="change size and set contents to 0">CleanNew</a>(RoundupSize(BytesToWords(inputLen)));
<a name="l03085"></a>03085
<a name="l03086"></a>03086 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=inputLen; i > 0; i--)
<a name="l03087"></a>03087 {
<a name="l03088"></a>03088 bt.<a class="code" href="class_buffered_transformation.html#a9e1ad913c8fe697d269f408a7d5928fc" title="try to retrieve a single byte">Get</a>(b);
<a name="l03089"></a>03089 reg[(i-1)/WORD_SIZE] |= word(b) << ((i-1)%WORD_SIZE)*8;
<a name="l03090"></a>03090 }
<a name="l03091"></a>03091
<a name="l03092"></a>03092 <span class="keywordflow">if</span> (sign == NEGATIVE)
<a name="l03093"></a>03093 {
<a name="l03094"></a>03094 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=inputLen; i<reg.size()*WORD_SIZE; i++)
<a name="l03095"></a>03095 reg[i/WORD_SIZE] |= word(0xff) << (i%WORD_SIZE)*8;
<a name="l03096"></a>03096 TwosComplement(reg, reg.size());
<a name="l03097"></a>03097 }
<a name="l03098"></a>03098 }
<a name="l03099"></a>03099
<a name="l03100"></a><a class="code" href="class_integer.html#a3b269bbf8a91faf217c0dd76222182bb">03100</a> <span class="keywordtype">size_t</span> <a class="code" href="class_integer.html#a3b269bbf8a91faf217c0dd76222182bb" title="minimum number of bytes to encode this integer">Integer::MinEncodedSize</a>(Signedness signedness)<span class="keyword"> const</span>
<a name="l03101"></a>03101 <span class="keyword"></span>{
<a name="l03102"></a>03102 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> outputLen = STDMAX(1U, <a class="code" href="class_integer.html#aea4f2d31725ab02c67d9ea0288767670" title="number of significant bytes = ceiling(BitCount()/8)">ByteCount</a>());
<a name="l03103"></a>03103 <span class="keywordflow">if</span> (signedness == UNSIGNED)
<a name="l03104"></a>03104 <span class="keywordflow">return</span> outputLen;
<a name="l03105"></a>03105 <span class="keywordflow">if</span> (NotNegative() && (<a class="code" href="class_integer.html#a95fad23b0d8a06325ca2893300c9b45e" title="return the i-th byte">GetByte</a>(outputLen-1) & 0x80))
<a name="l03106"></a>03106 outputLen++;
<a name="l03107"></a>03107 <span class="keywordflow">if</span> (IsNegative() && *<span class="keyword">this</span> < -<a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Power2</a>(outputLen*8-1))
<a name="l03108"></a>03108 outputLen++;
<a name="l03109"></a>03109 <span class="keywordflow">return</span> outputLen;
<a name="l03110"></a>03110 }
<a name="l03111"></a>03111
<a name="l03112"></a><a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4">03112</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Integer::Encode</a>(byte *output, <span class="keywordtype">size_t</span> outputLen, Signedness signedness)<span class="keyword"> const</span>
<a name="l03113"></a>03113 <span class="keyword"></span>{
<a name="l03114"></a>03114 <a class="code" href="class_array_sink.html" title="Copy input to a memory buffer.">ArraySink</a> sink(output, outputLen);
<a name="l03115"></a>03115 <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Encode</a>(sink, outputLen, signedness);
<a name="l03116"></a>03116 }
<a name="l03117"></a>03117
<a name="l03118"></a>03118 <span class="keywordtype">void</span> <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Integer::Encode</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt, <span class="keywordtype">size_t</span> outputLen, Signedness signedness)<span class="keyword"> const</span>
<a name="l03119"></a>03119 <span class="keyword"></span>{
<a name="l03120"></a>03120 <span class="keywordflow">if</span> (signedness == UNSIGNED || NotNegative())
<a name="l03121"></a>03121 {
<a name="l03122"></a>03122 <span class="keywordflow">for</span> (<span class="keywordtype">size_t</span> i=outputLen; i > 0; i--)
<a name="l03123"></a>03123 bt.<a class="code" href="class_buffered_transformation.html#ae70658b0d271f8e114ac6c3cc9774ede" title="input a byte for processing">Put</a>(<a class="code" href="class_integer.html#a95fad23b0d8a06325ca2893300c9b45e" title="return the i-th byte">GetByte</a>(i-1));
<a name="l03124"></a>03124 }
<a name="l03125"></a>03125 <span class="keywordflow">else</span>
<a name="l03126"></a>03126 {
<a name="l03127"></a>03127 <span class="comment">// take two's complement of *this</span>
<a name="l03128"></a>03128 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> temp = <a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Integer::Power2</a>(8*STDMAX((<span class="keywordtype">size_t</span>)<a class="code" href="class_integer.html#aea4f2d31725ab02c67d9ea0288767670" title="number of significant bytes = ceiling(BitCount()/8)">ByteCount</a>(), outputLen)) + *<span class="keyword">this</span>;
<a name="l03129"></a>03129 temp.<a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Encode</a>(bt, outputLen, UNSIGNED);
<a name="l03130"></a>03130 }
<a name="l03131"></a>03131 }
<a name="l03132"></a>03132
<a name="l03133"></a><a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e">03133</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">Integer::DEREncode</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)<span class="keyword"> const</span>
<a name="l03134"></a>03134 <span class="keyword"></span>{
<a name="l03135"></a>03135 <a class="code" href="class_d_e_r_general_encoder.html" title="DER General Encoder.">DERGeneralEncoder</a> enc(bt, INTEGER);
<a name="l03136"></a>03136 <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Encode</a>(enc, <a class="code" href="class_integer.html#a3b269bbf8a91faf217c0dd76222182bb" title="minimum number of bytes to encode this integer">MinEncodedSize</a>(SIGNED), SIGNED);
<a name="l03137"></a>03137 enc.MessageEnd();
<a name="l03138"></a>03138 }
<a name="l03139"></a>03139
<a name="l03140"></a>03140 <span class="keywordtype">void</span> Integer::BERDecode(<span class="keyword">const</span> byte *input, <span class="keywordtype">size_t</span> len)
<a name="l03141"></a>03141 {
<a name="l03142"></a>03142 <a class="code" href="class_string_store.html" title="string-based implementation of Store interface">StringStore</a> store(input, len);
<a name="l03143"></a>03143 BERDecode(store);
<a name="l03144"></a>03144 }
<a name="l03145"></a>03145
<a name="l03146"></a><a class="code" href="class_integer.html#a8736cc41b06596c9c04328d2f0238db7">03146</a> <span class="keywordtype">void</span> Integer::BERDecode(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)
<a name="l03147"></a>03147 {
<a name="l03148"></a>03148 <a class="code" href="class_b_e_r_general_decoder.html" title="BER General Decoder.">BERGeneralDecoder</a> dec(bt, INTEGER);
<a name="l03149"></a>03149 <span class="keywordflow">if</span> (!dec.IsDefiniteLength() || dec.<a class="code" href="class_buffered_transformation.html#a6ec48acd2d2bda08baa4baa1c9a8a99c" title="returns number of bytes that is currently ready for retrieval">MaxRetrievable</a>() < dec.RemainingLength())
<a name="l03150"></a>03150 BERDecodeError();
<a name="l03151"></a>03151 Decode(dec, (<span class="keywordtype">size_t</span>)dec.RemainingLength(), SIGNED);
<a name="l03152"></a>03152 dec.MessageEnd();
<a name="l03153"></a>03153 }
<a name="l03154"></a>03154
<a name="l03155"></a><a class="code" href="class_integer.html#a1dc54b479df856d614cb23e362126110">03155</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a1dc54b479df856d614cb23e362126110" title="encode absolute value as big-endian octet string">Integer::DEREncodeAsOctetString</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt, <span class="keywordtype">size_t</span> length)<span class="keyword"> const</span>
<a name="l03156"></a>03156 <span class="keyword"></span>{
<a name="l03157"></a>03157 <a class="code" href="class_d_e_r_general_encoder.html" title="DER General Encoder.">DERGeneralEncoder</a> enc(bt, OCTET_STRING);
<a name="l03158"></a>03158 <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Encode</a>(enc, length);
<a name="l03159"></a>03159 enc.MessageEnd();
<a name="l03160"></a>03160 }
<a name="l03161"></a>03161
<a name="l03162"></a><a class="code" href="class_integer.html#a59f2e3f759fb252da8ce4bd718fb6487">03162</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a59f2e3f759fb252da8ce4bd718fb6487" title="decode nonnegative value as big-endian octet string">Integer::BERDecodeAsOctetString</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt, <span class="keywordtype">size_t</span> length)
<a name="l03163"></a>03163 {
<a name="l03164"></a>03164 <a class="code" href="class_b_e_r_general_decoder.html" title="BER General Decoder.">BERGeneralDecoder</a> dec(bt, OCTET_STRING);
<a name="l03165"></a>03165 <span class="keywordflow">if</span> (!dec.IsDefiniteLength() || dec.RemainingLength() != length)
<a name="l03166"></a>03166 BERDecodeError();
<a name="l03167"></a>03167 Decode(dec, length);
<a name="l03168"></a>03168 dec.MessageEnd();
<a name="l03169"></a>03169 }
<a name="l03170"></a>03170
<a name="l03171"></a><a class="code" href="class_integer.html#a9d6226e12e1ac0b957ad84ac54a15ce9">03171</a> <span class="keywordtype">size_t</span> <a class="code" href="class_integer.html#a9d6226e12e1ac0b957ad84ac54a15ce9" title="encode absolute value in OpenPGP format, return length of output">Integer::OpenPGPEncode</a>(byte *output, <span class="keywordtype">size_t</span> len)<span class="keyword"> const</span>
<a name="l03172"></a>03172 <span class="keyword"></span>{
<a name="l03173"></a>03173 <a class="code" href="class_array_sink.html" title="Copy input to a memory buffer.">ArraySink</a> sink(output, len);
<a name="l03174"></a>03174 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#a9d6226e12e1ac0b957ad84ac54a15ce9" title="encode absolute value in OpenPGP format, return length of output">OpenPGPEncode</a>(sink);
<a name="l03175"></a>03175 }
<a name="l03176"></a>03176
<a name="l03177"></a><a class="code" href="class_integer.html#a2325e09a01b29c3a70f3c2bcfcea0a1d">03177</a> <span class="keywordtype">size_t</span> <a class="code" href="class_integer.html#a9d6226e12e1ac0b957ad84ac54a15ce9" title="encode absolute value in OpenPGP format, return length of output">Integer::OpenPGPEncode</a>(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)<span class="keyword"> const</span>
<a name="l03178"></a>03178 <span class="keyword"></span>{
<a name="l03179"></a>03179 word16 bitCount = <a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d" title="number of significant bits = floor(log2(abs(*this))) + 1">BitCount</a>();
<a name="l03180"></a>03180 bt.<a class="code" href="class_buffered_transformation.html#a92c60616792d7bce5cd41eaffbd1c3cc" title="input a 16-bit word">PutWord16</a>(bitCount);
<a name="l03181"></a>03181 <span class="keywordtype">size_t</span> byteCount = BitsToBytes(bitCount);
<a name="l03182"></a>03182 <a class="code" href="class_integer.html#ac12ea467de9a609b86ec03d8cb8837e4" title="encode in big-endian format">Encode</a>(bt, byteCount);
<a name="l03183"></a>03183 <span class="keywordflow">return</span> 2 + byteCount;
<a name="l03184"></a>03184 }
<a name="l03185"></a>03185
<a name="l03186"></a>03186 <span class="keywordtype">void</span> Integer::OpenPGPDecode(<span class="keyword">const</span> byte *input, <span class="keywordtype">size_t</span> len)
<a name="l03187"></a>03187 {
<a name="l03188"></a>03188 <a class="code" href="class_string_store.html" title="string-based implementation of Store interface">StringStore</a> store(input, len);
<a name="l03189"></a>03189 OpenPGPDecode(store);
<a name="l03190"></a>03190 }
<a name="l03191"></a>03191
<a name="l03192"></a>03192 <span class="keywordtype">void</span> Integer::OpenPGPDecode(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)
<a name="l03193"></a>03193 {
<a name="l03194"></a>03194 word16 bitCount;
<a name="l03195"></a>03195 <span class="keywordflow">if</span> (bt.<a class="code" href="class_buffered_transformation.html#a1ac50bcb2d279c3c6aef6858dab3eeb7" title="try to retrieve a 16-bit word">GetWord16</a>(bitCount) != 2 || bt.<a class="code" href="class_buffered_transformation.html#a6ec48acd2d2bda08baa4baa1c9a8a99c" title="returns number of bytes that is currently ready for retrieval">MaxRetrievable</a>() < BitsToBytes(bitCount))
<a name="l03196"></a>03196 <span class="keywordflow">throw</span> OpenPGPDecodeErr();
<a name="l03197"></a>03197 Decode(bt, BitsToBytes(bitCount));
<a name="l03198"></a>03198 }
<a name="l03199"></a>03199
<a name="l03200"></a>03200 <span class="keywordtype">void</span> Integer::Randomize(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng, <span class="keywordtype">size_t</span> nbits)
<a name="l03201"></a>03201 {
<a name="l03202"></a>03202 <span class="keyword">const</span> <span class="keywordtype">size_t</span> nbytes = nbits/8 + 1;
<a name="l03203"></a>03203 <a class="code" href="class_sec_block.html" title="a block of memory allocated using A">SecByteBlock</a> buf(nbytes);
<a name="l03204"></a>03204 rng.<a class="code" href="class_random_number_generator.html#a497145546d24e6d4abaf10b7e0f1ba17" title="generate random array of bytes">GenerateBlock</a>(buf, nbytes);
<a name="l03205"></a>03205 <span class="keywordflow">if</span> (nbytes)
<a name="l03206"></a>03206 buf[0] = (byte)Crop(buf[0], nbits % 8);
<a name="l03207"></a>03207 Decode(buf, nbytes, UNSIGNED);
<a name="l03208"></a>03208 }
<a name="l03209"></a>03209
<a name="l03210"></a>03210 <span class="keywordtype">void</span> Integer::Randomize(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &min, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &max)
<a name="l03211"></a>03211 {
<a name="l03212"></a>03212 <span class="keywordflow">if</span> (min > max)
<a name="l03213"></a>03213 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"Integer: Min must be no greater than Max"</span>);
<a name="l03214"></a>03214
<a name="l03215"></a>03215 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> range = max - min;
<a name="l03216"></a>03216 <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nbits = range.<a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d" title="number of significant bits = floor(log2(abs(*this))) + 1">BitCount</a>();
<a name="l03217"></a>03217
<a name="l03218"></a>03218 <span class="keywordflow">do</span>
<a name="l03219"></a>03219 {
<a name="l03220"></a>03220 Randomize(rng, nbits);
<a name="l03221"></a>03221 }
<a name="l03222"></a>03222 <span class="keywordflow">while</span> (*<span class="keyword">this</span> > range);
<a name="l03223"></a>03223
<a name="l03224"></a>03224 *<span class="keyword">this</span> += min;
<a name="l03225"></a>03225 }
<a name="l03226"></a>03226
<a name="l03227"></a><a class="code" href="class_integer.html#a83dd6a11aa51d545ce2735777787b622">03227</a> <span class="keywordtype">bool</span> Integer::Randomize(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &min, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &max, RandomNumberType rnType, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &equiv, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &mod)
<a name="l03228"></a>03228 {
<a name="l03229"></a>03229 <span class="keywordflow">return</span> GenerateRandomNoThrow(rng, MakeParameters(<span class="stringliteral">"Min"</span>, min)(<span class="stringliteral">"Max"</span>, max)(<span class="stringliteral">"RandomNumberType"</span>, rnType)(<span class="stringliteral">"EquivalentTo"</span>, equiv)(<span class="stringliteral">"Mod"</span>, mod));
<a name="l03230"></a>03230 }
<a name="l03231"></a>03231
<a name="l03232"></a><a class="code" href="class_k_d_f2___r_n_g.html">03232</a> <span class="keyword">class </span><a class="code" href="class_k_d_f2___r_n_g.html">KDF2_RNG</a> : <span class="keyword">public</span> <a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a>
<a name="l03233"></a>03233 {
<a name="l03234"></a>03234 <span class="keyword">public</span>:
<a name="l03235"></a>03235 <a class="code" href="class_k_d_f2___r_n_g.html">KDF2_RNG</a>(<span class="keyword">const</span> byte *seed, <span class="keywordtype">size_t</span> seedSize)
<a name="l03236"></a>03236 : m_counter(0), m_counterAndSeed(seedSize + 4)
<a name="l03237"></a>03237 {
<a name="l03238"></a>03238 memcpy(m_counterAndSeed + 4, seed, seedSize);
<a name="l03239"></a>03239 }
<a name="l03240"></a>03240
<a name="l03241"></a><a class="code" href="class_k_d_f2___r_n_g.html#a4dc2d7c24fe10a3018e62e38e9c8daf6">03241</a> <span class="keywordtype">void</span> <a class="code" href="class_k_d_f2___r_n_g.html#a4dc2d7c24fe10a3018e62e38e9c8daf6" title="generate random array of bytes">GenerateBlock</a>(byte *output, <span class="keywordtype">size_t</span> size)
<a name="l03242"></a>03242 {
<a name="l03243"></a>03243 PutWord(<span class="keyword">false</span>, BIG_ENDIAN_ORDER, m_counterAndSeed, m_counter);
<a name="l03244"></a>03244 ++m_counter;
<a name="l03245"></a>03245 <a class="code" href="class_p1363___k_d_f2.html" title="_">P1363_KDF2<SHA1>::DeriveKey</a>(output, size, m_counterAndSeed, m_counterAndSeed.size(), NULL, 0);
<a name="l03246"></a>03246 }
<a name="l03247"></a>03247
<a name="l03248"></a>03248 <span class="keyword">private</span>:
<a name="l03249"></a>03249 word32 m_counter;
<a name="l03250"></a>03250 <a class="code" href="class_sec_block.html" title="a block of memory allocated using A">SecByteBlock</a> m_counterAndSeed;
<a name="l03251"></a>03251 };
<a name="l03252"></a>03252
<a name="l03253"></a>03253 <span class="keywordtype">bool</span> Integer::GenerateRandomNoThrow(<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &i_rng, <span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html" title="interface for retrieving values given their names">NameValuePairs</a> &params)
<a name="l03254"></a>03254 {
<a name="l03255"></a>03255 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> min = params.<a class="code" href="class_name_value_pairs.html#a943b2009297783f1c35bae46efc3b5f7" title="get a named value, returns the default if the name doesn't exist">GetValueWithDefault</a>(<span class="stringliteral">"Min"</span>, <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Integer::Zero</a>());
<a name="l03256"></a>03256 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> max;
<a name="l03257"></a>03257 <span class="keywordflow">if</span> (!params.<a class="code" href="class_name_value_pairs.html#a96686e9f8d6ce3ab870e516fb72b608e" title="get a named value, returns true if the name exists">GetValue</a>(<span class="stringliteral">"Max"</span>, max))
<a name="l03258"></a>03258 {
<a name="l03259"></a>03259 <span class="keywordtype">int</span> bitLength;
<a name="l03260"></a>03260 <span class="keywordflow">if</span> (params.<a class="code" href="class_name_value_pairs.html#a39b6daefcabcdd07f5ae482a075e1728" title="get a named value with type int">GetIntValue</a>(<span class="stringliteral">"BitLength"</span>, bitLength))
<a name="l03261"></a>03261 max = <a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Integer::Power2</a>(bitLength);
<a name="l03262"></a>03262 <span class="keywordflow">else</span>
<a name="l03263"></a>03263 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"Integer: missing Max argument"</span>);
<a name="l03264"></a>03264 }
<a name="l03265"></a>03265 <span class="keywordflow">if</span> (min > max)
<a name="l03266"></a>03266 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"Integer: Min must be no greater than Max"</span>);
<a name="l03267"></a>03267
<a name="l03268"></a>03268 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> equiv = params.<a class="code" href="class_name_value_pairs.html#a943b2009297783f1c35bae46efc3b5f7" title="get a named value, returns the default if the name doesn't exist">GetValueWithDefault</a>(<span class="stringliteral">"EquivalentTo"</span>, <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Integer::Zero</a>());
<a name="l03269"></a>03269 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> mod = params.<a class="code" href="class_name_value_pairs.html#a943b2009297783f1c35bae46efc3b5f7" title="get a named value, returns the default if the name doesn't exist">GetValueWithDefault</a>(<span class="stringliteral">"Mod"</span>, <a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">Integer::One</a>());
<a name="l03270"></a>03270
<a name="l03271"></a>03271 <span class="keywordflow">if</span> (equiv.IsNegative() || equiv >= mod)
<a name="l03272"></a>03272 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"Integer: invalid EquivalentTo and/or Mod argument"</span>);
<a name="l03273"></a>03273
<a name="l03274"></a>03274 Integer::RandomNumberType rnType = params.<a class="code" href="class_name_value_pairs.html#a943b2009297783f1c35bae46efc3b5f7" title="get a named value, returns the default if the name doesn't exist">GetValueWithDefault</a>(<span class="stringliteral">"RandomNumberType"</span>, Integer::ANY);
<a name="l03275"></a>03275
<a name="l03276"></a>03276 <a class="code" href="classmember__ptr.html">member_ptr<KDF2_RNG></a> kdf2Rng;
<a name="l03277"></a>03277 <a class="code" href="class_const_byte_array_parameter.html" title="used to pass byte array input as part of a NameValuePairs object">ConstByteArrayParameter</a> seed;
<a name="l03278"></a>03278 <span class="keywordflow">if</span> (params.<a class="code" href="class_name_value_pairs.html#a96686e9f8d6ce3ab870e516fb72b608e" title="get a named value, returns true if the name exists">GetValue</a>(<a class="code" href="namespace_name.html#af4d62c61a0b246395693744225519a2c" title="ConstByteArrayParameter.">Name::Seed</a>(), seed))
<a name="l03279"></a>03279 {
<a name="l03280"></a>03280 <a class="code" href="class_byte_queue.html" title="Byte Queue.">ByteQueue</a> bq;
<a name="l03281"></a>03281 <a class="code" href="class_d_e_r_sequence_encoder.html" title="DER Sequence Encoder.">DERSequenceEncoder</a> seq(bq);
<a name="l03282"></a>03282 min.<a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">DEREncode</a>(seq);
<a name="l03283"></a>03283 max.<a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">DEREncode</a>(seq);
<a name="l03284"></a>03284 equiv.<a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">DEREncode</a>(seq);
<a name="l03285"></a>03285 mod.<a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">DEREncode</a>(seq);
<a name="l03286"></a>03286 DEREncodeUnsigned(seq, rnType);
<a name="l03287"></a>03287 DEREncodeOctetString(seq, seed.begin(), seed.size());
<a name="l03288"></a>03288 seq.MessageEnd();
<a name="l03289"></a>03289
<a name="l03290"></a>03290 <a class="code" href="class_sec_block.html" title="a block of memory allocated using A">SecByteBlock</a> finalSeed((<span class="keywordtype">size_t</span>)bq.<a class="code" href="class_byte_queue.html#a56f851da4a1e9518c2b7005807aecab8" title="returns number of bytes that is currently ready for retrieval">MaxRetrievable</a>());
<a name="l03291"></a>03291 bq.<a class="code" href="class_byte_queue.html#a19413e3aa72b749e3771d617e8eca632" title="try to retrieve a single byte">Get</a>(finalSeed, finalSeed.size());
<a name="l03292"></a>03292 kdf2Rng.reset(<span class="keyword">new</span> <a class="code" href="class_k_d_f2___r_n_g.html">KDF2_RNG</a>(finalSeed.begin(), finalSeed.size()));
<a name="l03293"></a>03293 }
<a name="l03294"></a>03294 <a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &rng = kdf2Rng.get() ? (<a class="code" href="class_random_number_generator.html" title="interface for random number generators">RandomNumberGenerator</a> &)*kdf2Rng : i_rng;
<a name="l03295"></a>03295
<a name="l03296"></a>03296 <span class="keywordflow">switch</span> (rnType)
<a name="l03297"></a>03297 {
<a name="l03298"></a>03298 <span class="keywordflow">case</span> ANY:
<a name="l03299"></a>03299 <span class="keywordflow">if</span> (mod == <a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">One</a>())
<a name="l03300"></a>03300 Randomize(rng, min, max);
<a name="l03301"></a>03301 <span class="keywordflow">else</span>
<a name="l03302"></a>03302 {
<a name="l03303"></a>03303 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> min1 = min + (equiv-min)%mod;
<a name="l03304"></a>03304 <span class="keywordflow">if</span> (max < min1)
<a name="l03305"></a>03305 <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l03306"></a>03306 Randomize(rng, <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>(), (max - min1) / mod);
<a name="l03307"></a>03307 *<span class="keyword">this</span> *= mod;
<a name="l03308"></a>03308 *<span class="keyword">this</span> += min1;
<a name="l03309"></a>03309 }
<a name="l03310"></a>03310 <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l03311"></a>03311
<a name="l03312"></a>03312 <span class="keywordflow">case</span> PRIME:
<a name="l03313"></a>03313 {
<a name="l03314"></a>03314 <span class="keyword">const</span> <a class="code" href="class_prime_selector.html">PrimeSelector</a> *pSelector = params.<a class="code" href="class_name_value_pairs.html#a943b2009297783f1c35bae46efc3b5f7" title="get a named value, returns the default if the name doesn't exist">GetValueWithDefault</a>(<a class="code" href="namespace_name.html#a2c58f621e53639c1e9aebac364898756" title="const PrimeSelector *">Name::PointerToPrimeSelector</a>(), (<span class="keyword">const</span> <a class="code" href="class_prime_selector.html">PrimeSelector</a> *)NULL);
<a name="l03315"></a>03315
<a name="l03316"></a>03316 <span class="keywordtype">int</span> i;
<a name="l03317"></a>03317 i = 0;
<a name="l03318"></a>03318 <span class="keywordflow">while</span> (1)
<a name="l03319"></a>03319 {
<a name="l03320"></a>03320 <span class="keywordflow">if</span> (++i==16)
<a name="l03321"></a>03321 {
<a name="l03322"></a>03322 <span class="comment">// check if there are any suitable primes in [min, max]</span>
<a name="l03323"></a>03323 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> first = min;
<a name="l03324"></a>03324 <span class="keywordflow">if</span> (FirstPrime(first, max, equiv, mod, pSelector))
<a name="l03325"></a>03325 {
<a name="l03326"></a>03326 <span class="comment">// if there is only one suitable prime, we're done</span>
<a name="l03327"></a>03327 *<span class="keyword">this</span> = first;
<a name="l03328"></a>03328 <span class="keywordflow">if</span> (!FirstPrime(first, max, equiv, mod, pSelector))
<a name="l03329"></a>03329 <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l03330"></a>03330 }
<a name="l03331"></a>03331 <span class="keywordflow">else</span>
<a name="l03332"></a>03332 <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l03333"></a>03333 }
<a name="l03334"></a>03334
<a name="l03335"></a>03335 Randomize(rng, min, max);
<a name="l03336"></a>03336 <span class="keywordflow">if</span> (FirstPrime(*<span class="keyword">this</span>, STDMIN(*<span class="keyword">this</span>+mod*PrimeSearchInterval(max), max), equiv, mod, pSelector))
<a name="l03337"></a>03337 <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l03338"></a>03338 }
<a name="l03339"></a>03339 }
<a name="l03340"></a>03340
<a name="l03341"></a>03341 <span class="keywordflow">default</span>:
<a name="l03342"></a>03342 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"Integer: invalid RandomNumberType argument"</span>);
<a name="l03343"></a>03343 }
<a name="l03344"></a>03344 }
<a name="l03345"></a>03345
<a name="l03346"></a>03346 std::istream& operator>>(std::istream& in, <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)
<a name="l03347"></a>03347 {
<a name="l03348"></a>03348 <span class="keywordtype">char</span> c;
<a name="l03349"></a>03349 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> length = 0;
<a name="l03350"></a>03350 <a class="code" href="class_sec_block.html" title="a block of memory allocated using A">SecBlock<char></a> str(length + 16);
<a name="l03351"></a>03351
<a name="l03352"></a>03352 std::ws(in);
<a name="l03353"></a>03353
<a name="l03354"></a>03354 <span class="keywordflow">do</span>
<a name="l03355"></a>03355 {
<a name="l03356"></a>03356 in.read(&c, 1);
<a name="l03357"></a>03357 str[length++] = c;
<a name="l03358"></a>03358 <span class="keywordflow">if</span> (length >= str.size())
<a name="l03359"></a>03359 str.Grow(length + 16);
<a name="l03360"></a>03360 }
<a name="l03361"></a>03361 <span class="keywordflow">while</span> (in && (c==<span class="charliteral">'-'</span> || c==<span class="charliteral">'x'</span> || (c>=<span class="charliteral">'0'</span> && c<=<span class="charliteral">'9'</span>) || (c>=<span class="charliteral">'a'</span> && c<=<span class="charliteral">'f'</span>) || (c>=<span class="charliteral">'A'</span> && c<=<span class="charliteral">'F'</span>) || c==<span class="charliteral">'h'</span> || c==<span class="charliteral">'H'</span> || c==<span class="charliteral">'o'</span> || c==<span class="charliteral">'O'</span> || c==<span class="charliteral">','</span> || c==<span class="charliteral">'.'</span>));
<a name="l03362"></a>03362
<a name="l03363"></a>03363 <span class="keywordflow">if</span> (in.gcount())
<a name="l03364"></a>03364 in.putback(c);
<a name="l03365"></a>03365 str[length-1] = <span class="charliteral">'\0'</span>;
<a name="l03366"></a>03366 a = <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>(str);
<a name="l03367"></a>03367
<a name="l03368"></a>03368 <span class="keywordflow">return</span> in;
<a name="l03369"></a>03369 }
<a name="l03370"></a>03370
<a name="l03371"></a>03371 std::ostream& operator<<(std::ostream& out, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)
<a name="l03372"></a>03372 {
<a name="l03373"></a>03373 <span class="comment">// Get relevant conversion specifications from ostream.</span>
<a name="l03374"></a>03374 <span class="keywordtype">long</span> f = out.flags() & std::ios::basefield; <span class="comment">// Get base digits.</span>
<a name="l03375"></a>03375 <span class="keywordtype">int</span> base, block;
<a name="l03376"></a>03376 <span class="keywordtype">char</span> suffix;
<a name="l03377"></a>03377 <span class="keywordflow">switch</span>(f)
<a name="l03378"></a>03378 {
<a name="l03379"></a>03379 <span class="keywordflow">case</span> std::ios::oct :
<a name="l03380"></a>03380 base = 8;
<a name="l03381"></a>03381 block = 8;
<a name="l03382"></a>03382 suffix = <span class="charliteral">'o'</span>;
<a name="l03383"></a>03383 <span class="keywordflow">break</span>;
<a name="l03384"></a>03384 <span class="keywordflow">case</span> std::ios::hex :
<a name="l03385"></a>03385 base = 16;
<a name="l03386"></a>03386 block = 4;
<a name="l03387"></a>03387 suffix = <span class="charliteral">'h'</span>;
<a name="l03388"></a>03388 <span class="keywordflow">break</span>;
<a name="l03389"></a>03389 <span class="keywordflow">default</span> :
<a name="l03390"></a>03390 base = 10;
<a name="l03391"></a>03391 block = 3;
<a name="l03392"></a>03392 suffix = <span class="charliteral">'.'</span>;
<a name="l03393"></a>03393 }
<a name="l03394"></a>03394
<a name="l03395"></a>03395 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> temp1=a, temp2;
<a name="l03396"></a>03396
<a name="l03397"></a>03397 <span class="keywordflow">if</span> (a.IsNegative())
<a name="l03398"></a>03398 {
<a name="l03399"></a>03399 out << <span class="charliteral">'-'</span>;
<a name="l03400"></a>03400 temp1.Negate();
<a name="l03401"></a>03401 }
<a name="l03402"></a>03402
<a name="l03403"></a>03403 <span class="keywordflow">if</span> (!a)
<a name="l03404"></a>03404 out << <span class="charliteral">'0'</span>;
<a name="l03405"></a>03405
<a name="l03406"></a>03406 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> upper[]=<span class="stringliteral">"0123456789ABCDEF"</span>;
<a name="l03407"></a>03407 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> lower[]=<span class="stringliteral">"0123456789abcdef"</span>;
<a name="l03408"></a>03408
<a name="l03409"></a>03409 <span class="keyword">const</span> <span class="keywordtype">char</span>* vec = (out.flags() & std::ios::uppercase) ? upper : lower;
<a name="l03410"></a>03410 <span class="keywordtype">unsigned</span> i=0;
<a name="l03411"></a>03411 <a class="code" href="class_sec_block.html" title="a block of memory allocated using A">SecBlock<char></a> s(a.<a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d" title="number of significant bits = floor(log2(abs(*this))) + 1">BitCount</a>() / (BitPrecision(base)-1) + 1);
<a name="l03412"></a>03412
<a name="l03413"></a>03413 <span class="keywordflow">while</span> (!!temp1)
<a name="l03414"></a>03414 {
<a name="l03415"></a>03415 word digit;
<a name="l03416"></a>03416 <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(digit, temp2, temp1, base);
<a name="l03417"></a>03417 s[i++]=vec[digit];
<a name="l03418"></a>03418 temp1.swap(temp2);
<a name="l03419"></a>03419 }
<a name="l03420"></a>03420
<a name="l03421"></a>03421 <span class="keywordflow">while</span> (i--)
<a name="l03422"></a>03422 {
<a name="l03423"></a>03423 out << s[i];
<a name="l03424"></a>03424 <span class="comment">// if (i && !(i%block))</span>
<a name="l03425"></a>03425 <span class="comment">// out << ",";</span>
<a name="l03426"></a>03426 }
<a name="l03427"></a>03427 <span class="keywordflow">return</span> out << suffix;
<a name="l03428"></a>03428 }
<a name="l03429"></a>03429
<a name="l03430"></a>03430 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator++()
<a name="l03431"></a>03431 {
<a name="l03432"></a>03432 <span class="keywordflow">if</span> (NotNegative())
<a name="l03433"></a>03433 {
<a name="l03434"></a>03434 <span class="keywordflow">if</span> (Increment(reg, reg.size()))
<a name="l03435"></a>03435 {
<a name="l03436"></a>03436 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(2*reg.size());
<a name="l03437"></a>03437 reg[reg.size()/2]=1;
<a name="l03438"></a>03438 }
<a name="l03439"></a>03439 }
<a name="l03440"></a>03440 <span class="keywordflow">else</span>
<a name="l03441"></a>03441 {
<a name="l03442"></a>03442 word borrow = Decrement(reg, reg.size());
<a name="l03443"></a>03443 assert(!borrow);
<a name="l03444"></a>03444 <span class="keywordflow">if</span> (<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>()==0)
<a name="l03445"></a>03445 *<span class="keyword">this</span> = <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>();
<a name="l03446"></a>03446 }
<a name="l03447"></a>03447 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03448"></a>03448 }
<a name="l03449"></a>03449
<a name="l03450"></a>03450 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator--()
<a name="l03451"></a>03451 {
<a name="l03452"></a>03452 <span class="keywordflow">if</span> (IsNegative())
<a name="l03453"></a>03453 {
<a name="l03454"></a>03454 <span class="keywordflow">if</span> (Increment(reg, reg.size()))
<a name="l03455"></a>03455 {
<a name="l03456"></a>03456 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(2*reg.size());
<a name="l03457"></a>03457 reg[reg.size()/2]=1;
<a name="l03458"></a>03458 }
<a name="l03459"></a>03459 }
<a name="l03460"></a>03460 <span class="keywordflow">else</span>
<a name="l03461"></a>03461 {
<a name="l03462"></a>03462 <span class="keywordflow">if</span> (Decrement(reg, reg.size()))
<a name="l03463"></a>03463 *<span class="keyword">this</span> = -<a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">One</a>();
<a name="l03464"></a>03464 }
<a name="l03465"></a>03465 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03466"></a>03466 }
<a name="l03467"></a>03467
<a name="l03468"></a>03468 <span class="keywordtype">void</span> PositiveAdd(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &sum, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& b)
<a name="l03469"></a>03469 {
<a name="l03470"></a>03470 <span class="keywordtype">int</span> carry;
<a name="l03471"></a>03471 <span class="keywordflow">if</span> (a.reg.size() == b.reg.size())
<a name="l03472"></a>03472 carry = Add(sum.reg, a.reg, b.reg, a.reg.size());
<a name="l03473"></a>03473 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (a.reg.size() > b.reg.size())
<a name="l03474"></a>03474 {
<a name="l03475"></a>03475 carry = Add(sum.reg, a.reg, b.reg, b.reg.size());
<a name="l03476"></a>03476 CopyWords(sum.reg+b.reg.size(), a.reg+b.reg.size(), a.reg.size()-b.reg.size());
<a name="l03477"></a>03477 carry = Increment(sum.reg+b.reg.size(), a.reg.size()-b.reg.size(), carry);
<a name="l03478"></a>03478 }
<a name="l03479"></a>03479 <span class="keywordflow">else</span>
<a name="l03480"></a>03480 {
<a name="l03481"></a>03481 carry = Add(sum.reg, a.reg, b.reg, a.reg.size());
<a name="l03482"></a>03482 CopyWords(sum.reg+a.reg.size(), b.reg+a.reg.size(), b.reg.size()-a.reg.size());
<a name="l03483"></a>03483 carry = Increment(sum.reg+a.reg.size(), b.reg.size()-a.reg.size(), carry);
<a name="l03484"></a>03484 }
<a name="l03485"></a>03485
<a name="l03486"></a>03486 <span class="keywordflow">if</span> (carry)
<a name="l03487"></a>03487 {
<a name="l03488"></a>03488 sum.reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(2*sum.reg.size());
<a name="l03489"></a>03489 sum.reg[sum.reg.size()/2] = 1;
<a name="l03490"></a>03490 }
<a name="l03491"></a>03491 sum.sign = Integer::POSITIVE;
<a name="l03492"></a>03492 }
<a name="l03493"></a>03493
<a name="l03494"></a>03494 <span class="keywordtype">void</span> PositiveSubtract(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &diff, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& b)
<a name="l03495"></a>03495 {
<a name="l03496"></a>03496 <span class="keywordtype">unsigned</span> aSize = a.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03497"></a>03497 aSize += aSize%2;
<a name="l03498"></a>03498 <span class="keywordtype">unsigned</span> bSize = b.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03499"></a>03499 bSize += bSize%2;
<a name="l03500"></a>03500
<a name="l03501"></a>03501 <span class="keywordflow">if</span> (aSize == bSize)
<a name="l03502"></a>03502 {
<a name="l03503"></a>03503 <span class="keywordflow">if</span> (Compare(a.reg, b.reg, aSize) >= 0)
<a name="l03504"></a>03504 {
<a name="l03505"></a>03505 Subtract(diff.reg, a.reg, b.reg, aSize);
<a name="l03506"></a>03506 diff.sign = Integer::POSITIVE;
<a name="l03507"></a>03507 }
<a name="l03508"></a>03508 <span class="keywordflow">else</span>
<a name="l03509"></a>03509 {
<a name="l03510"></a>03510 Subtract(diff.reg, b.reg, a.reg, aSize);
<a name="l03511"></a>03511 diff.sign = Integer::NEGATIVE;
<a name="l03512"></a>03512 }
<a name="l03513"></a>03513 }
<a name="l03514"></a>03514 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (aSize > bSize)
<a name="l03515"></a>03515 {
<a name="l03516"></a>03516 word borrow = Subtract(diff.reg, a.reg, b.reg, bSize);
<a name="l03517"></a>03517 CopyWords(diff.reg+bSize, a.reg+bSize, aSize-bSize);
<a name="l03518"></a>03518 borrow = Decrement(diff.reg+bSize, aSize-bSize, borrow);
<a name="l03519"></a>03519 assert(!borrow);
<a name="l03520"></a>03520 diff.sign = Integer::POSITIVE;
<a name="l03521"></a>03521 }
<a name="l03522"></a>03522 <span class="keywordflow">else</span>
<a name="l03523"></a>03523 {
<a name="l03524"></a>03524 word borrow = Subtract(diff.reg, b.reg, a.reg, aSize);
<a name="l03525"></a>03525 CopyWords(diff.reg+aSize, b.reg+aSize, bSize-aSize);
<a name="l03526"></a>03526 borrow = Decrement(diff.reg+aSize, bSize-aSize, borrow);
<a name="l03527"></a>03527 assert(!borrow);
<a name="l03528"></a>03528 diff.sign = Integer::NEGATIVE;
<a name="l03529"></a>03529 }
<a name="l03530"></a>03530 }
<a name="l03531"></a>03531
<a name="l03532"></a>03532 <span class="comment">// MSVC .NET 2003 workaround</span>
<a name="l03533"></a>03533 <span class="keyword">template</span> <<span class="keyword">class</span> T> <span class="keyword">inline</span> <span class="keyword">const</span> T& STDMAX2(<span class="keyword">const</span> T& a, <span class="keyword">const</span> T& b)
<a name="l03534"></a>03534 {
<a name="l03535"></a>03535 <span class="keywordflow">return</span> a < b ? b : a;
<a name="l03536"></a>03536 }
<a name="l03537"></a>03537
<a name="l03538"></a>03538 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::Plus(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& b)<span class="keyword"> const</span>
<a name="l03539"></a>03539 <span class="keyword"></span>{
<a name="l03540"></a>03540 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> sum((word)0, STDMAX2(reg.size(), b.reg.size()));
<a name="l03541"></a>03541 <span class="keywordflow">if</span> (NotNegative())
<a name="l03542"></a>03542 {
<a name="l03543"></a>03543 <span class="keywordflow">if</span> (b.NotNegative())
<a name="l03544"></a>03544 PositiveAdd(sum, *<span class="keyword">this</span>, b);
<a name="l03545"></a>03545 <span class="keywordflow">else</span>
<a name="l03546"></a>03546 PositiveSubtract(sum, *<span class="keyword">this</span>, b);
<a name="l03547"></a>03547 }
<a name="l03548"></a>03548 <span class="keywordflow">else</span>
<a name="l03549"></a>03549 {
<a name="l03550"></a>03550 <span class="keywordflow">if</span> (b.NotNegative())
<a name="l03551"></a>03551 PositiveSubtract(sum, b, *<span class="keyword">this</span>);
<a name="l03552"></a>03552 <span class="keywordflow">else</span>
<a name="l03553"></a>03553 {
<a name="l03554"></a>03554 PositiveAdd(sum, *<span class="keyword">this</span>, b);
<a name="l03555"></a>03555 sum.sign = Integer::NEGATIVE;
<a name="l03556"></a>03556 }
<a name="l03557"></a>03557 }
<a name="l03558"></a>03558 <span class="keywordflow">return</span> sum;
<a name="l03559"></a>03559 }
<a name="l03560"></a>03560
<a name="l03561"></a>03561 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator+=(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)
<a name="l03562"></a>03562 {
<a name="l03563"></a>03563 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(t.reg.size());
<a name="l03564"></a>03564 <span class="keywordflow">if</span> (NotNegative())
<a name="l03565"></a>03565 {
<a name="l03566"></a>03566 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03567"></a>03567 PositiveAdd(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03568"></a>03568 <span class="keywordflow">else</span>
<a name="l03569"></a>03569 PositiveSubtract(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03570"></a>03570 }
<a name="l03571"></a>03571 <span class="keywordflow">else</span>
<a name="l03572"></a>03572 {
<a name="l03573"></a>03573 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03574"></a>03574 PositiveSubtract(*<span class="keyword">this</span>, t, *<span class="keyword">this</span>);
<a name="l03575"></a>03575 <span class="keywordflow">else</span>
<a name="l03576"></a>03576 {
<a name="l03577"></a>03577 PositiveAdd(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03578"></a>03578 sign = Integer::NEGATIVE;
<a name="l03579"></a>03579 }
<a name="l03580"></a>03580 }
<a name="l03581"></a>03581 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03582"></a>03582 }
<a name="l03583"></a>03583
<a name="l03584"></a>03584 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::Minus(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& b)<span class="keyword"> const</span>
<a name="l03585"></a>03585 <span class="keyword"></span>{
<a name="l03586"></a>03586 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> diff((word)0, STDMAX2(reg.size(), b.reg.size()));
<a name="l03587"></a>03587 <span class="keywordflow">if</span> (NotNegative())
<a name="l03588"></a>03588 {
<a name="l03589"></a>03589 <span class="keywordflow">if</span> (b.NotNegative())
<a name="l03590"></a>03590 PositiveSubtract(diff, *<span class="keyword">this</span>, b);
<a name="l03591"></a>03591 <span class="keywordflow">else</span>
<a name="l03592"></a>03592 PositiveAdd(diff, *<span class="keyword">this</span>, b);
<a name="l03593"></a>03593 }
<a name="l03594"></a>03594 <span class="keywordflow">else</span>
<a name="l03595"></a>03595 {
<a name="l03596"></a>03596 <span class="keywordflow">if</span> (b.NotNegative())
<a name="l03597"></a>03597 {
<a name="l03598"></a>03598 PositiveAdd(diff, *<span class="keyword">this</span>, b);
<a name="l03599"></a>03599 diff.sign = Integer::NEGATIVE;
<a name="l03600"></a>03600 }
<a name="l03601"></a>03601 <span class="keywordflow">else</span>
<a name="l03602"></a>03602 PositiveSubtract(diff, b, *<span class="keyword">this</span>);
<a name="l03603"></a>03603 }
<a name="l03604"></a>03604 <span class="keywordflow">return</span> diff;
<a name="l03605"></a>03605 }
<a name="l03606"></a>03606
<a name="l03607"></a>03607 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator-=(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)
<a name="l03608"></a>03608 {
<a name="l03609"></a>03609 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(t.reg.size());
<a name="l03610"></a>03610 <span class="keywordflow">if</span> (NotNegative())
<a name="l03611"></a>03611 {
<a name="l03612"></a>03612 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03613"></a>03613 PositiveSubtract(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03614"></a>03614 <span class="keywordflow">else</span>
<a name="l03615"></a>03615 PositiveAdd(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03616"></a>03616 }
<a name="l03617"></a>03617 <span class="keywordflow">else</span>
<a name="l03618"></a>03618 {
<a name="l03619"></a>03619 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03620"></a>03620 {
<a name="l03621"></a>03621 PositiveAdd(*<span class="keyword">this</span>, *<span class="keyword">this</span>, t);
<a name="l03622"></a>03622 sign = Integer::NEGATIVE;
<a name="l03623"></a>03623 }
<a name="l03624"></a>03624 <span class="keywordflow">else</span>
<a name="l03625"></a>03625 PositiveSubtract(*<span class="keyword">this</span>, t, *<span class="keyword">this</span>);
<a name="l03626"></a>03626 }
<a name="l03627"></a>03627 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03628"></a>03628 }
<a name="l03629"></a>03629
<a name="l03630"></a>03630 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator<<=(<span class="keywordtype">size_t</span> n)
<a name="l03631"></a>03631 {
<a name="l03632"></a>03632 <span class="keyword">const</span> <span class="keywordtype">size_t</span> wordCount = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03633"></a>03633 <span class="keyword">const</span> <span class="keywordtype">size_t</span> shiftWords = n / WORD_BITS;
<a name="l03634"></a>03634 <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> shiftBits = (<span class="keywordtype">unsigned</span> int)(n % WORD_BITS);
<a name="l03635"></a>03635
<a name="l03636"></a>03636 reg.<a class="code" href="class_sec_block.html#a4ef9516e973051e6afa38bba526da3e9" title="change size only if newSize > current size. contents are preserved and additional area is set to 0...">CleanGrow</a>(RoundupSize(wordCount+BitsToWords(n)));
<a name="l03637"></a>03637 ShiftWordsLeftByWords(reg, wordCount + shiftWords, shiftWords);
<a name="l03638"></a>03638 ShiftWordsLeftByBits(reg+shiftWords, wordCount+BitsToWords(shiftBits), shiftBits);
<a name="l03639"></a>03639 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03640"></a>03640 }
<a name="l03641"></a>03641
<a name="l03642"></a>03642 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& Integer::operator>>=(<span class="keywordtype">size_t</span> n)
<a name="l03643"></a>03643 {
<a name="l03644"></a>03644 <span class="keyword">const</span> <span class="keywordtype">size_t</span> wordCount = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03645"></a>03645 <span class="keyword">const</span> <span class="keywordtype">size_t</span> shiftWords = n / WORD_BITS;
<a name="l03646"></a>03646 <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> shiftBits = (<span class="keywordtype">unsigned</span> int)(n % WORD_BITS);
<a name="l03647"></a>03647
<a name="l03648"></a>03648 ShiftWordsRightByWords(reg, wordCount, shiftWords);
<a name="l03649"></a>03649 <span class="keywordflow">if</span> (wordCount > shiftWords)
<a name="l03650"></a>03650 ShiftWordsRightByBits(reg, wordCount-shiftWords, shiftBits);
<a name="l03651"></a>03651 <span class="keywordflow">if</span> (IsNegative() && <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>()==0) <span class="comment">// avoid -0</span>
<a name="l03652"></a>03652 *<span class="keyword">this</span> = <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>();
<a name="l03653"></a>03653 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
<a name="l03654"></a>03654 }
<a name="l03655"></a>03655
<a name="l03656"></a>03656 <span class="keywordtype">void</span> PositiveMultiply(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &product, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)
<a name="l03657"></a>03657 {
<a name="l03658"></a>03658 <span class="keywordtype">size_t</span> aSize = RoundupSize(a.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>());
<a name="l03659"></a>03659 <span class="keywordtype">size_t</span> bSize = RoundupSize(b.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>());
<a name="l03660"></a>03660
<a name="l03661"></a>03661 product.reg.<a class="code" href="class_sec_block.html#a2d78e75002fd02e5b89bd72a9e65e769" title="change size and set contents to 0">CleanNew</a>(RoundupSize(aSize+bSize));
<a name="l03662"></a>03662 product.sign = Integer::POSITIVE;
<a name="l03663"></a>03663
<a name="l03664"></a>03664 <a class="code" href="class_sec_block.html">IntegerSecBlock</a> workspace(aSize + bSize);
<a name="l03665"></a>03665 AsymmetricMultiply(product.reg, workspace, a.reg, aSize, b.reg, bSize);
<a name="l03666"></a>03666 }
<a name="l03667"></a>03667
<a name="l03668"></a>03668 <span class="keywordtype">void</span> Multiply(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &product, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)
<a name="l03669"></a>03669 {
<a name="l03670"></a>03670 PositiveMultiply(product, a, b);
<a name="l03671"></a>03671
<a name="l03672"></a>03672 <span class="keywordflow">if</span> (a.NotNegative() != b.NotNegative())
<a name="l03673"></a>03673 product.Negate();
<a name="l03674"></a>03674 }
<a name="l03675"></a>03675
<a name="l03676"></a>03676 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::Times(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l03677"></a>03677 <span class="keyword"></span>{
<a name="l03678"></a>03678 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> product;
<a name="l03679"></a>03679 Multiply(product, *<span class="keyword">this</span>, b);
<a name="l03680"></a>03680 <span class="keywordflow">return</span> product;
<a name="l03681"></a>03681 }
<a name="l03682"></a>03682
<a name="l03683"></a>03683 <span class="comment">/*</span>
<a name="l03684"></a>03684 <span class="comment">void PositiveDivide(Integer &remainder, Integer &quotient,</span>
<a name="l03685"></a>03685 <span class="comment"> const Integer &dividend, const Integer &divisor)</span>
<a name="l03686"></a>03686 <span class="comment">{</span>
<a name="l03687"></a>03687 <span class="comment"> remainder.reg.CleanNew(divisor.reg.size());</span>
<a name="l03688"></a>03688 <span class="comment"> remainder.sign = Integer::POSITIVE;</span>
<a name="l03689"></a>03689 <span class="comment"> quotient.reg.New(0);</span>
<a name="l03690"></a>03690 <span class="comment"> quotient.sign = Integer::POSITIVE;</span>
<a name="l03691"></a>03691 <span class="comment"> unsigned i=dividend.BitCount();</span>
<a name="l03692"></a>03692 <span class="comment"> while (i--)</span>
<a name="l03693"></a>03693 <span class="comment"> {</span>
<a name="l03694"></a>03694 <span class="comment"> word overflow = ShiftWordsLeftByBits(remainder.reg, remainder.reg.size(), 1);</span>
<a name="l03695"></a>03695 <span class="comment"> remainder.reg[0] |= dividend[i];</span>
<a name="l03696"></a>03696 <span class="comment"> if (overflow || remainder >= divisor)</span>
<a name="l03697"></a>03697 <span class="comment"> {</span>
<a name="l03698"></a>03698 <span class="comment"> Subtract(remainder.reg, remainder.reg, divisor.reg, remainder.reg.size());</span>
<a name="l03699"></a>03699 <span class="comment"> quotient.SetBit(i);</span>
<a name="l03700"></a>03700 <span class="comment"> }</span>
<a name="l03701"></a>03701 <span class="comment"> }</span>
<a name="l03702"></a>03702 <span class="comment">}</span>
<a name="l03703"></a>03703 <span class="comment">*/</span>
<a name="l03704"></a>03704
<a name="l03705"></a>03705 <span class="keywordtype">void</span> PositiveDivide(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &remainder, <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &quotient,
<a name="l03706"></a>03706 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)
<a name="l03707"></a>03707 {
<a name="l03708"></a>03708 <span class="keywordtype">unsigned</span> aSize = a.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03709"></a>03709 <span class="keywordtype">unsigned</span> bSize = b.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03710"></a>03710
<a name="l03711"></a>03711 <span class="keywordflow">if</span> (!bSize)
<a name="l03712"></a>03712 <span class="keywordflow">throw</span> <a class="code" href="class_integer_1_1_divide_by_zero.html" title="division by zero exception">Integer::DivideByZero</a>();
<a name="l03713"></a>03713
<a name="l03714"></a>03714 <span class="keywordflow">if</span> (aSize < bSize)
<a name="l03715"></a>03715 {
<a name="l03716"></a>03716 remainder = a;
<a name="l03717"></a>03717 remainder.sign = Integer::POSITIVE;
<a name="l03718"></a>03718 quotient = <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Integer::Zero</a>();
<a name="l03719"></a>03719 <span class="keywordflow">return</span>;
<a name="l03720"></a>03720 }
<a name="l03721"></a>03721
<a name="l03722"></a>03722 aSize += aSize%2; <span class="comment">// round up to next even number</span>
<a name="l03723"></a>03723 bSize += bSize%2;
<a name="l03724"></a>03724
<a name="l03725"></a>03725 remainder.reg.<a class="code" href="class_sec_block.html#a2d78e75002fd02e5b89bd72a9e65e769" title="change size and set contents to 0">CleanNew</a>(RoundupSize(bSize));
<a name="l03726"></a>03726 remainder.sign = Integer::POSITIVE;
<a name="l03727"></a>03727 quotient.reg.<a class="code" href="class_sec_block.html#a2d78e75002fd02e5b89bd72a9e65e769" title="change size and set contents to 0">CleanNew</a>(RoundupSize(aSize-bSize+2));
<a name="l03728"></a>03728 quotient.sign = Integer::POSITIVE;
<a name="l03729"></a>03729
<a name="l03730"></a>03730 <a class="code" href="class_sec_block.html">IntegerSecBlock</a> T(aSize+3*(bSize+2));
<a name="l03731"></a>03731 Divide(remainder.reg, quotient.reg, T, a.reg, aSize, b.reg, bSize);
<a name="l03732"></a>03732 }
<a name="l03733"></a>03733
<a name="l03734"></a><a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb">03734</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &remainder, <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &quotient, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &dividend, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &divisor)
<a name="l03735"></a>03735 {
<a name="l03736"></a>03736 PositiveDivide(remainder, quotient, dividend, divisor);
<a name="l03737"></a>03737
<a name="l03738"></a>03738 <span class="keywordflow">if</span> (dividend.IsNegative())
<a name="l03739"></a>03739 {
<a name="l03740"></a>03740 quotient.Negate();
<a name="l03741"></a>03741 <span class="keywordflow">if</span> (remainder.NotZero())
<a name="l03742"></a>03742 {
<a name="l03743"></a>03743 --quotient;
<a name="l03744"></a>03744 remainder = divisor.AbsoluteValue() - remainder;
<a name="l03745"></a>03745 }
<a name="l03746"></a>03746 }
<a name="l03747"></a>03747
<a name="l03748"></a>03748 <span class="keywordflow">if</span> (divisor.IsNegative())
<a name="l03749"></a>03749 quotient.Negate();
<a name="l03750"></a>03750 }
<a name="l03751"></a>03751
<a name="l03752"></a><a class="code" href="class_integer.html#abf2934a6172b4cb5317874f0c993a420">03752</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#abf2934a6172b4cb5317874f0c993a420" title="returns same result as Divide(r, q, a, Power2(n)), but faster">Integer::DivideByPowerOf2</a>(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &r, <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &q, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> n)
<a name="l03753"></a>03753 {
<a name="l03754"></a>03754 q = a;
<a name="l03755"></a>03755 q >>= n;
<a name="l03756"></a>03756
<a name="l03757"></a>03757 <span class="keyword">const</span> <span class="keywordtype">size_t</span> wordCount = BitsToWords(n);
<a name="l03758"></a>03758 <span class="keywordflow">if</span> (wordCount <= a.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>())
<a name="l03759"></a>03759 {
<a name="l03760"></a>03760 r.reg.<a class="code" href="class_sec_block.html#af9e98d3f4a7af1156fcf3e6e68f4ae5a" title="change size and preserve contents">resize</a>(RoundupSize(wordCount));
<a name="l03761"></a>03761 CopyWords(r.reg, a.reg, wordCount);
<a name="l03762"></a>03762 SetWords(r.reg+wordCount, 0, r.reg.size()-wordCount);
<a name="l03763"></a>03763 <span class="keywordflow">if</span> (n % WORD_BITS != 0)
<a name="l03764"></a>03764 r.reg[wordCount-1] %= (word(1) << (n % WORD_BITS));
<a name="l03765"></a>03765 }
<a name="l03766"></a>03766 <span class="keywordflow">else</span>
<a name="l03767"></a>03767 {
<a name="l03768"></a>03768 r.reg.<a class="code" href="class_sec_block.html#af9e98d3f4a7af1156fcf3e6e68f4ae5a" title="change size and preserve contents">resize</a>(RoundupSize(a.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>()));
<a name="l03769"></a>03769 CopyWords(r.reg, a.reg, r.reg.size());
<a name="l03770"></a>03770 }
<a name="l03771"></a>03771 r.sign = POSITIVE;
<a name="l03772"></a>03772
<a name="l03773"></a>03773 <span class="keywordflow">if</span> (a.IsNegative() && r.NotZero())
<a name="l03774"></a>03774 {
<a name="l03775"></a>03775 --q;
<a name="l03776"></a>03776 r = <a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Power2</a>(n) - r;
<a name="l03777"></a>03777 }
<a name="l03778"></a>03778 }
<a name="l03779"></a>03779
<a name="l03780"></a>03780 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::DividedBy(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l03781"></a>03781 <span class="keyword"></span>{
<a name="l03782"></a>03782 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> remainder, quotient;
<a name="l03783"></a>03783 <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(remainder, quotient, *<span class="keyword">this</span>, b);
<a name="l03784"></a>03784 <span class="keywordflow">return</span> quotient;
<a name="l03785"></a>03785 }
<a name="l03786"></a>03786
<a name="l03787"></a>03787 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::Modulo(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l03788"></a>03788 <span class="keyword"></span>{
<a name="l03789"></a>03789 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> remainder, quotient;
<a name="l03790"></a>03790 <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(remainder, quotient, *<span class="keyword">this</span>, b);
<a name="l03791"></a>03791 <span class="keywordflow">return</span> remainder;
<a name="l03792"></a>03792 }
<a name="l03793"></a>03793
<a name="l03794"></a><a class="code" href="class_integer.html#a1849c5a8af28ab4f3a70d9690924f249">03794</a> <span class="keywordtype">void</span> <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(word &remainder, <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &quotient, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &dividend, word divisor)
<a name="l03795"></a>03795 {
<a name="l03796"></a>03796 <span class="keywordflow">if</span> (!divisor)
<a name="l03797"></a>03797 <span class="keywordflow">throw</span> <a class="code" href="class_integer_1_1_divide_by_zero.html" title="division by zero exception">Integer::DivideByZero</a>();
<a name="l03798"></a>03798
<a name="l03799"></a>03799 assert(divisor);
<a name="l03800"></a>03800
<a name="l03801"></a>03801 <span class="keywordflow">if</span> ((divisor & (divisor-1)) == 0) <span class="comment">// divisor is a power of 2</span>
<a name="l03802"></a>03802 {
<a name="l03803"></a>03803 quotient = dividend >> (BitPrecision(divisor)-1);
<a name="l03804"></a>03804 remainder = dividend.reg[0] & (divisor-1);
<a name="l03805"></a>03805 <span class="keywordflow">return</span>;
<a name="l03806"></a>03806 }
<a name="l03807"></a>03807
<a name="l03808"></a>03808 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i = dividend.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03809"></a>03809 quotient.reg.<a class="code" href="class_sec_block.html#a2d78e75002fd02e5b89bd72a9e65e769" title="change size and set contents to 0">CleanNew</a>(RoundupSize(i));
<a name="l03810"></a>03810 remainder = 0;
<a name="l03811"></a>03811 <span class="keywordflow">while</span> (i--)
<a name="l03812"></a>03812 {
<a name="l03813"></a>03813 quotient.reg[i] = <a class="code" href="class_d_word.html">DWord</a>(dividend.reg[i], remainder) / divisor;
<a name="l03814"></a>03814 remainder = <a class="code" href="class_d_word.html">DWord</a>(dividend.reg[i], remainder) % divisor;
<a name="l03815"></a>03815 }
<a name="l03816"></a>03816
<a name="l03817"></a>03817 <span class="keywordflow">if</span> (dividend.NotNegative())
<a name="l03818"></a>03818 quotient.sign = POSITIVE;
<a name="l03819"></a>03819 <span class="keywordflow">else</span>
<a name="l03820"></a>03820 {
<a name="l03821"></a>03821 quotient.sign = NEGATIVE;
<a name="l03822"></a>03822 if (remainder)
<a name="l03823"></a>03823 {
<a name="l03824"></a>03824 --quotient;
<a name="l03825"></a>03825 remainder = divisor - remainder;
<a name="l03826"></a>03826 }
<a name="l03827"></a>03827 }
<a name="l03828"></a>03828 }
<a name="l03829"></a>03829
<a name="l03830"></a>03830 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> Integer::DividedBy(word b)<span class="keyword"> const</span>
<a name="l03831"></a>03831 <span class="keyword"></span>{
<a name="l03832"></a>03832 word remainder;
<a name="l03833"></a>03833 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> quotient;
<a name="l03834"></a>03834 <a class="code" href="class_integer.html#a567c89aa176b354143c99d558d05a5fb" title="calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))">Integer::Divide</a>(remainder, quotient, *<span class="keyword">this</span>, b);
<a name="l03835"></a>03835 <span class="keywordflow">return</span> quotient;
<a name="l03836"></a>03836 }
<a name="l03837"></a>03837
<a name="l03838"></a>03838 word Integer::Modulo(word divisor)<span class="keyword"> const</span>
<a name="l03839"></a>03839 <span class="keyword"></span>{
<a name="l03840"></a>03840 <span class="keywordflow">if</span> (!divisor)
<a name="l03841"></a>03841 <span class="keywordflow">throw</span> <a class="code" href="class_integer_1_1_divide_by_zero.html" title="division by zero exception">Integer::DivideByZero</a>();
<a name="l03842"></a>03842
<a name="l03843"></a>03843 assert(divisor);
<a name="l03844"></a>03844
<a name="l03845"></a>03845 word remainder;
<a name="l03846"></a>03846
<a name="l03847"></a>03847 <span class="keywordflow">if</span> ((divisor & (divisor-1)) == 0) <span class="comment">// divisor is a power of 2</span>
<a name="l03848"></a>03848 remainder = reg[0] & (divisor-1);
<a name="l03849"></a>03849 <span class="keywordflow">else</span>
<a name="l03850"></a>03850 {
<a name="l03851"></a>03851 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03852"></a>03852
<a name="l03853"></a>03853 <span class="keywordflow">if</span> (divisor <= 5)
<a name="l03854"></a>03854 {
<a name="l03855"></a>03855 <a class="code" href="class_d_word.html">DWord</a> sum(0, 0);
<a name="l03856"></a>03856 <span class="keywordflow">while</span> (i--)
<a name="l03857"></a>03857 sum += reg[i];
<a name="l03858"></a>03858 remainder = sum % divisor;
<a name="l03859"></a>03859 }
<a name="l03860"></a>03860 <span class="keywordflow">else</span>
<a name="l03861"></a>03861 {
<a name="l03862"></a>03862 remainder = 0;
<a name="l03863"></a>03863 <span class="keywordflow">while</span> (i--)
<a name="l03864"></a>03864 remainder = <a class="code" href="class_d_word.html">DWord</a>(reg[i], remainder) % divisor;
<a name="l03865"></a>03865 }
<a name="l03866"></a>03866 }
<a name="l03867"></a>03867
<a name="l03868"></a>03868 <span class="keywordflow">if</span> (IsNegative() && remainder)
<a name="l03869"></a>03869 remainder = divisor - remainder;
<a name="l03870"></a>03870
<a name="l03871"></a>03871 <span class="keywordflow">return</span> remainder;
<a name="l03872"></a>03872 }
<a name="l03873"></a>03873
<a name="l03874"></a>03874 <span class="keywordtype">void</span> Integer::Negate()
<a name="l03875"></a>03875 {
<a name="l03876"></a>03876 <span class="keywordflow">if</span> (!!(*<span class="keyword">this</span>)) <span class="comment">// don't flip sign if *this==0</span>
<a name="l03877"></a>03877 sign = Sign(1-sign);
<a name="l03878"></a>03878 }
<a name="l03879"></a>03879
<a name="l03880"></a>03880 <span class="keywordtype">int</span> Integer::PositiveCompare(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)<span class="keyword"> const</span>
<a name="l03881"></a>03881 <span class="keyword"></span>{
<a name="l03882"></a>03882 <span class="keywordtype">unsigned</span> size = <a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>(), tSize = t.<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>();
<a name="l03883"></a>03883
<a name="l03884"></a>03884 <span class="keywordflow">if</span> (size == tSize)
<a name="l03885"></a>03885 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#a550cf80410789dc459df82387792ed49" title="signed comparison">CryptoPP::Compare</a>(reg, t.reg, size);
<a name="l03886"></a>03886 <span class="keywordflow">else</span>
<a name="l03887"></a>03887 <span class="keywordflow">return</span> size > tSize ? 1 : -1;
<a name="l03888"></a>03888 }
<a name="l03889"></a>03889
<a name="l03890"></a><a class="code" href="class_integer.html#a550cf80410789dc459df82387792ed49">03890</a> <span class="keywordtype">int</span> <a class="code" href="class_integer.html#a550cf80410789dc459df82387792ed49" title="signed comparison">Integer::Compare</a>(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& t)<span class="keyword"> const</span>
<a name="l03891"></a>03891 <span class="keyword"></span>{
<a name="l03892"></a>03892 <span class="keywordflow">if</span> (NotNegative())
<a name="l03893"></a>03893 {
<a name="l03894"></a>03894 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03895"></a>03895 <span class="keywordflow">return</span> PositiveCompare(t);
<a name="l03896"></a>03896 <span class="keywordflow">else</span>
<a name="l03897"></a>03897 <span class="keywordflow">return</span> 1;
<a name="l03898"></a>03898 }
<a name="l03899"></a>03899 <span class="keywordflow">else</span>
<a name="l03900"></a>03900 {
<a name="l03901"></a>03901 <span class="keywordflow">if</span> (t.NotNegative())
<a name="l03902"></a>03902 <span class="keywordflow">return</span> -1;
<a name="l03903"></a>03903 <span class="keywordflow">else</span>
<a name="l03904"></a>03904 <span class="keywordflow">return</span> -PositiveCompare(t);
<a name="l03905"></a>03905 }
<a name="l03906"></a>03906 }
<a name="l03907"></a>03907
<a name="l03908"></a><a class="code" href="class_integer.html#a9cbc1009bb421942470163aed5e3fefb">03908</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> <a class="code" href="class_integer.html#a9cbc1009bb421942470163aed5e3fefb" title="extract square root, if negative return 0, else return floor of square root">Integer::SquareRoot</a>()<span class="keyword"> const</span>
<a name="l03909"></a>03909 <span class="keyword"></span>{
<a name="l03910"></a>03910 <span class="keywordflow">if</span> (!IsPositive())
<a name="l03911"></a>03911 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>();
<a name="l03912"></a>03912
<a name="l03913"></a>03913 <span class="comment">// overestimate square root</span>
<a name="l03914"></a>03914 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> x, y = <a class="code" href="class_integer.html#ade53248f5dbb520273a70856b975417c" title="return the integer 2**e">Power2</a>((<a class="code" href="class_integer.html#a178398002ab175e788a3bc224e5e5a8d" title="number of significant bits = floor(log2(abs(*this))) + 1">BitCount</a>()+1)/2);
<a name="l03915"></a>03915 assert(y*y >= *<span class="keyword">this</span>);
<a name="l03916"></a>03916
<a name="l03917"></a>03917 <span class="keywordflow">do</span>
<a name="l03918"></a>03918 {
<a name="l03919"></a>03919 x = y;
<a name="l03920"></a>03920 y = (x + *<span class="keyword">this</span>/x) >> 1;
<a name="l03921"></a>03921 } <span class="keywordflow">while</span> (y<x);
<a name="l03922"></a>03922
<a name="l03923"></a>03923 <span class="keywordflow">return</span> x;
<a name="l03924"></a>03924 }
<a name="l03925"></a>03925
<a name="l03926"></a><a class="code" href="class_integer.html#a49efda9b0c4767508a2b5541380132ed">03926</a> <span class="keywordtype">bool</span> <a class="code" href="class_integer.html#a49efda9b0c4767508a2b5541380132ed" title="return whether this integer is a perfect square">Integer::IsSquare</a>()<span class="keyword"> const</span>
<a name="l03927"></a>03927 <span class="keyword"></span>{
<a name="l03928"></a>03928 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> r = <a class="code" href="class_integer.html#a9cbc1009bb421942470163aed5e3fefb" title="extract square root, if negative return 0, else return floor of square root">SquareRoot</a>();
<a name="l03929"></a>03929 <span class="keywordflow">return</span> *<span class="keyword">this</span> == r.Squared();
<a name="l03930"></a>03930 }
<a name="l03931"></a>03931
<a name="l03932"></a><a class="code" href="class_integer.html#acbee0ebe94c7ef5b0da39beabe87c27b">03932</a> <span class="keywordtype">bool</span> <a class="code" href="class_integer.html#acbee0ebe94c7ef5b0da39beabe87c27b" title="is 1 or -1">Integer::IsUnit</a>()<span class="keyword"> const</span>
<a name="l03933"></a>03933 <span class="keyword"></span>{
<a name="l03934"></a>03934 <span class="keywordflow">return</span> (<a class="code" href="class_integer.html#aa8ecc9cc334b338ee805f91e6b289396" title="number of significant words = ceiling(ByteCount()/sizeof(word))">WordCount</a>() == 1) && (reg[0] == 1);
<a name="l03935"></a>03935 }
<a name="l03936"></a>03936
<a name="l03937"></a><a class="code" href="class_integer.html#a94954b3df8073387d225be1033b0fa5b">03937</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> <a class="code" href="class_integer.html#a94954b3df8073387d225be1033b0fa5b" title="return inverse if 1 or -1, otherwise return 0">Integer::MultiplicativeInverse</a>()<span class="keyword"> const</span>
<a name="l03938"></a>03938 <span class="keyword"></span>{
<a name="l03939"></a>03939 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#acbee0ebe94c7ef5b0da39beabe87c27b" title="is 1 or -1">IsUnit</a>() ? *<span class="keyword">this</span> : <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>();
<a name="l03940"></a>03940 }
<a name="l03941"></a>03941
<a name="l03942"></a><a class="code" href="class_integer.html#ac030bf1a90f1feb05d18c6b09e37db38">03942</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> a_times_b_mod_c(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &x, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& y, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& m)
<a name="l03943"></a>03943 {
<a name="l03944"></a>03944 <span class="keywordflow">return</span> x*y%m;
<a name="l03945"></a>03945 }
<a name="l03946"></a>03946
<a name="l03947"></a><a class="code" href="class_integer.html#a45068a431797e59f7876e7d64e0f8dbb">03947</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> a_exp_b_mod_c(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &x, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& e, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& m)
<a name="l03948"></a>03948 {
<a name="l03949"></a>03949 <a class="code" href="class_modular_arithmetic.html" title="ring of congruence classes modulo n">ModularArithmetic</a> mr(m);
<a name="l03950"></a>03950 <span class="keywordflow">return</span> mr.Exponentiate(x, e);
<a name="l03951"></a>03951 }
<a name="l03952"></a>03952
<a name="l03953"></a><a class="code" href="class_integer.html#a2d4d29937f8ef666717530b30f137c37">03953</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> <a class="code" href="class_integer.html#a2d4d29937f8ef666717530b30f137c37" title="greatest common divisor">Integer::Gcd</a>(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)
<a name="l03954"></a>03954 {
<a name="l03955"></a>03955 <span class="keywordflow">return</span> <a class="code" href="class_euclidean_domain_of.html" title="EuclideanDomainOf.">EuclideanDomainOf<Integer></a>().<a class="code" href="class_integer.html#a2d4d29937f8ef666717530b30f137c37" title="greatest common divisor">Gcd</a>(a, b);
<a name="l03956"></a>03956 }
<a name="l03957"></a>03957
<a name="l03958"></a><a class="code" href="class_integer.html#a881f9c714ee42f35718725a43d4d7db3">03958</a> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> <a class="code" href="class_integer.html#a881f9c714ee42f35718725a43d4d7db3" title="calculate multiplicative inverse of *this mod n">Integer::InverseMod</a>(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &m)<span class="keyword"> const</span>
<a name="l03959"></a>03959 <span class="keyword"></span>{
<a name="l03960"></a>03960 assert(m.NotNegative());
<a name="l03961"></a>03961
<a name="l03962"></a>03962 <span class="keywordflow">if</span> (IsNegative())
<a name="l03963"></a>03963 <span class="keywordflow">return</span> Modulo(m).<a class="code" href="class_integer.html#a881f9c714ee42f35718725a43d4d7db3" title="calculate multiplicative inverse of *this mod n">InverseMod</a>(m);
<a name="l03964"></a>03964
<a name="l03965"></a>03965 <span class="keywordflow">if</span> (m.IsEven())
<a name="l03966"></a>03966 {
<a name="l03967"></a>03967 <span class="keywordflow">if</span> (!m || IsEven())
<a name="l03968"></a>03968 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>(); <span class="comment">// no inverse</span>
<a name="l03969"></a>03969 <span class="keywordflow">if</span> (*<span class="keyword">this</span> == <a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">One</a>())
<a name="l03970"></a>03970 <span class="keywordflow">return</span> <a class="code" href="class_integer.html#a8c070592581bf6c2f928c72bfa1c1638" title="avoid calling constructors for these frequently used integers">One</a>();
<a name="l03971"></a>03971
<a name="l03972"></a>03972 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> u = m.Modulo(*this).<a class="code" href="class_integer.html#a881f9c714ee42f35718725a43d4d7db3" title="calculate multiplicative inverse of *this mod n">InverseMod</a>(*<span class="keyword">this</span>);
<a name="l03973"></a>03973 <span class="keywordflow">return</span> !u ? <a class="code" href="class_integer.html#a19b7e6d48b1b57bd4846160ea2928175" title="avoid calling constructors for these frequently used integers">Zero</a>() : (m*(*<span class="keyword">this</span>-u)+1)/(*this);
<a name="l03974"></a>03974 }
<a name="l03975"></a>03975
<a name="l03976"></a>03976 <a class="code" href="class_sec_block.html">SecBlock<word></a> T(m.reg.size() * 4);
<a name="l03977"></a>03977 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> r((word)0, m.reg.size());
<a name="l03978"></a>03978 <span class="keywordtype">unsigned</span> k = AlmostInverse(r.reg, T, reg, reg.size(), m.reg, m.reg.size());
<a name="l03979"></a>03979 DivideByPower2Mod(r.reg, r.reg, k, m.reg, m.reg.size());
<a name="l03980"></a>03980 <span class="keywordflow">return</span> r;
<a name="l03981"></a>03981 }
<a name="l03982"></a>03982
<a name="l03983"></a>03983 word <a class="code" href="class_integer.html#a881f9c714ee42f35718725a43d4d7db3" title="calculate multiplicative inverse of *this mod n">Integer::InverseMod</a>(word mod)<span class="keyword"> const</span>
<a name="l03984"></a>03984 <span class="keyword"></span>{
<a name="l03985"></a>03985 word g0 = mod, g1 = *<span class="keyword">this</span> % mod;
<a name="l03986"></a>03986 word v0 = 0, v1 = 1;
<a name="l03987"></a>03987 word y;
<a name="l03988"></a>03988
<a name="l03989"></a>03989 <span class="keywordflow">while</span> (g1)
<a name="l03990"></a>03990 {
<a name="l03991"></a>03991 <span class="keywordflow">if</span> (g1 == 1)
<a name="l03992"></a>03992 <span class="keywordflow">return</span> v1;
<a name="l03993"></a>03993 y = g0 / g1;
<a name="l03994"></a>03994 g0 = g0 % g1;
<a name="l03995"></a>03995 v0 += y * v1;
<a name="l03996"></a>03996
<a name="l03997"></a>03997 <span class="keywordflow">if</span> (!g0)
<a name="l03998"></a>03998 <span class="keywordflow">break</span>;
<a name="l03999"></a>03999 <span class="keywordflow">if</span> (g0 == 1)
<a name="l04000"></a>04000 <span class="keywordflow">return</span> mod-v0;
<a name="l04001"></a>04001 y = g1 / g0;
<a name="l04002"></a>04002 g1 = g1 % g0;
<a name="l04003"></a>04003 v1 += y * v0;
<a name="l04004"></a>04004 }
<a name="l04005"></a>04005 <span class="keywordflow">return</span> 0;
<a name="l04006"></a>04006 }
<a name="l04007"></a>04007
<a name="l04008"></a>04008 <span class="comment">// ********************************************************</span>
<a name="l04009"></a>04009
<a name="l04010"></a>04010 ModularArithmetic::ModularArithmetic(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)
<a name="l04011"></a>04011 {
<a name="l04012"></a>04012 <a class="code" href="class_b_e_r_sequence_decoder.html" title="BER Sequence Decoder.">BERSequenceDecoder</a> seq(bt);
<a name="l04013"></a>04013 <a class="code" href="class_o_i_d.html" title="Object Identifier.">OID</a> oid(seq);
<a name="l04014"></a>04014 <span class="keywordflow">if</span> (oid != ASN1::prime_field())
<a name="l04015"></a>04015 BERDecodeError();
<a name="l04016"></a>04016 m_modulus.BERDecode(seq);
<a name="l04017"></a>04017 seq.MessageEnd();
<a name="l04018"></a>04018 m_result.reg.<a class="code" href="class_sec_block.html#af9e98d3f4a7af1156fcf3e6e68f4ae5a" title="change size and preserve contents">resize</a>(m_modulus.reg.size());
<a name="l04019"></a>04019 }
<a name="l04020"></a>04020
<a name="l04021"></a>04021 <span class="keywordtype">void</span> ModularArithmetic::DEREncode(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &bt)<span class="keyword"> const</span>
<a name="l04022"></a>04022 <span class="keyword"></span>{
<a name="l04023"></a>04023 <a class="code" href="class_d_e_r_sequence_encoder.html" title="DER Sequence Encoder.">DERSequenceEncoder</a> seq(bt);
<a name="l04024"></a>04024 ASN1::prime_field().DEREncode(seq);
<a name="l04025"></a>04025 m_modulus.<a class="code" href="class_integer.html#a6ab51a05bee88cfa690179611e8a084e" title="encode using Distinguished Encoding Rules, put result into a BufferedTransformation object...">DEREncode</a>(seq);
<a name="l04026"></a>04026 seq.MessageEnd();
<a name="l04027"></a>04027 }
<a name="l04028"></a>04028
<a name="l04029"></a>04029 <span class="keywordtype">void</span> ModularArithmetic::DEREncodeElement(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &out, <span class="keyword">const</span> Element &a)<span class="keyword"> const</span>
<a name="l04030"></a>04030 <span class="keyword"></span>{
<a name="l04031"></a>04031 a.DEREncodeAsOctetString(out, MaxElementByteLength());
<a name="l04032"></a>04032 }
<a name="l04033"></a>04033
<a name="l04034"></a>04034 <span class="keywordtype">void</span> ModularArithmetic::BERDecodeElement(<a class="code" href="class_buffered_transformation.html" title="interface for buffered transformations">BufferedTransformation</a> &in, Element &a)<span class="keyword"> const</span>
<a name="l04035"></a>04035 <span class="keyword"></span>{
<a name="l04036"></a>04036 a.BERDecodeAsOctetString(in, MaxElementByteLength());
<a name="l04037"></a>04037 }
<a name="l04038"></a>04038
<a name="l04039"></a>04039 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Half(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)<span class="keyword"> const</span>
<a name="l04040"></a>04040 <span class="keyword"></span>{
<a name="l04041"></a>04041 <span class="keywordflow">if</span> (a.reg.size()==m_modulus.reg.size())
<a name="l04042"></a>04042 {
<a name="l04043"></a>04043 CryptoPP::DivideByPower2Mod(m_result.reg.begin(), a.reg, 1, m_modulus.reg, a.reg.size());
<a name="l04044"></a>04044 <span class="keywordflow">return</span> m_result;
<a name="l04045"></a>04045 }
<a name="l04046"></a>04046 <span class="keywordflow">else</span>
<a name="l04047"></a>04047 <span class="keywordflow">return</span> m_result1 = (a.IsEven() ? (a >> 1) : ((a+m_modulus) >> 1));
<a name="l04048"></a>04048 }
<a name="l04049"></a>04049
<a name="l04050"></a>04050 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Add(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l04051"></a>04051 <span class="keyword"></span>{
<a name="l04052"></a>04052 <span class="keywordflow">if</span> (a.reg.size()==m_modulus.reg.size() && b.reg.size()==m_modulus.reg.size())
<a name="l04053"></a>04053 {
<a name="l04054"></a>04054 <span class="keywordflow">if</span> (CryptoPP::Add(m_result.reg.begin(), a.reg, b.reg, a.reg.size())
<a name="l04055"></a>04055 || Compare(m_result.reg, m_modulus.reg, a.reg.size()) >= 0)
<a name="l04056"></a>04056 {
<a name="l04057"></a>04057 CryptoPP::Subtract(m_result.reg.begin(), m_result.reg, m_modulus.reg, a.reg.size());
<a name="l04058"></a>04058 }
<a name="l04059"></a>04059 <span class="keywordflow">return</span> m_result;
<a name="l04060"></a>04060 }
<a name="l04061"></a>04061 <span class="keywordflow">else</span>
<a name="l04062"></a>04062 {
<a name="l04063"></a>04063 m_result1 = a+b;
<a name="l04064"></a>04064 <span class="keywordflow">if</span> (m_result1 >= m_modulus)
<a name="l04065"></a>04065 m_result1 -= m_modulus;
<a name="l04066"></a>04066 <span class="keywordflow">return</span> m_result1;
<a name="l04067"></a>04067 }
<a name="l04068"></a>04068 }
<a name="l04069"></a>04069
<a name="l04070"></a>04070 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Accumulate(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l04071"></a>04071 <span class="keyword"></span>{
<a name="l04072"></a>04072 <span class="keywordflow">if</span> (a.reg.size()==m_modulus.reg.size() && b.reg.size()==m_modulus.reg.size())
<a name="l04073"></a>04073 {
<a name="l04074"></a>04074 <span class="keywordflow">if</span> (CryptoPP::Add(a.reg, a.reg, b.reg, a.reg.size())
<a name="l04075"></a>04075 || Compare(a.reg, m_modulus.reg, a.reg.size()) >= 0)
<a name="l04076"></a>04076 {
<a name="l04077"></a>04077 CryptoPP::Subtract(a.reg, a.reg, m_modulus.reg, a.reg.size());
<a name="l04078"></a>04078 }
<a name="l04079"></a>04079 }
<a name="l04080"></a>04080 <span class="keywordflow">else</span>
<a name="l04081"></a>04081 {
<a name="l04082"></a>04082 a+=b;
<a name="l04083"></a>04083 <span class="keywordflow">if</span> (a>=m_modulus)
<a name="l04084"></a>04084 a-=m_modulus;
<a name="l04085"></a>04085 }
<a name="l04086"></a>04086
<a name="l04087"></a>04087 <span class="keywordflow">return</span> a;
<a name="l04088"></a>04088 }
<a name="l04089"></a>04089
<a name="l04090"></a>04090 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Subtract(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l04091"></a>04091 <span class="keyword"></span>{
<a name="l04092"></a>04092 <span class="keywordflow">if</span> (a.reg.size()==m_modulus.reg.size() && b.reg.size()==m_modulus.reg.size())
<a name="l04093"></a>04093 {
<a name="l04094"></a>04094 <span class="keywordflow">if</span> (CryptoPP::Subtract(m_result.reg.begin(), a.reg, b.reg, a.reg.size()))
<a name="l04095"></a>04095 CryptoPP::Add(m_result.reg.begin(), m_result.reg, m_modulus.reg, a.reg.size());
<a name="l04096"></a>04096 <span class="keywordflow">return</span> m_result;
<a name="l04097"></a>04097 }
<a name="l04098"></a>04098 <span class="keywordflow">else</span>
<a name="l04099"></a>04099 {
<a name="l04100"></a>04100 m_result1 = a-b;
<a name="l04101"></a>04101 <span class="keywordflow">if</span> (m_result1.IsNegative())
<a name="l04102"></a>04102 m_result1 += m_modulus;
<a name="l04103"></a>04103 <span class="keywordflow">return</span> m_result1;
<a name="l04104"></a>04104 }
<a name="l04105"></a>04105 }
<a name="l04106"></a>04106
<a name="l04107"></a>04107 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Reduce(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l04108"></a>04108 <span class="keyword"></span>{
<a name="l04109"></a>04109 <span class="keywordflow">if</span> (a.reg.size()==m_modulus.reg.size() && b.reg.size()==m_modulus.reg.size())
<a name="l04110"></a>04110 {
<a name="l04111"></a>04111 <span class="keywordflow">if</span> (CryptoPP::Subtract(a.reg, a.reg, b.reg, a.reg.size()))
<a name="l04112"></a>04112 CryptoPP::Add(a.reg, a.reg, m_modulus.reg, a.reg.size());
<a name="l04113"></a>04113 }
<a name="l04114"></a>04114 <span class="keywordflow">else</span>
<a name="l04115"></a>04115 {
<a name="l04116"></a>04116 a-=b;
<a name="l04117"></a>04117 <span class="keywordflow">if</span> (a.IsNegative())
<a name="l04118"></a>04118 a+=m_modulus;
<a name="l04119"></a>04119 }
<a name="l04120"></a>04120
<a name="l04121"></a>04121 <span class="keywordflow">return</span> a;
<a name="l04122"></a>04122 }
<a name="l04123"></a>04123
<a name="l04124"></a>04124 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& ModularArithmetic::Inverse(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)<span class="keyword"> const</span>
<a name="l04125"></a>04125 <span class="keyword"></span>{
<a name="l04126"></a>04126 <span class="keywordflow">if</span> (!a)
<a name="l04127"></a>04127 <span class="keywordflow">return</span> a;
<a name="l04128"></a>04128
<a name="l04129"></a>04129 CopyWords(m_result.reg.begin(), m_modulus.reg, m_modulus.reg.size());
<a name="l04130"></a>04130 <span class="keywordflow">if</span> (CryptoPP::Subtract(m_result.reg.begin(), m_result.reg, a.reg, a.reg.size()))
<a name="l04131"></a>04131 Decrement(m_result.reg.begin()+a.reg.size(), m_modulus.reg.size()-a.reg.size());
<a name="l04132"></a>04132
<a name="l04133"></a>04133 <span class="keywordflow">return</span> m_result;
<a name="l04134"></a>04134 }
<a name="l04135"></a>04135
<a name="l04136"></a>04136 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> ModularArithmetic::CascadeExponentiate(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &x, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &e1, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &y, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &e2)<span class="keyword"> const</span>
<a name="l04137"></a>04137 <span class="keyword"></span>{
<a name="l04138"></a>04138 <span class="keywordflow">if</span> (m_modulus.IsOdd())
<a name="l04139"></a>04139 {
<a name="l04140"></a>04140 <a class="code" href="class_montgomery_representation.html" title="do modular arithmetics in Montgomery representation for increased speed">MontgomeryRepresentation</a> dr(m_modulus);
<a name="l04141"></a>04141 <span class="keywordflow">return</span> dr.ConvertOut(dr.CascadeExponentiate(dr.ConvertIn(x), e1, dr.ConvertIn(y), e2));
<a name="l04142"></a>04142 }
<a name="l04143"></a>04143 <span class="keywordflow">else</span>
<a name="l04144"></a>04144 <span class="keywordflow">return</span> <a class="code" href="class_abstract_ring.html" title="Abstract Ring.">AbstractRing<Integer>::CascadeExponentiate</a>(x, e1, y, e2);
<a name="l04145"></a>04145 }
<a name="l04146"></a>04146
<a name="l04147"></a>04147 <span class="keywordtype">void</span> ModularArithmetic::SimultaneousExponentiate(<a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> *results, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &base, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> *exponents, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> exponentsCount)<span class="keyword"> const</span>
<a name="l04148"></a>04148 <span class="keyword"></span>{
<a name="l04149"></a>04149 <span class="keywordflow">if</span> (m_modulus.IsOdd())
<a name="l04150"></a>04150 {
<a name="l04151"></a>04151 <a class="code" href="class_montgomery_representation.html" title="do modular arithmetics in Montgomery representation for increased speed">MontgomeryRepresentation</a> dr(m_modulus);
<a name="l04152"></a>04152 dr.SimultaneousExponentiate(results, dr.ConvertIn(base), exponents, exponentsCount);
<a name="l04153"></a>04153 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i<exponentsCount; i++)
<a name="l04154"></a>04154 results[i] = dr.ConvertOut(results[i]);
<a name="l04155"></a>04155 }
<a name="l04156"></a>04156 <span class="keywordflow">else</span>
<a name="l04157"></a>04157 <a class="code" href="class_abstract_ring.html" title="Abstract Ring.">AbstractRing<Integer>::SimultaneousExponentiate</a>(results, base, exponents, exponentsCount);
<a name="l04158"></a>04158 }
<a name="l04159"></a>04159
<a name="l04160"></a>04160 MontgomeryRepresentation::MontgomeryRepresentation(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &m) <span class="comment">// modulus must be odd</span>
<a name="l04161"></a>04161 : <a class="code" href="class_modular_arithmetic.html" title="ring of congruence classes modulo n">ModularArithmetic</a>(m),
<a name="l04162"></a>04162 m_u((word)0, m_modulus.reg.size()),
<a name="l04163"></a>04163 m_workspace(5*m_modulus.reg.size())
<a name="l04164"></a>04164 {
<a name="l04165"></a>04165 <span class="keywordflow">if</span> (!m_modulus.IsOdd())
<a name="l04166"></a>04166 <span class="keywordflow">throw</span> <a class="code" href="class_invalid_argument.html" title="exception thrown when an invalid argument is detected">InvalidArgument</a>(<span class="stringliteral">"MontgomeryRepresentation: Montgomery representation requires an odd modulus"</span>);
<a name="l04167"></a>04167
<a name="l04168"></a>04168 RecursiveInverseModPower2(m_u.reg, m_workspace, m_modulus.reg, m_modulus.reg.size());
<a name="l04169"></a>04169 }
<a name="l04170"></a>04170
<a name="l04171"></a>04171 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& MontgomeryRepresentation::Multiply(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a, <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &b)<span class="keyword"> const</span>
<a name="l04172"></a>04172 <span class="keyword"></span>{
<a name="l04173"></a>04173 word *<span class="keyword">const</span> T = m_workspace.begin();
<a name="l04174"></a>04174 word *<span class="keyword">const</span> R = m_result.reg.begin();
<a name="l04175"></a>04175 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N = m_modulus.reg.size();
<a name="l04176"></a>04176 assert(a.reg.size()<=N && b.reg.size()<=N);
<a name="l04177"></a>04177
<a name="l04178"></a>04178 AsymmetricMultiply(T, T+2*N, a.reg, a.reg.size(), b.reg, b.reg.size());
<a name="l04179"></a>04179 SetWords(T+a.reg.size()+b.reg.size(), 0, 2*N-a.reg.size()-b.reg.size());
<a name="l04180"></a>04180 MontgomeryReduce(R, T+2*N, T, m_modulus.reg, m_u.reg, N);
<a name="l04181"></a>04181 <span class="keywordflow">return</span> m_result;
<a name="l04182"></a>04182 }
<a name="l04183"></a>04183
<a name="l04184"></a>04184 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& MontgomeryRepresentation::Square(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)<span class="keyword"> const</span>
<a name="l04185"></a>04185 <span class="keyword"></span>{
<a name="l04186"></a>04186 word *<span class="keyword">const</span> T = m_workspace.begin();
<a name="l04187"></a>04187 word *<span class="keyword">const</span> R = m_result.reg.begin();
<a name="l04188"></a>04188 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N = m_modulus.reg.size();
<a name="l04189"></a>04189 assert(a.reg.size()<=N);
<a name="l04190"></a>04190
<a name="l04191"></a>04191 CryptoPP::Square(T, T+2*N, a.reg, a.reg.size());
<a name="l04192"></a>04192 SetWords(T+2*a.reg.size(), 0, 2*N-2*a.reg.size());
<a name="l04193"></a>04193 MontgomeryReduce(R, T+2*N, T, m_modulus.reg, m_u.reg, N);
<a name="l04194"></a>04194 <span class="keywordflow">return</span> m_result;
<a name="l04195"></a>04195 }
<a name="l04196"></a>04196
<a name="l04197"></a>04197 <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> MontgomeryRepresentation::ConvertOut(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)<span class="keyword"> const</span>
<a name="l04198"></a>04198 <span class="keyword"></span>{
<a name="l04199"></a>04199 word *<span class="keyword">const</span> T = m_workspace.begin();
<a name="l04200"></a>04200 word *<span class="keyword">const</span> R = m_result.reg.begin();
<a name="l04201"></a>04201 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N = m_modulus.reg.size();
<a name="l04202"></a>04202 assert(a.reg.size()<=N);
<a name="l04203"></a>04203
<a name="l04204"></a>04204 CopyWords(T, a.reg, a.reg.size());
<a name="l04205"></a>04205 SetWords(T+a.reg.size(), 0, 2*N-a.reg.size());
<a name="l04206"></a>04206 MontgomeryReduce(R, T+2*N, T, m_modulus.reg, m_u.reg, N);
<a name="l04207"></a>04207 <span class="keywordflow">return</span> m_result;
<a name="l04208"></a>04208 }
<a name="l04209"></a>04209
<a name="l04210"></a>04210 <span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a>& MontgomeryRepresentation::MultiplicativeInverse(<span class="keyword">const</span> <a class="code" href="class_integer.html" title="multiple precision integer and basic arithmetics">Integer</a> &a)<span class="keyword"> const</span>
<a name="l04211"></a>04211 <span class="keyword"></span>{
<a name="l04212"></a>04212 <span class="comment">// return (EuclideanMultiplicativeInverse(a, modulus)<<(2*WORD_BITS*modulus.reg.size()))%modulus;</span>
<a name="l04213"></a>04213 word *<span class="keyword">const</span> T = m_workspace.begin();
<a name="l04214"></a>04214 word *<span class="keyword">const</span> R = m_result.reg.begin();
<a name="l04215"></a>04215 <span class="keyword">const</span> <span class="keywordtype">size_t</span> N = m_modulus.reg.size();
<a name="l04216"></a>04216 assert(a.reg.size()<=N);
<a name="l04217"></a>04217
<a name="l04218"></a>04218 CopyWords(T, a.reg, a.reg.size());
<a name="l04219"></a>04219 SetWords(T+a.reg.size(), 0, 2*N-a.reg.size());
<a name="l04220"></a>04220 MontgomeryReduce(R, T+2*N, T, m_modulus.reg, m_u.reg, N);
<a name="l04221"></a>04221 <span class="keywordtype">unsigned</span> k = AlmostInverse(R, T, R, N, m_modulus.reg, N);
<a name="l04222"></a>04222
<a name="l04223"></a>04223 <span class="comment">// cout << "k=" << k << " N*32=" << 32*N << endl;</span>
<a name="l04224"></a>04224
<a name="l04225"></a>04225 <span class="keywordflow">if</span> (k>N*WORD_BITS)
<a name="l04226"></a>04226 DivideByPower2Mod(R, R, k-N*WORD_BITS, m_modulus.reg, N);
<a name="l04227"></a>04227 <span class="keywordflow">else</span>
<a name="l04228"></a>04228 MultiplyByPower2Mod(R, R, N*WORD_BITS-k, m_modulus.reg, N);
<a name="l04229"></a>04229
<a name="l04230"></a>04230 <span class="keywordflow">return</span> m_result;
<a name="l04231"></a>04231 }
<a name="l04232"></a>04232
<a name="l04233"></a>04233 NAMESPACE_END
<a name="l04234"></a>04234
<a name="l04235"></a>04235 <span class="preprocessor">#endif</span>
</pre></div></div>
</div>
<hr class="footer"/><address class="footer"><small>Generated on Sun Oct 16 2011 for Crypto++ by 
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.7.4 </small></address>
</body>
</html>
