/***************************************************************
	 *								*
	 *	gint.h							*
	 *								*
	 *	Header file for large-integer arithmetic library giants	*
	 *								*
	 *	Updates:						*
	 *          18 Jul 99  REC  Added fer_mod().			*
	 *          30 Apr 98  JF   USE_ASSEMBLER_MUL removed		*
	 *          29 Apr 98  JF   Function prototypes cleaned up	*
	 *	    20 Apr 97  RDW					*
	 *								*
	 *	(c) 1997 Perfectly Scientific, Inc.			*
	 *	All Rights Reserved.					*
	 *								*
	 ***************************************************************/

#define EXT __declspec(dllexport) 

 /***************************************************************
 *								*
 * Error Codes							*
 *								*
 ***************************************************************/

#define OVFLOW        2
#define SIGN	      3

#define AUTO_MUL      0
#define GRAMMAR_MUL   1
#define FFT_MUL       2
#define KARAT_MUL     3

 /***************************************************************
 *								*
 * Preprocessor definitions					*
 *								*
 ***************************************************************/

/* 
 * 2^(16*MAX_SHORTS)-1 will fit into a giant, but take care:
 * one usually has squares, etc. of giants involved, and
 * every intermediate giant in a calculation must fit into
 * this many shorts. Thus, if you want systematically to effect
 * arithmetic on B-bit operands, you need MAX_SHORTS > B/8,
 * preferably a tad larger than this; e.g. MAX_SHORTS > B/7.
 */

#define MAX_SHORTS (1<<19)	

#define D_MAX 600
#define NUM_PRIMES 6542 /* PrimePi[2^16]. */
#define INFINITY (-1)
#define FALSE 0
#define TRUE 1

#define TWOPI    (double)(2*3.1415926535897932384626433)
#define SQRTHALF (double)(0.707106781186547524400844362104)
#define TWO16    (double)(65536.0)
#define TWOM16   (double)(0.0000152587890625)

// Decimal digit ceiling in digit-input routines. 
#define MAX_DIGITS 10000

// Next, mumber of shorts per operand at which Karatsuba breaks over. 
#define KARAT_BREAK 40
                                                                
// Next, mumber of shorts per operand at which FFT breaks over. 
#define FFT_BREAK 200

#define newmin(a,b) ((a)<(b)? (a) : (b))
#define newmax(a,b) ((a)>(b)? (a) : (b))

// The limit below which hgcd is too ponderous 
#define GCDLIMIT 5000

// The limit below which ordinary ints will be used 
#define INTLIMIT 31

// Size by which to increment the stack used in pushg() and popg(). 
#define	STACK_GROW 16

 /***************************************************************
 *								*
 * Structure definitions					*
 *								*
 ***************************************************************/

typedef struct { 
  int sign;
  unsigned short n[1];	/* number of shorts = abs(sign) */
} giantstruct;

typedef giantstruct *giant;

typedef struct _matrix {
	giant ul;	/* upper left  */
	giant ur;	/* upper right */
	giant ll;	/* lower left  */
	giant lr;	/* lower right */
} *gmatrix;

typedef struct {
	double re;
	double im;
} complex;

#define MSGMAX 257

typedef struct { 
	int  yes; 
	int  parnr; 
	char * plasterror;
	char * pversion;
	char version   [MSGMAX];
	char lasterror [MSGMAX];
} einfo;

#define SZMAX 32000

typedef struct { 
	int sz; 
	char TheData [SZMAX];
} results;


 /***************************************************************
 *								*
 * Function Prototypes						*
 *								*
 ***************************************************************/

 /***************************************************************
 *							       	*
 * Initialization and utility functions			       	*
 *							      	*
 ***************************************************************/

// trig lookups. 
void	init_sinCos(int);
double	s_sin(int);
double	s_cos(int);
void    init_ellmul (long size);
int	xergint (char *srname, int info);

// stack handling functions. 
EXT giant popg (void);
EXT void pushg (int);

// Creates a new giant, numshorts = INFINITY invokes the maximum MAX_SHORTS. 
EXT giant newgiant (int numshorts);

// Creates a new giant matrix, but does not malloc the component giants. 
EXT gmatrix newgmatrix (void);

// Returns the bit-length n; e.g. n=7 returns 3. 
EXT int bitlen (giant n);

// Returns the value of the pos bit of n. 
EXT int bitval (giant n, int pos);

// Returns whether g is one. 
EXT int isone (giant g);

// Returns whether g is zero. 
EXT int isZero (giant g);

// Copies one giant to another.
EXT void gtog (giant src, giant dest);

// Integer <-> giant. 
EXT void itog (int n, giant g);
EXT signed int gtoi (giant);

// Returns the sign of g: -1, 0, 1. 
EXT int gsign (giant g);

// Returns 1, 0, -1 as a>b, a=b, a<b. 
EXT int gcompg (giant a, giant b);

// Set AUTO_MUL for automatic FFT crossover (this is the
// default), set FFT_MUL for forced FFT multiply, set
// GRAMMAR_MUL for forced grammar school multiply. 
EXT void setmulmode (int mode);

 /***************************************************************
 *							     	*
 * Math Functions						*
 *								*
 ***************************************************************/

// g := -g. 
EXT void negg (giant g);

// g := |g|.
EXT void absg (giant g);

// g += i, with i non-negative and < 2^16. 
EXT void iaddg (int i,giant g);

// g -= i, with i non-negative and < 2^16. 
EXT void isubg (int i,giant g);

// b += a. 
EXT void addg (giant a, giant b);

// b -= a. 
EXT void subg (giant a, giant b);

// Returns the number of trailing zero bits in g. 
EXT int numtrailzeros (giant g);

// u becomes greatest power of two not exceeding u/v. 
EXT void bdivg (giant v, giant u);

// Same as invg, but uses bdivg. 
EXT int binvg (giant n, giant x);

// If 1/x exists (mod n), 1 is returned and x := 1/x.  If
// inverse does not exist, 0 is returned and x := GCD(n, x). 
EXT int invg (giant n, giant x);
EXT int mersenneinvg (int q, giant x);

// Classical GCD, x:= GCD(n, x). 
EXT void cgcdg (giant n, giant x);

// General GCD, x:= GCD(n, x). 
EXT void gcdg (giant n, giant x);

// Binary GCD, x:= GCD(n, x). 
EXT void bgcdg (giant n, giant x);

// g := m^n, no mod is performed.
EXT void powerg (int a, int b, giant g);

// r becomes the steady-state reciprocal 2^(2b)/d, where b = bit-length of d-1. 
EXT void make_recip (giant d, giant r);

// n := [n/d], d positive, using stored reciprocal directly. 
EXT void divg_via_recip (giant d, giant r, giant n);

// n := n % d, d positive, using stored reciprocal directly. 
EXT void modg_via_recip (giant d, giant r, giant n);

// num := num % den, any positive den. 
EXT void modg (giant den, giant num);

// g := g/n, and (g mod n) is returned. 
EXT int idivg (int n, giant g);

// num := [num/den], any positive den. 
EXT void divg (giant den, giant num);

// x := x^n (mod z). 
EXT void powermod (giant x, int n, giant z);

// x := x^n (mod z). 
EXT void powermodg (giant x, giant n, giant z);

// x := x^n (mod 2^q+1). 
EXT void fermatpowermod (giant x, int n, int q);

// x := x^n (mod 2^q+1). 
EXT void fermatpowermodg (giant x, giant n, int q);

// x := x^n (mod 2^q-1). 
EXT void mersennepowermod (giant x, int n, int q);

// x := x^n (mod 2^q-1). 
EXT void mersennepowermodg (giant x, giant n, int q);

// Switched by modmode
EXT void s_modg (giant N, giant t);

// Shift g left by bits, introducing zeros on the right. 
EXT void gshiftleft (int bits, giant g);

// Shift g right by bits, losing bits on the right. 
EXT void gshiftright (int bits, giant g);

// dest becomes lowermost n bits of src. Equivalent to dest = src % 2^n. 
EXT void extractbits (int n, giant src, giant dest);

// negate g. g is mod 2^n+1. 
EXT void fermatnegate (int n, giant g);

// g := g (mod 2^n-1). 
EXT void mersennemod (int n, giant g);

// g := g (mod 2^n+1). 
EXT void fermatmod (int n, giant g);

// g := g (mod 2^n+1). 
EXT void fer_mod (int n, giant g, giant modulus);

// g *= s. 
EXT void smulg (unsigned short s, giant g);

// g *= g. 
EXT void squareg (giant g);

// b *= a. 
EXT void mulg (giant a, giant b);

// A giant gcd.  Modifies its arguments. 
EXT void ggcd (giant xx, giant yy);

// elliptic functions
EXT int ell_even  (giant x1,giant z1,giant x2,giant z2,giant An,giant Ad,giant N);
EXT int ell_odd   (giant x1,giant z1,giant x2,giant z2,giant xor,giant zor,giant N);
EXT int ell_mul   (giant xx,giant zz,int n,giant An,giant Ad,giant N);

EXT void choose12 (giant x,giant z,int k,giant An,giant Ad,giant N);

// misc
EXT int  GetGINTinfo	 (void);
EXT int  ResetGINTerror	 (void);
EXT int  giantinit 	 (int bits);

EXT int  bigprimeq 	 (giant x);
EXT int  special_mulg    (giant y, giant x);
EXT int  special_squareg (giant y);

EXT int  ResetString	 (void);
EXT int  gtos		 (giant thegiant);
EXT int  tostring	 (const char *fmt, ...);
EXT int  gianttos 	 (giant g);
EXT int  stringtog	 (char *inbuf, int numdigits, giant theg);

// EOF