|
Defines |
| #define | MP_HWBITS (MP_WBITS >> 1) |
| #define | MP_WBYTES (MP_WBITS >> 3) |
| #define | MP_WNIBBLES (MP_WBITS >> 2) |
| #define | MP_WORDS_TO_BITS(x) ((x) << 5) |
| #define | MP_WORDS_TO_NIBBLES(x) ((x) << 3) |
| #define | MP_WORDS_TO_BYTES(x) ((x) << 2) |
| #define | MP_BITS_TO_WORDS(x) ((x) >> 5) |
| #define | MP_NIBBLES_TO_WORDS(x) ((x) >> 3) |
| #define | MP_BYTES_TO_WORDS(x) ((x) >> 2) |
| #define | MP_MSBMASK (((mpw) 0x1) << (MP_WBITS-1)) |
| #define | MP_LSBMASK ((mpw) 0x1) |
| #define | MP_ALLMASK ~((mpw) 0x0) |
| #define | mpcopy(size, dst, src) memcpy(dst, src, MP_WORDS_TO_BYTES(size)) |
| #define | mpmove(size, dst, src) memmove(dst, src, MP_WORDS_TO_BYTES(size)) |
Functions |
| void | mpzero (size_t size, mpw *data) |
| | This function zeroes a multi-precision integer of a given size.
|
| void | mpfill (size_t size, mpw *data, mpw fill) |
| | This function fills each word of a multi-precision integer with a given value.
|
| int | mpodd (size_t size, const mpw *data) |
| | This functions tests if a multi-precision integer is odd.
|
| int | mpeven (size_t size, const mpw *data) |
| | This function tests if a multi-precision integer is even.
|
| int | mpz (size_t size, const mpw *data) |
| | This function tests if a multi-precision integer is zero.
|
| int | mpnz (size_t size, const mpw *data) |
| | This function tests if a multi-precision integer is not zero.
|
| int | mpeq (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if two multi-precision integers of the same size are equal.
|
| int | mpne (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if two multi-precision integers of the same size differ.
|
| int | mpgt (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of the same size is greater than the second.
|
| int | mplt (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of the same size is less than the second.
|
| int | mpge (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of the same size is greater than or equal to the second.
|
| int | mple (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of the same size is less than or equal to the second.
|
| int | mpeqx (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if two multi-precision integers of different size are equal.
|
| int | mpnex (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if two multi-precision integers of different size are equal.
|
| int | mpgtx (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of different size is greater than the second.
|
| int | mpltx (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of different size is less than the second.
|
| int | mpgex (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of different size is greater than or equal to the second.
|
| int | mplex (size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function tests if the first of two multi-precision integers of different size is less than or equal to the second.
|
| int | mpisone (size_t size, const mpw *data) |
| | This functions tests if the value of a multi-precision integer is equal to one.
|
| int | mpistwo (size_t size, const mpw *data) |
| | This function tests if the value of a multi-precision integer is equal to two.
|
| int | mpleone (size_t size, const mpw *data) |
| | This function tests if the value of a multi-precision integer is less than or equal to one.
|
| int | mpeqmone (size_t size, const mpw *xdata, const mpw *ydata) |
| | This function tests if multi-precision integer x is equal to y minus one.
|
| int | mpmsbset (size_t size, const mpw *data) |
| | This function tests if the most significant bit of a multi-precision integer is set.
|
| int | mplsbset (size_t size, const mpw *data) |
| | This function tests if the leiast significant bit of a multi-precision integer is set.
|
| void | mpsetmsb (size_t size, mpw *data) |
| | This function sets the most significant bit of a multi-precision integer.
|
| void | mpsetlsb (size_t size, mpw *data) |
| | This function sets the least significant bit of a multi-precision integer.
|
| void | mpclrmsb (size_t size, mpw *data) |
| | This function clears the most significant bit of a multi-precision integer.
|
| void | mpclrlsb (size_t size, mpw *data) |
| | This function clears the least significant bit of a multi-precision integer.
|
| void | mpand (size_t size, mpw *xdata, const mpw *ydata) |
| | This function computes the bit-wise AND of two multi-precision integers. Modifies xdata.
|
| void | mpor (size_t size, mpw *xdata, const mpw *ydata) |
| | This function computes the bit-wise OR of two multi-precision integers. Modifies xdata.
|
| void | mpxor (size_t size, mpw *xdata, const mpw *ydata) |
| | This function computes the bit-wise XOR of two multi-precision integers. Modifies xdata.
|
| void | mpnot (size_t size, mpw *data) |
| | This function flips all bits of a multi-precision integer.
|
| void | mpsetw (size_t size, mpw *xdata, mpw y) |
| | This function sets the value of a multi-precision integer to the given word. The given value is copied into the least significant word, while the most significant words are zeroed.
|
| void | mpsetx (size_t xsize, mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function set the value of the first multi-precision integer to the second, truncating the most significant words if ysize > xsize, or zeroing the most significant words if ysize < xsize.
|
| int | mpaddw (size_t size, mpw *xdata, mpw y) |
| | This function adds one word to a multi-precision integer. The performed operation is in pseudocode: x += y.
|
| int | mpadd (size_t size, mpw *xdata, const mpw *ydata) |
| | This function adds two multi-precision integers of equal size. The performed operation is in pseudocode: x += y.
|
| int | mpaddx (size_t xsize, mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function adds two multi-precision integers of different size. The performed operation in pseudocode: x += y.
|
| int | mpsubw (size_t size, mpw *xdata, mpw y) |
| | This function subtracts one word to a multi-precision integer. The performed operation in pseudocode: x -= y.
|
| int | mpsub (size_t size, mpw *xdata, const mpw *ydata) |
| | This function subtracts two multi-precision integers of equal size. The performed operation in pseudocode: x -= y.
|
| int | mpsubx (size_t xsize, mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function subtracts two multi-precision integers of different size. The performed operation in pseudocode: x -= y.
|
| int | mpmultwo (size_t size, mpw *data) |
| void | mpneg (size_t size, mpw *data) |
| | This function negates a multi-precision integer.
|
| size_t | mpsize (size_t size, const mpw *data) |
| | This function returns the true size of a multi-precision integer, after stripping leading zero words.
|
| size_t | mpbits (size_t size, const mpw *data) |
| | This function returns the number of significant bits in a multi-precision integer.
|
| size_t | mpmszcnt (size_t size, const mpw *data) |
| size_t | mplszcnt (size_t size, const mpw *data) |
| void | mplshift (size_t size, mpw *data, size_t count) |
| void | mprshift (size_t size, mpw *data, size_t count) |
| size_t | mprshiftlsz (size_t size, mpw *data) |
| size_t | mpnorm (size_t size, mpw *data) |
| void | mpdivtwo (size_t size, mpw *data) |
| void | mpsdivtwo (size_t size, mpw *data) |
| mpw | mpsetmul (size_t size, mpw *result, const mpw *data, mpw y) |
| | This function performs a multi-precision multiply-setup.
|
| mpw | mpaddmul (size_t size, mpw *result, const mpw *data, mpw y) |
| | This function performs a mult-precision multiply-accumulate.
|
| void | mpaddsqrtrc (size_t size, mpw *result, const mpw *data) |
| | This function is used in the calculation of a multi-precision squaring.
|
| void | mpmul (mpw *result, size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata) |
| | This function computes a full multi-precision product.
|
| void | mpsqr (mpw *result, size_t size, const mpw *data) |
| | This function computes a full multi-precision square.
|
| void | mpgcd_w (size_t size, const mpw *xdata, const mpw *ydata, mpw *result, mpw *wksp) |
| int | mpextgcd_w (size_t size, const mpw *xdata, const mpw *ydata, mpw *result, mpw *wksp) |
| mpw | mppndiv (mpw xhi, mpw xlo, mpw y) |
| void | mpmod (mpw *result, size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata, mpw *wksp) |
| void | mpndivmod (mpw *result, size_t xsize, const mpw *xdata, size_t ysize, const mpw *ydata, mpw *wksp) |
| void | mpprint (size_t size, const mpw *data) |
| void | mpprintln (size_t size, const mpw *data) |
| void | mpfprint (FILE *f, size_t size, const mpw *data) |
| void | mpfprintln (FILE *f, size_t size, const mpw *data) |
| int | os2ip (mpw *idata, size_t isize, const byte *osdata, size_t ossize) |
| int | i2osp (byte *osdata, size_t ossize, const mpw *idata, size_t isize) |
| int | hs2ip (mpw *idata, size_t isize, const char *hsdata, size_t hssize) |
The routines declared here are all low-level operations, most of them suitable to be implemented in assembler. Prime candidates are in order of importance (according to gprof):
With some smart use of available assembler instructions, it's possible to speed these routines up by a factor of 2 to 4.