Sindbad~EG File Manager

/* Bignum arithmetic package by M. Beeson */
/* Uses dynamic arrays instead of linked lists */
/* includes  addition, subtraction, multiplication, division, exponentiation,
   gcd, conversion to decimal form, and output.  */

/* bignum digits are 'unsigned', which makes them either 16 or 32 bits on
   the architectures in use at the time of writing.  However, the code should
   also work on future architectures with for example 64 bit integers, except
   as follows:  Functions 'longmult'  and 'longdiv' are written in assembly
   language and conditionally compiled.  They will work correctly for 16-bit
   ints and 32-bit longs or for 32-bit ints and 32-bit longs; if in
   the future we have 32-bit ints and 64-bit longs or eventually even
   64-bit ints and 64-bit longs,  more work will be required.
*/


typedef  unsigned digit;

/* don't change the definition of digit;  the use of MAX assumes that
   digits and the .ln field of bignums are the same. */

typedef struct { unsigned ln;  /* number of "digits" */
                 digit *val;   /*least significant digits first */
               } bignum;

typedef struct {  int sign;   /* 1 is positive, -1 is negative, 0 is zero */
                  bignum n;   /* numerator */
                  bignum d;   /* denominator */
                }  bigrat;

digit *getspace(unsigned);   /* bignum.c */
void freespace(digit *);     /* release space allocated by getspace */

#define NN 32U
/* Microsoft Visual C 5.0 doesn't compile the following properly.
It evaluates (trialq >> NN) to a nonzero value when trialq is a digit!

#define NN  ((unsigned)(sizeof(digit)<<3))
*/
#define LEFTDIGIT ((digit)(1 << (NN-1)))     /* 1 in the leftmost place of a digit */
#define INC(i)  ((i==0)?1:((i==1)?2:((i==2)?0:(i++%3))))  /* ++i mod 3 */

/* Function prototypes  */
int smallgcd(digit,digit);
void longmult(digit x, digit y, digit *lo, digit *hi);
void longdiv(unsigned x, unsigned y, unsigned z, unsigned *q, unsigned *r);
void bigplus2(bignum x, bignum y, bignum *ansp);
void bigplus(bignum x, bignum y, bignum *ansp);
void mult_by_digit2(bignum x, digit d, bignum *ansp);
void mult_by_digit(bignum x, digit d, bignum *ansp);
void bigmult2(bignum x, bignum y, bignum *ansp);
void bigmult(bignum x, bignum y, bignum *ansp);
int compare(bignum x, bignum y);
digit mod_digit(bignum x, digit y);
bignum btod(bignum x, unsigned n);
void bigminus2(bignum x, bignum y, bignum *ansp);
void bigminus(bignum x, bignum y, bignum *ansp);
void right_shift(bignum x, int i, bignum *y);
void divide_by_digit(bignum x, digit y, bignum *q, digit *r);
void divide_by_digit2(bignum x, digit y, bignum *q, digit *r);
bignum long_to_bignum(unsigned long x);
int bigdivide(bignum x, bignum y, bignum *q, bignum *r);
int bigdivide2(bignum x, bignum y, bignum *q, bignum *r);
int bigpower(bignum x, digit d, bignum *ansp);
int bigsqrt(bignum x, bignum *ansp, bignum *remp);
int bigsqrt2(bignum x, bignum *ans, bignum *remp);
void biggcd(bignum x, bignum y, bignum *ansp);
int convert_and_print(bignum x, int separator);
int bigroot(unsigned n, bignum x, bignum *ansp, bignum *remp);
int bigroot2(unsigned n, bignum x, bignum *ansp, bignum *remp);
int bigfactorial(unsigned n, bignum *ansp);
int string_bignum(char *s, unsigned n, bignum *xp);
char *bignum_string(bignum x, int separator);
int get_small_factors(bignum, unsigned *, int *, bignum *,unsigned *);
void modexp(bignum, bignum,bignum, bignum *);  /* file bigmod.c */
void modexp2(bignum, bignum,bignum, bignum *);  /* file bigmod.c */
int bignum_double(bignum,double *);
int bigrat_double(bignum,bignum, double *);
void fftmult(bignum,bignum,bignum *);
void mod2(bignum m, bignum u, bignum *ansp);
void bigplusmod2(bignum m, bignum a, bignum b, bignum *ans);
void bigplusmod(bignum m, bignum a, bignum b, bignum *ans);
void bigmultmod2(bignum m, bignum a, bignum b, bignum *ans);
void mod(bignum m, bignum u, bignum *ansp);
void bigmultmod(bignum m, bignum a, bignum b, bignum *ans);
#define freespace(x)  free2((digit *)(x))
unsigned addmod(unsigned a, unsigned b, unsigned m);
unsigned mulmod(unsigned a, unsigned b, unsigned m);
int intbinomial(long n, long k, bignum *ans);
int ratbinomial(long n, long d, long k, bigrat *ans);
bignum bigint(unsigned long n);
int bignum_long(bignum b, long *ans);
int primality_test(bignum b);
int exact_bernoulli(long, bignum *, bignum *);
int exact_eulernumber(long n, bignum *ans);
#define NSTOREDBERNOULLIS 200   // twice the dimension of bernoulli_strings and euler_strings