.Bf -symbolic This interface is obsolete in favor of the **crypto**(3)

.Vt BIGNUM library.

.Ef **libmp** is the traditional *BSD * multiple precision integer arithmetic library. It has a number of problems, and is unsuitable for use in any programs where reliability is a concern. It is provided here for compatibility only.

These routines perform arithmetic on integers of arbitrary precision stored using the defined type

.Vt MINT . Pointers to

.Vt MINT are initialized using ` itom` or ` xtom`, and must be recycled with ` mfree` when they are no longer needed. Routines which store a result in one of their arguments expect that the latter has also been initialized prior to being passed to it. The following routines are defined and implemented:

* "MINT *"* ` itom "short n"`;

* "MINT *"* ` xtom "const char *s"`;

* "char *"* ` mtox "const MINT *mp"`;

* void* ` mfree "MINT *mp"`;

` itom`

returns an

.Vt MINT

with the value of

* n*.

` xtom`

returns an

.Vt MINT

with the value of

* s*,

which is treated to be in hexadecimal.

The return values from

` itom`

and

` xtom`

must be released with

` mfree`

when they are no longer needed.

` mtox`

returns a null-terminated hexadecimal string having the value of

* mp*;

its return value must be released with

` free`

(**free**(3))

when it is no longer needed.

* void* ` madd "const MINT *mp1" "const MINT *mp2" "MINT *rmp"`;

* void* ` msub "const MINT *mp1" "const MINT *mp2" "MINT *rmp"`;

* void* ` mult "const MINT *mp1" "const MINT *mp2" "MINT *rmp"`;

` madd`,

` msub`,

and

` mult`

store the sum, difference, or product, respectively, of

* mp1*

and

* mp2*

in

* rmp*.

* void* ` mdiv "const MINT *nmp" "const MINT *dmp" "MINT *qmp" "MINT *rmp"`;

* void* ` sdiv "const MINT *nmp" "short d" "MINT *qmp" "short *ro"`;

` mdiv`

computes the quotient and remainder of

* nmp*

and

* dmp*

and stores the result in

* qmp*

and

* rmp*,

respectively.

` sdiv`

is similar to

` mdiv`

except the divisor

*( dmp*

or

* d*)

and remainder

*( rmp*

or

* ro*)

are ordinary integers.

* void* ` pow "const MINT *bmp" "const MINT *emp" "const MINT *mmp" "MINT *rmp"`;

* void* ` rpow "const MINT *bmp" "short e" "MINT *rmp"`;

` rpow`

computes the result of

* bmp*

raised to the

* emp th*

power and reduced modulo

* mmp*;

the result is stored in

* rmp*.

` pow`

computes the result of

* bmp*

raised to the

* e th*

power and stores the result in

* rmp*.

* void* ` min "MINT *mp"`;

* void* ` mout "const MINT *mp"`;

` min`

reads a line from standard input, tries to interpret it as a decimal

number, and if successful, stores the result in

* mp*.

` mout`

prints the value, in decimal, of

* mp*

to standard output (without a trailing newline).

* void* ` gcd "const MINT *mp1" "const MINT *mp2" "MINT *rmp"`;

` gcd`

computes the greatest common divisor of

* mp1*

and

* mp2*

and stores the result in

* rmp*.

* int* ` mcmp "const MINT *mp1" "const MINT *mp2"`;

* mcmp*

compares the values of

* mp1*

and

* mp2*

and returns

0 if the two values are equal,

a value greater than 0 if

* mp1*

is greater than

* mp2*,

and a value less than 0 if

* mp2*

is greater than

* mp1*.

* void* ` move "const MINT *smp" "MINT *tmp"`;

` move`

copies the value of

* smp*

to

* tmp*

(both values must be initialized).