Lines Matching refs:That
76 large integer numbers. It was written in portable ISO C source code so that it will build on any platform with a conforming
90 Since both\footnote{Note that the MPI files under mtest/ are copyrighted by Michael Fromberger. They are not required to use LibTomMath.} are in the
106 that and include ``tommath.h'' within your programs. Alternatively to build with MSVC issue the following
143 If you do not have a ``/dev/urandom'' style RNG source you will have to write your own PRNG and simply pipe that into
150 This will output a row of numbers that are increasing. Each column is a different test (such as addition, multiplication, etc)
151 that is being performed. The numbers represent how many times the test was invoked. If an error is detected the program
175 You will also note that the header tommath\_class.h is actually recursively included (it includes itself twice).
195 A trim is a manner of removing functionality from a function that is not required. For instance, to perform
255 Source code alone cannot really teach how the algorithms work which is why I also wrote a textbook that accompanies
256 the library (beat that!).
291 that is very flexible, complete and performs well in resource contrained environments. Fast RSA for example can
346 Where ``mp\_digit'' is a data type that represents individual digits of the integer. By default, an mp\_digit is the
350 All LTM functions that use the mp\_int type will expect a pointer to mp\_int structure. You must allocate memory to
351 hold the structure itself by yourself (whether off stack or heap it doesn't matter). The very first thing that must be
352 done to use an mp\_int is that it must be initialized.
356 The arithmetic functions of the library are all organized to have the same style prototype. That is source operands
365 Another feature of the way the functions have been implemented is that source operands can be destination operands as well.
442 variables in an ``all or nothing'' fashion. That is, they are either all initialized successfully or they are all
557 excess digits being removed. Note that you can use a shrunk mp\_int in further computations, however, such operations
558 will require heap operations which can be slow. It is not ideal to shrink mp\_int variables that you will further
594 Within the mp\_int structure are two parameters which control the limitations of the array of digits that represent
595 the integer the mp\_int is meant to equal. The \textit{used} parameter dictates how many digits are significant, that is,
597 the array. If you need to perform an operation that requires more digits you will have to mp\_grow() the mp\_int to
655 This will zero the contents of $a$ and make it represent an integer equal to the value of $b$. Note that this
683 To set a constant that is the size of an ISO C ``unsigned long'' and larger than a single digit the following function
930 This will compare $a$ to the left of $b$ using a signed comparison. Note that it will always treat $b$ as
972 Logical operations are operations that can be performed either with simple shifts or boolean operators such as
1061 value to signal that the remainder is not desired.
1145 This divides $a$ by $b$ and stores the quotient in $c$ and $d$. The signed quotient is computed such that
1146 $bc + d = a$. Note that either of $c$ or $d$ can be set to \textbf{NULL} if their value is not required. If
1231 Both of the Toom-Cook and Karatsuba multiplication algorithms are faster than the traditional $O(n^2)$ approach that
1237 So why not always use Karatsuba or Toom-Cook? The simple answer is that they have so much overhead that they're not
1239 GCC 3.3.1 and an Athlon XP processor the cutoff point is roughly 110 digits (about 70 for the Intel P4). That is, at
1271 good Karatsuba squaring and multiplication points. Then it proceeds to find Toom-Cook points. Note that the Toom-Cook
1287 Note that one of the four optimized reduction algorithms are automatically chosen in the modular exponentiation
1303 Barrett reduction is a generic optimized reduction algorithm that requires pre--computation to achieve
1396 setup for instance, the limit is $127$ digits ($3556$--bits). Note that this function is not limited to
1397 that it falls back to a baseline algorithm after that point.
1399 An important observation is that this reduction does not return $a \mbox{ mod }m$ but $aR^{-1} \mbox{ mod }m$
1495 ``Dimminished Radix'' reduction refers to reduction with respect to moduli that are ameniable to simple
1523 Note that unlike Montgomery reduction there is no normalization process. The result of this function is
1563 $X$ the operation is performed as $Y \equiv (G^{-1} \mbox{ mod }P)^{\vert X \vert} \mbox{ (mod }P\mbox{)}$ provided that
1576 This computes $c = a^{1/b}$ such that $c^b \le a$ and $(c+1)^b > a$. The implementation of this function is not
1595 outcome in ``result''. That is if $result = 0$ then $a$ is not divisible by the primes, otherwise it is. Note that
1604 Performs a Fermat primality test to the base $b$. That is it computes $b^a \mbox{ mod }a$ and tests whether the value is
1617 Note that is suggested that you use the Miller-Rabin test instead of the Fermat test since all of the failures of
1622 or so unique bases. However, it has been proven that the probability of failure goes down as the size of the input goes up.
1641 If $a$ passes all of the tests $result$ is set to one, otherwise it is set to zero. Note that $t$ is bounded by
1649 This finds the next prime after $a$ that passes mp\_prime\_is\_prime() with $t$ tests. Set $bbs\_style$ to one if you
1665 Which is a function that must read $len$ bytes (and return the amount stored) into $dst$. The $dat$ variable is simply
1691 \hline LTM\_PRIME\_SAFE & Make a prime $p$ such that $(p - 1)/2$ is also prime. \\
1693 \hline LTM\_PRIME\_2MSB\_OFF & Makes sure that the bit adjacent to the most significant bit \\
1695 \hline LTM\_PRIME\_2MSB\_ON & Makes sure that the bit adjacent to the most significant bit \\
1729 character it does not recognize (which happens to include th NUL char... imagine that...). A single leading $-$ sign
1777 This finds the triple U1/U2/U3 using the Extended Euclidean algorithm such that the following equation holds.
1814 Computes the multiplicative inverse of $a$ modulo $b$ and stores the result in $c$ such that $ac \equiv 1 \mbox{ (mod }b\mbox{)}$.
