Lines Matching refs:Will
76 large integer numbers. It was written in portable ISO C source code so that it will build on any platform with a conforming
95 LibTomMath is meant to be very ``GCC friendly'' as it comes with a makefile well suited for GCC. However, the library will
96 also build in MSVC, Borland C out of the box. For any other ISO C compiler a makefile will have to be made by the end
105 command. This will build the library and archive the object files in ``libtommath.a''. Now you link against
111 This will build the library and archive the object files in ``tommath.lib''. This has been tested with MSVC
119 This requires the ``libtool'' package (common on most Linux/BSD systems). It will build LibTomMath as both shared
121 library (resource) will be called ``libtommath.la'' while the static library called ``libtommath.a''. Generally
135 This will build the library, ``test'' and ``mtest/mtest''. The ``test'' program will accept test vectors and verify the
136 results. ``mtest/mtest'' will generate test vectors using the MPI library by Michael Fromberger\footnote{A copy of MPI
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)
152 will exit with a dump of the relevent numbers it was working with.
160 instructs the system to build all of the functions. This is how LibTomMath used to be packaged. This will give you
169 In the file tommath\_class.h you will see a large list of C ``defines'' followed by a series of ``ifdefs''
172 function in the respective file will be compiled and linked into the library. Accordingly when the define
173 is absent the file will not be compiled and not contribute any size to the library.
175 You will also note that the header tommath\_class.h is actually recursively included (it includes itself twice).
176 This is to help resolve as many dependencies as possible. In the last pass the symbol LTM\_LAST will be defined.
330 This will return a pointer to a string which describes the given error code. It will not work for the return codes
350 All LTM functions that use the mp\_int type will expect a pointer to mp\_int structure. You must allocate memory to
384 This function expects a pointer to an mp\_int structure and will initialize the members of the structure so the mp\_int
452 It accepts a \textbf{NULL} terminated list of pointers to mp\_int structures. It will attempt to initialize them all
488 This function will initialize $a$ and make it a copy of $b$ if all goes well.
523 The $size$ parameter must be greater than zero. If the function succeeds the mp\_int $a$ will be initialized
556 This will remove excess digits of the mp\_int $a$. If the operation fails the mp\_int should be intact without the
558 will require heap operations which can be slow. It is not ideal to shrink mp\_int variables that you will further
597 the array. If you need to perform an operation that requires more digits you will have to mp\_grow() the mp\_int to
605 This will grow the array of digits of $a$ to $size$. If the \textit{alloc} parameter is already bigger than
606 $size$ the function will not do anything.
655 This will zero the contents of $a$ and make it represent an integer equal to the value of $b$. Note that this
691 This will assign the value of the 32-bit variable $b$ to the mp\_int $a$. Unlike mp\_set() this function will always
702 This will return the 32 least significant bits of the mp\_int $a$.
810 mp\_int structures. This is analogous to an absolute comparison. The function mp\_cmp\_mag() will compare two
817 This will compare $a$ to $b$ placing $a$ to the left of $b$. This function cannot fail and will return one of the
874 This will compare $a$ to the left of $b$. It will first compare the signs of the two mp\_int variables. If they
875 differ it will return immediately based on their signs. If the signs are equal then it will compare the digits
876 individually. This function will return one of the compare conditions codes listed in figure \ref{fig:CMP}.
930 This will compare $a$ to the left of $b$ using a signed comparison. Note that it will always treat $b$ as
932 comes up in cryptography). The function cannot fail and will return one of the tree compare condition codes
964 If this program functions properly it will print out the following.
987 The former will assign twice $a$ to $b$ while the latter will assign half $a$ to $b$. These functions are fast
1036 If this program is successful it will print out the following text.
1050 This will multiply $a$ by $2^b$ and store the result in ``c''. If the value of $b$ is less than or equal to
1051 zero the function will copy $a$ to ``c'' without performing any further actions.
1059 Which will divide $a$ by $2^b$, store the quotient in ``c'' and the remainder in ``d'. If $b \le 0$ then the
1078 This will multiply $a$ in place by $x^b$ which is equivalent to shifting the digits left $b$ places and inserting zeroes
1085 This will divide $a$ in place by $x^b$ and discard the remainder. This function cannot fail as it performs the operations
1163 will determine on its own\footnote{Some tweaking may be required.} what routine to use automatically when it is called.
1225 Will square $a$ and store it in $b$. Like the case of multiplication there are four different squaring
1270 When the program is running it will output a series of measurements for different cutoff points. It will first find
1319 This will reduce $a$ in place modulo $b$ with the precomputed $\mu$ value in $c$. $a$ must be in the range
1373 This program will calculate $a^3 \mbox{ mod }b$ if all the functions succeed.
1537 This will compute the required $d$ value for the given moduli $a$.
1544 This will reduce $a$ in place modulo $n$ with the pre--computed value $d$. From my experience this routine is
1562 will automatically detect the fastest modular reduction technique to use during the operation. For negative values of
1566 This function is actually a shell around the two internal exponentiation functions. This routine will automatically
1577 ideal for values of $b$ greater than three. It will work but become very slow. So unless you are working with very small
1578 numbers (less than 1000 bits) I'd avoid $b > 3$ situations. Will return a positive root only for even roots and return
1579 a root with the sign of the input for odd roots. For example, performing $4^{1/2}$ will return $2$ whereas $(-8)^{1/3}$
1580 will return $-2$.
1582 This algorithm uses the ``Newton Approximation'' method and will converge on the correct root fairly quickly. Since
1594 This will attempt to evenly divide $a$ by a list of primes\footnote{Default is the first 256 primes.} and store the
1640 This will perform a trial division followed by $t$ rounds of Miller-Rabin tests on $a$ and store the result in $result$.
1658 This will find a prime greater than $256^{size}$ which can be ``bbs\_style'' or not depending on $bbs$ and must pass
1680 This will generate a prime in $a$ using $t$ tests of the primality testing algorithms. The variable $size$
1721 function returns an error code and ``size'' will be zero.
1728 This will read the base-``radix'' NUL terminated string from ``str'' into $a$. It will stop reading when it reads a
1741 This will return the number of bytes (octets) required to store the unsigned copy of the integer $a$.
1747 This will store $a$ into the buffer $b$ in big--endian format. Fortunately this is exactly what DER (or is it ASN?)
1754 This will read in an unsigned big--endian array of bytes (octets) from $b$ of length $c$ into $a$. The resulting
1755 integer $a$ will always be positive.
1790 This will compute the greatest common divisor of $a$ and $b$ and store it in $c$.
1797 This will compute the least common multiple of $a$ and $b$ and store it in $c$.
1804 This will compute the Jacobi symbol for $a$ with respect to $p$. If $p$ is prime this essentially computes the Legendre
1806 then the result will be $-1$ when $a$ is not a quadratic residue modulo $p$. The result will be $0$ if $a$ divides $p$
1807 and the result will be $1$ if $a$ is a quadratic residue modulo $p$.
1830 functions fairly handy if you have to work with relatively small numbers since you will not have to allocate
