libbeecrypt-dev 4.2.1-4 / usr / include / beecrypt / mp.h

/*
 * Copyright (c) 2002, 2003 Bob Deblier
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*!\file mp.h
 * \brief Multi-precision integer routines.
 *
 * 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):
 * <ul>
 *  <li>mpaddmul
 *  <li>mpsetmul 
 *  <li>mpaddsqrtrc
 *  <li>mpsub
 *  <li>mpadd
 * </ul>
 *
 * With some smart use of available assembler instructions, it's possible
 * to speed these routines up by a factor of 2 to 4.
 *
 * \author Bob Deblier <bob.deblier@telenet.be>
 * \ingroup MP_m
 */

#ifndef _MP_H
#define _MP_H

#include "beecrypt/api.h"
#include "beecrypt/mpopt.h"

#define MP_HWBITS	(MP_WBITS >> 1)
#define MP_WBYTES	(MP_WBITS >> 3)
#define MP_WNIBBLES	(MP_WBITS >> 2)

#if (MP_WBITS == 64)
# define MP_WORDS_TO_BITS(x)	((x) << 6)
# define MP_WORDS_TO_NIBBLES(x)	((x) << 4)
# define MP_WORDS_TO_BYTES(x)	((x) << 3)
# define MP_BITS_TO_WORDS(x)	((x) >> 6)
# define MP_NIBBLES_TO_WORDS(x)	((x) >> 4)
# define MP_BYTES_TO_WORDS(x)	((x) >> 3)
#elif (MP_WBITS == 32)
# 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)
#else
# error
#endif

#define MP_MSBMASK	(((mpw) 0x1) << (MP_WBITS-1))
#define MP_LSBMASK	 ((mpw) 0x1)
#define MP_ALLMASK	~((mpw) 0x0)

#ifdef __cplusplus
extern "C" {
#endif

#ifndef ASM_MPCOPY
# define mpcopy(size, dst, src) memcpy(dst, src, MP_WORDS_TO_BYTES(size))
#else
BEECRYPTAPI
void mpcopy(size_t size, mpw* dest, const mpw* src);
#endif

#ifndef ASM_MPMOVE
# define mpmove(size, dst, src) memmove(dst, src, MP_WORDS_TO_BYTES(size))
#else
BEECRYPTAPI
void mpmove(size_t size, mpw* dest, const mpw* src);
#endif

/*!\fn void mpzero(size_t size, mpw* data)
 * \brief This function zeroes a multi-precision integer of a given size.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpzero(size_t size, mpw* data);

/*!\fn void mpfill(size_t size, mpw* data, mpw fill)
 * \brief This function fills each word of a multi-precision integer with a
 *  given value.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \param fill The value fill the data with.
 */
BEECRYPTAPI
void mpfill(size_t size, mpw* data, mpw fill);

/*!\fn int mpodd(size_t size, const mpw* data)
 * \brief This functions tests if a multi-precision integer is odd.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if odd
 * \retval 0 if even
 */
BEECRYPTAPI
int mpodd (size_t size, const mpw* data);

/*!\fn int mpeven(size_t size, const mpw* data)
 * \brief This function tests if a multi-precision integer is even.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if even
 * \retval 0 if odd
 */
BEECRYPTAPI
int mpeven(size_t size, const mpw* data);

/*!\fn int mpz(size_t size, const mpw* data)
 * \brief This function tests if a multi-precision integer is zero.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if zero
 * \retval 0 if not zero
 */
BEECRYPTAPI
int mpz  (size_t size, const mpw* data);

/*!\fn int mpnz(size_t size, const mpw* data)
 * \brief This function tests if a multi-precision integer is not zero.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if not zero
 * \retval 0 if zero
 */
BEECRYPTAPI
int mpnz (size_t size, const mpw* data);

/*!\fn int mpeq(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if two multi-precision integers of the same size
 *  are equal.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if equal
 * \retval 0 if not equal
 */
BEECRYPTAPI
int mpeq (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpne(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if two multi-precision integers of the same size
 *  differ.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if not equal
 * \retval 0 if equal
 */
BEECRYPTAPI
int mpne (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpgt(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of the same size is greater than the second.
 * \note The comparison treats the arguments as unsigned.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if greater
 * \retval 0 if less or equal
 */
BEECRYPTAPI
int mpgt (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mplt(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of the same size is less than the second.
 * \note The comparison treats the arguments as unsigned.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if less
 * \retval 0 if greater or equal
 */
BEECRYPTAPI
int mplt (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpge(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of the same size is greater than or equal to the second.
 * \note The comparison treats the arguments as unsigned.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if greater or equal
 * \retval 0 if less
 */
BEECRYPTAPI
int mpge (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mple(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of the same size is less than or equal to the second.
 * \note The comparison treats the arguments as unsigned.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if less or equal
 * \retval 0 if greater
 */
BEECRYPTAPI
int mple (size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpcmp(size_t size, const mpw* xdata, const mpw* ydata)
 * \brief This function performs a comparison of two multi-precision
 *  integers of the same size.
 * \note The comparison treats the arguments as unsigned.
 * \retval -1 if x < y
 * \retval 0 if x == y
 * \retval 1 if x > y
 */
BEECRYPTAPI
int mpcmp(size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpeqx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if two multi-precision integers of different
 *  size are equal.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if equal
 * \retval 0 if not equal
 */
BEECRYPTAPI
int mpeqx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpnex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if two multi-precision integers of different
 *  size are equal.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if equal
 * \retval 0 if not equal
*/
BEECRYPTAPI
int mpnex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpgtx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of different size is greater than the second.
 * \note The comparison treats the arguments as unsigned.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if greater
 * \retval 0 if less or equal
 */
BEECRYPTAPI
int mpgtx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpltx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of different size is less than the second.
 * \note The comparison treats the arguments as unsigned.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if less
 * \retval 0 if greater or equal
 */
BEECRYPTAPI
int mpltx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpgex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of different size is greater than or equal to the second.
 * \note The comparison treats the arguments as unsigned.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if greater or equal
 * \retval 0 if less
 */
BEECRYPTAPI
int mpgex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mplex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function tests if the first of two multi-precision integers
 *  of different size is less than or equal to the second.
 * \note The comparison treats the arguments as unsigned.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if less or equal
 * \retval 0 if greater
 */
BEECRYPTAPI
int mplex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpcmpx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function performs a comparison of two multi-precision
 *  integers of the different size.
 * \note The comparison treats the arguments as unsigned.
 * \retval -1 if x < y
 * \retval 0 if x == y
 * \retval 1 if x > y
 */
BEECRYPTAPI
int mpcmpx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpisone(size_t size, const mpw* data)
 * \brief This functions tests if the value of a multi-precision integer is
 *  equal to one.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if one
 * \retval 0 if not one
 */
BEECRYPTAPI
int mpisone(size_t size, const mpw* data);

/*!\fn int mpistwo(size_t size, const mpw* data)
 * \brief This function tests if the value of a multi-precision integer is
 *  equal to two.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if two
 * \retval 0 if not two
 */
BEECRYPTAPI
int mpistwo(size_t size, const mpw* data);

/*!\fn int mpleone(size_t size, const mpw* data);
 * \brief This function tests if the value of a multi-precision integer is
 *  less than or equal to one.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if less than or equal to one.
 * \retval 0 if greater than one.
 */
BEECRYPTAPI
int mpleone(size_t size, const mpw* data);

/*!\fn int mpeqmone(size_t size, const mpw* xdata, const mpw* ydata);
 * \brief This function tests if multi-precision integer x is equal to y
 *  minus one.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \retval 1 if less than or equal to one.
 * \retval 0 if greater than one.
 */
BEECRYPTAPI
int mpeqmone(size_t size, const mpw* xdata, const mpw* ydata);

/*!\fn int mpmsbset(size_t size, const mpw* data)
 * \brief This function tests if the most significant bit of a multi-precision
 *  integer is set.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if set
 * \retval 0 if not set
 */
BEECRYPTAPI
int mpmsbset(size_t size, const mpw* data);

/*!\fn int mplsbset(size_t size, const mpw* data)
 * \brief This function tests if the leiast significant bit of a multi-precision
 *  integer is set.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 * \retval 1 if set
 * \retval 0 if not set
 */
BEECRYPTAPI
int mplsbset(size_t size, const mpw* data);

/*!\fn void mpsetmsb(size_t size, mpw* data)
 * \brief This function sets the most significant bit of a multi-precision
 *  integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpsetmsb(size_t size, mpw* data);

/*!\fn void mpsetlsb(size_t size, mpw* data)
 * \brief This function sets the least significant bit of a multi-precision
 *  integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpsetlsb(size_t size, mpw* data);

/*!\fn void mpclrmsb(size_t size, mpw* data)
 * \brief This function clears the most significant bit of a multi-precision
 *  integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpclrmsb(size_t size, mpw* data);

/*!\fn void mpclrlsb(size_t size, mpw* data)
 * \brief This function clears the least significant bit of a multi-precision
 *  integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpclrlsb(size_t size, mpw* data);

/*!\fn mpand(size_t size, mpw* xdata, const mpw* ydata)
 * \brief This function computes the bit-wise AND of two multi-precision
 *  integers. Modifies xdata.
 * \param size The size of the multi-precision integers.
 * \param xdata The multi-precision integer data.
 * \param ydata The multi-precision integer data.
 */
BEECRYPTAPI
void mpand(size_t size, mpw* xdata, const mpw* ydata);

/*!\fn void mpor(size_t size, mpw* xdata, const mpw* ydata) 
 * \brief This function computes the bit-wise OR of two multi-precision
 *  integers. Modifies xdata.
 * \param size The size of the multi-precision integer.
 * \param xdata The multi-precision integer data.
 * \param ydata The multi-precision integer data.
 */
BEECRYPTAPI
void mpor(size_t size, mpw* xdata, const mpw* ydata);

/*!\fn void mpxor(size_t size, mpw* xdata, const mpw* ydata) 
 * \brief This function computes the bit-wise XOR of two multi-precision
 *  integers. Modifies xdata.
 * \param size The size of the multi-precision integer.
 * \param xdata The multi-precision integer data.
 * \param ydata The multi-precision integer data.
 */
BEECRYPTAPI
void mpxor(size_t size, mpw* xdata, const mpw* ydata);

/*!\fn mpnot(size_t size, mpw* data)
 * \brief This function flips all bits of a multi-precision integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpnot(size_t size, mpw* data);

/*!\fn void mpsetw(size_t size, mpw* xdata, mpw y)
 * \brief 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.
 * \param size The size of the multi-precision integer.
 * \param xdata The multi-precision integer data.
 * \param y The value to be assigned.
 */
BEECRYPTAPI
void mpsetw(size_t size, mpw* xdata, mpw y);

/*!\fn void mpsetws(size_t size, mpw* xdata, size_t y)
 * \brief This function sets the value of a multi-precision integer to the
 *  given word. The given value is copied into the least significant word(s),
 *  while the most significant words are zeroed.
 * \param size The size of the multi-precision integer.
 * \param xdata The multi-precision integer data.
 * \param y The value.
 */
BEECRYPTAPI
void mpsetws(size_t size, mpw* xdata, size_t y);

/*!\fn void mpsetx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief 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.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 */
BEECRYPTAPI
void mpsetx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpaddw(size_t size, mpw* xdata, mpw y)
 * \brief This function adds one word to a multi-precision integer.
 *  The performed operation is in pseudocode: x += y.
 * \param size The size of the multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param y The multi-precision word.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpaddw(size_t size, mpw* xdata, mpw y);

/*!\fn int mpadd(size_t size, mpw* xdata, const mpw* ydata)
 * \brief This function adds two multi-precision integers of equal size.
 *  The performed operation is in pseudocode: x += y.
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpadd (size_t size, mpw* xdata, const mpw* ydata);

/*!\fn int mpaddx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function adds two multi-precision integers of different size.
 *  The performed operation in pseudocode: x += y.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpaddx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn int mpsubw(size_t size, mpw* xdata, mpw y)
 * \brief This function subtracts one word to a multi-precision integer.
 *  The performed operation in pseudocode: x -= y
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param y The multi-precision word.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpsubw(size_t size, mpw* xdata, mpw y);

/*!\fn int mpsub(size_t size, mpw* xdata, const mpw* ydata)
 * \brief This function subtracts two multi-precision integers of equal size.
 *  The performed operation in pseudocode: x -= y
 * \param size The size of the multi-precision integers.
 * \param xdata The first multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpsub (size_t size, mpw* xdata, const mpw* ydata);

/*!\fn int mpsubx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function subtracts two multi-precision integers of different
 *  size. The performed operation in pseudocode: x -= y.
 * \param xsize The size of the first multi-precision integer.
 * \param xdata The first multi-precision integer.
 * \param ysize The size of the second multi-precision integer.
 * \param ydata The second multi-precision integer.
 * \return The carry-over value of the operation; this value is either 0 or 1.
 */
BEECRYPTAPI
int mpsubx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata);

BEECRYPTAPI
int mpmultwo(size_t size, mpw* data);

/*!\fn void mpneg(size_t size, mpw* data)
 * \brief This function negates a multi-precision integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
void mpneg(size_t size, mpw* data);

/*!\fn size_t mpsize(size_t size, const mpw* data)
 * \brief This function returns the true size of a multi-precision
 *  integer, after stripping leading zero words.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
size_t mpsize(size_t size, const mpw* data);

/*!\fn size_t mpbits(size_t size, const mpw* data)
 * \brief This function returns the number of significant bits
 *  in a multi-precision integer.
 * \param size The size of the multi-precision integer.
 * \param data The multi-precision integer data.
 */
BEECRYPTAPI
size_t mpbits(size_t size, const mpw* data);

BEECRYPTAPI
size_t mpmszcnt(size_t size, const mpw* data);

BEECRYPTAPI
size_t mplszcnt(size_t size, const mpw* data);

BEECRYPTAPI
void mplshift(size_t size, mpw* data, size_t count);

BEECRYPTAPI
void mprshift(size_t size, mpw* data, size_t count);

BEECRYPTAPI
size_t mprshiftlsz(size_t size, mpw* data);

BEECRYPTAPI
size_t mpnorm(size_t size, mpw* data);

BEECRYPTAPI
void mpdivtwo (size_t size, mpw* data);

BEECRYPTAPI
void mpsdivtwo(size_t size, mpw* data);

/*!\fn mpw mpsetmul(size_t size, mpw* result, const mpw* data, mpw y)
 * \brief This function performs a multi-precision multiply-setup.
 *
 * This function is used in the computation of a full multi-precision
 * multiplication. By using it we can shave off a few cycles; otherwise we'd
 * have to zero the least significant half of the result first and use
 * another call to the slightly slower mpaddmul function.
 *
 * \param size The size of multi-precision integer multiplier.
 * \param result The place where result will be accumulated.
 * \param data The multi-precision integer multiplier.
 * \param y The multiplicand.
 * \return The carry-over multi-precision word.
 */
BEECRYPTAPI
mpw mpsetmul   (size_t size, mpw* result, const mpw* data, mpw y);

/*!\fn mpw mpaddmul(size_t size, mpw* result, const mpw* data, mpw y)
 * \brief This function performs a mult-precision multiply-accumulate.
 *
 * This function is used in the computation of a full multi-precision
 * multiplication. It computes the product-by-one-word and accumulates it with
 * the previous result.
 *
 * \param size The size of multi-precision integer multiplier.
 * \param result The place where result will be accumulated.
 * \param data The multi-precision integer multiplier.
 * \param y The multiplicand.
 * \retval The carry-over multi-precision word.
 */
BEECRYPTAPI
mpw mpaddmul   (size_t size, mpw* result, const mpw* data, mpw y);

/*!\fn void mpaddsqrtrc(size_t size, mpw* result, const mpw* data)
 * \brief This function is used in the calculation of a multi-precision
 * squaring.
 */
BEECRYPTAPI
void mpaddsqrtrc(size_t size, mpw* result, const mpw* data);

/*!\fn void mpmul(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata)
 * \brief This function computes a full multi-precision product.
 */
BEECRYPTAPI
void mpmul(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata);

/*!\fn void mpsqr(mpw* result, size_t size, const mpw* data)
 * \brief This function computes a full multi-precision square.
 */
BEECRYPTAPI
void mpsqr(mpw* result, size_t size, const mpw* data);

BEECRYPTAPI
void mpgcd_w(size_t size, const mpw* xdata, const mpw* ydata, mpw* result, mpw* wksp);

BEECRYPTAPI
int  mpextgcd_w(size_t size, const mpw* xdata, const mpw* ydata, mpw* result, mpw* wksp);

BEECRYPTAPI
mpw mppndiv(mpw xhi, mpw xlo, mpw y);

BEECRYPTAPI
void mpmod (mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw*ydata, mpw* wksp);

BEECRYPTAPI
void mpndivmod(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata, mpw* wksp);

/*
 * Output Routines
 */

BEECRYPTAPI
void mpprint(size_t size, const mpw* data);

BEECRYPTAPI
void mpprintln(size_t size, const mpw* data);

BEECRYPTAPI
void mpfprint(FILE* f, size_t size, const mpw* data);

BEECRYPTAPI
void mpfprintln(FILE* f, size_t size, const mpw* data);

/*
 * Conversion Routines
 */

BEECRYPTAPI
int i2osp(byte* osdata, size_t ossize, const mpw* idata, size_t isize);

BEECRYPTAPI
int os2ip(mpw* idata, size_t isize, const byte* osdata, size_t ossize);

BEECRYPTAPI
int hs2ip(mpw* idata, size_t isize, const char* hsdata, size_t hssize);

#ifdef __cplusplus
}
#endif

#endif