zmath.h

Calc Software Package for Number Calc

extern DLL BOOL zcmp(ZVALUE z1, ZVALUE z2);


/*
 * More complicated numeric functions.
 */
extern DLL FULL uugcd(FULL i1, FULL i2);
extern DLL long iigcd(long i1, long i2);
extern DLL void zgcd(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL void zlcm(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL void zreduce(ZVALUE z1, ZVALUE z2, ZVALUE *z1res, ZVALUE *z2res);
extern DLL void zfact(ZVALUE z, ZVALUE *dest);
extern DLL void zperm(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL int zcomb(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL FLAG zjacobi(ZVALUE z1, ZVALUE z2);
extern DLL void zfib(ZVALUE z, ZVALUE *res);
extern DLL void zpowi(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL void ztenpow(long power, ZVALUE *res);
extern DLL void zpowermod(ZVALUE z1, ZVALUE z2, ZVALUE z3, ZVALUE *res);
extern DLL BOOL zmodinv(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL BOOL zrelprime(ZVALUE z1, ZVALUE z2);
extern DLL long zlog(ZVALUE z1, ZVALUE z2);
extern DLL long zlog10(ZVALUE z, BOOL *was_10_power);
extern DLL long zdivcount(ZVALUE z1, ZVALUE z2);
extern DLL long zfacrem(ZVALUE z1, ZVALUE z2, ZVALUE *rem);
extern DLL long zgcdrem(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL long zdigits(ZVALUE z1);
extern DLL long zdigit(ZVALUE z1, long n);
extern DLL FLAG zsqrt(ZVALUE z1, ZVALUE *dest, long R);
extern DLL void zroot(ZVALUE z1, ZVALUE z2, ZVALUE *dest);
extern DLL BOOL zissquare(ZVALUE z);
extern DLL void zhnrmod(ZVALUE v, ZVALUE h, ZVALUE zn, ZVALUE zr, ZVALUE *res);


/*
 * Prime related functions.
 */
extern DLL FLAG zisprime(ZVALUE z);
extern DLL FULL znprime(ZVALUE z);
extern DLL FULL next_prime(FULL v);
extern DLL FULL zpprime(ZVALUE z);
extern DLL void zpfact(ZVALUE z, ZVALUE *dest);
extern DLL BOOL zprimetest(ZVALUE z, long count, ZVALUE skip);
extern DLL BOOL zredcprimetest(ZVALUE z, long count, ZVALUE skip);
extern DLL BOOL znextcand(ZVALUE z1, long count, ZVALUE skip, ZVALUE res, ZVALUE mod, ZVALUE *cand);
extern DLL BOOL zprevcand(ZVALUE z1, long count, ZVALUE skip, ZVALUE res, ZVALUE mod, ZVALUE *cand);
extern DLL FULL zlowfactor(ZVALUE z, long count);
extern DLL FLAG zfactor(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL long zpix(ZVALUE z1);
extern DLL void zlcmfact(ZVALUE z, ZVALUE *dest);


/*
 * Misc misc functions. :-)
 */
extern DLL void zsquaremod(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL void zminmod(ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL BOOL zcmpmod(ZVALUE z1, ZVALUE z2, ZVALUE z3);
extern DLL void zio_init(void);


/*
 * These functions are for internal use only.
 */
extern DLL void ztrim(ZVALUE *z);
extern DLL void zshiftr(ZVALUE z, long n);
extern DLL void zshiftl(ZVALUE z, long n);
extern DLL HALF *zalloctemp(LEN len);


/*
 * Modulo arithmetic definitions.
 * Structure holding state of REDC initialization.
 * Multiple instances of this structure can be used allowing
 * calculations with more than one modulus at the same time.
 * Len of zero means the structure is not initialized.
 */
typedef struct {
	LEN len;		/* number of words in binary modulus */
	ZVALUE mod;		/* modulus REDC is computing with */
	ZVALUE inv;		/* inverse of modulus in binary modulus */
	ZVALUE one;		/* REDC format for the number 1 */
} REDC;

extern DLL REDC *zredcalloc(ZVALUE z1);
extern DLL void zredcfree(REDC *rp);
extern DLL void zredcencode(REDC *rp, ZVALUE z1, ZVALUE *res);
extern DLL void zredcdecode(REDC *rp, ZVALUE z1, ZVALUE *res);
extern DLL void zredcmul(REDC *rp, ZVALUE z1, ZVALUE z2, ZVALUE *res);
extern DLL void zredcsquare(REDC *rp, ZVALUE z1, ZVALUE *res);
extern DLL void zredcpower(REDC *rp, ZVALUE z1, ZVALUE z2, ZVALUE *res);


/*
 * macro expansions to speed this thing up
 */
#define ziseven(z)	(!(*(z).v & 0x1))
#define zisodd(z)	(*(z).v & 0x1)
#define ziszero(z)	((*(z).v == 0) && ((z).len == 1))
#define zisneg(z)	((z).sign)
#define zispos(z)	(((z).sign == 0) && (*(z).v || ((z).len > 1)))
#define zisunit(z)	((*(z).v == 1) && ((z).len == 1))
#define zisone(z)	((*(z).v == 1) && ((z).len == 1) && !(z).sign)
#define zisnegone(z)	((*(z).v == 1) && ((z).len == 1) && (z).sign)
#define zltnegone(z)	(zisneg(z) && (((z).len > 1) || *(z).v > 1))
#define zistwo(z)	((*(z).v == 2) && ((z).len == 1) && !(z).sign)
#define zisabstwo(z)	((*(z).v == 2) && ((z).len == 1))
#define zisabsleone(z)	((*(z).v <= 1) && ((z).len == 1))
#define zislezero(z)	(zisneg(z) || ziszero(z))
#define zisleone(z)	(zisneg(z) || zisabsleone(z))
#define zistiny(z)	((z).len == 1)

/*
 * zgtmaxfull(z)	TRUE if abs(z) > MAXFULL
 */
#define zgtmaxfull(z)	(((z).len > 2) || (((z).len == 2) && (((SHALF)(z).v[1]) < 0)))

/*
 * zgtmaxufull(z)	TRUE if abs(z) will not fit into a FULL (> MAXUFULL)
 */
#define zgtmaxufull(z)	((z).len > 2)

/*
 * zgtmaxulong(z)	TRUE if abs(z) > MAXULONG
 */
#if BASEB >= LONG_BITS
#define zgtmaxulong(z)	((z).len > 1)
#else
#define zgtmaxulong(z)	zgtmaxufull(z)
#endif

/*
 * zgtmaxlong(z)	TRUE if abs(z) > MAXLONG
 */
#if BASEB >= LONG_BITS
#define zgtmaxlong(z)	(((z).len > 1) || (((z).len == 1) && (((SHALF)(z).v[0]) < 0)))
#else
#define zgtmaxlong(z)	zgtmaxfull(z)
#endif

/*
 * Some algorithms testing for values of a certain length.  Macros such as
 * zistiny() do this well.  In other cases algorthms require tests for values
 * in comparison to a given power of 2.	 In the later case, zistiny() compares
 * against a different power of 2 on a 64 bit machine.	The macros below
 * provide a tests against powers of 2 that are independent of the work size.
 *
 *	zge16b(z)	TRUE if abs(z) >= 2^16
 *	zge24b(z)	TRUE if abs(z) >= 2^24
 *	zge31b(z)	TRUE if abs(z) >= 2^31
 *	zge32b(z)	TRUE if abs(z) >= 2^32
 *	zge64b(z)	TRUE if abs(z) >= 2^64
 *	zge128b(z)	TRUE if abs(z) >= 2^128
 *	zge256b(z)	TRUE if abs(z) >= 2^256
 *	zge512b(z)	TRUE if abs(z) >= 2^512
 *	zge1024b(z)	TRUE if abs(z) >= 2^1024
 *	zge2048b(z)	TRUE if abs(z) >= 2^2048
 *	zge4096b(z)	TRUE if abs(z) >= 2^4096
 *	zge8192b(z)	TRUE if abs(z) >= 2^8192
 */
#if BASEB == 32

#define zge16b(z)	(!zistiny(z) || ((z).v[0] >= (HALF)0x10000))
#define zge24b(z)	(!zistiny(z) || ((z).v[0] >= (HALF)0x1000000))
#define zge31b(z)	(!zistiny(z) || (((SHALF)(z).v[0]) < 0))
#define zge32b(z)	(!zistiny(z))
#define zge64b(z)	((z).len > 2)
#define zge128b(z)	((z).len > 4)
#define zge256b(z)	((z).len > 8)
#define zge512b(z)	((z).len > 16)
#define zge1024b(z)	((z).len > 32)
#define zge2048b(z)	((z).len > 64)
#define zge4096b(z)	((z).len > 128)
#define zge8192b(z)	((z).len > 256)

#else

#define zge16b(z)	(!zistiny(z))
#define zge24b(z)	(((z).len > 2) || (((z).len == 2) && ((z).v[1] >= (HALF)0x100)))
#define zge31b(z)	(((z).len > 2) || (((z).len == 2) && (((SHALF)(z).v[1]) < 0)))
#define zge32b(z)	((z).len > 2)
#define zge64b(z)	((z).len > 4)
#define zge128b(z)	((z).len > 8)
#define zge256b(z)	((z).len > 16)
#define zge512b(z)	((z).len > 32)
#define zge1024b(z)	((z).len > 64)
#define zge2048b(z)	((z).len > 128)
#define zge4096b(z)	((z).len > 256)
#define zge8192b(z)	((z).len > 512)

#endif


/*
 * ztofull - convert an absolute value of a ZVALUE to a FULL if possible
 *
 * If the value is too large, only the low order bits that are able to
 * be converted into a FULL will be used.
 */
#define ztofull(z)	(zistiny(z) ? ((FULL)((z).v[0])) :		\
				      ((FULL)((z).v[0]) +		\
				       ((FULL)((z).v[1]) << BASEB)))

#define z1tol(z)	((long)((z).v[0]))
#define z2tol(z)	((long)(((z).v[0]) + \
				(((z).v[1] & MAXHALF) << BASEB)))

/*
 * ztoulong - convert an absolute value of a ZVALUE to an unsigned long
 *
 * If the value is too large, only the low order bits that are able to
 * be converted into a long will be used.
 */
#if BASEB >= LONG_BITS
# define ztoulong(z)	((unsigned long)z1tol(z))
#else
# define ztoulong(z)	((unsigned long)ztofull(z))
#endif

/*
 * ztolong - convert an absolute value of a ZVALUE to a long
 *
 * If the value is too large, only the low order bits that are able to
 * be converted into a long will be used.
 */
#define ztolong(z)	((long)(ztoulong(z) & MAXLONG))

#define zclearval(z)	memset((z).v, 0, (z).len * sizeof(HALF))
#define zcopyval(z1,z2) memcpy((z2).v, (z1).v, (z1).len * sizeof(HALF))
#define zquicktrim(z)	{if (((z).len > 1) && ((z).v[(z).len-1] == 0)) \
				(z).len--;}
#define zfree(z)	freeh((z).v)


/*
 * Output modes for numeric displays.
 */
#define MODE_DEFAULT	0
#define MODE_FRAC	1
#define MODE_INT	2
#define MODE_REAL	3
#define MODE_EXP	4
#define MODE_HEX	5
#define MODE_OCTAL	6
#define MODE_BINARY	7
#define MODE_MAX	7
#define MODE2_OFF	(MODE_MAX+1)

#define MODE_INITIAL	MODE_REAL
#define MODE2_INITIAL	MODE2_OFF


/*
 * Output routines for either FILE handles or strings.
 */
extern DLL void math_chr(int ch);
extern DLL void math_str(char *str);
extern DLL void math_fill(char *str, long width);
extern DLL void math_flush(void);
extern DLL void math_divertio(void);
extern DLL void math_cleardiversions(void);
extern DLL char *math_getdivertedio(void);
extern DLL int math_setmode(int mode);
extern DLL int math_setmode2(int mode);
extern DLL LEN math_setdigits(LEN digits);
extern DLL void math_fmt(char *, ...);


/*
 * The error routine.
 */
extern DLL void math_error(char *, ...);


/*
 * external swap functions
 */
extern DLL HALF *swap_b8_in_HALFs(HALF *dest, HALF *src, LEN len);
extern DLL ZVALUE *swap_b8_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all);
extern DLL HALF *swap_b16_in_HALFs(HALF *dest, HALF *src, LEN len);
extern DLL ZVALUE *swap_b16_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all);
extern DLL ZVALUE *swap_HALF_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all);


/*
 * constants used often by the arithmetic routines
 */
extern HALF _zeroval_[], _oneval_[], _twoval_[], _threeval_[], _fourval_[];
extern HALF _fiveval_[], _sixval_[], _sevenval_[], _eightval_[], _nineval_[];
extern HALF _tenval_[], _elevenval_[], _twelveval_[], _thirteenval_[];
extern HALF _fourteenval_[], _fifteenval_[];
extern HALF _sqbaseval_[];
extern HALF _fourthbaseval_[];

extern ZVALUE zconst[];		/* ZVALUE integers from 0 thru 15 */

extern ZVALUE _zero_, _one_, _two_, _ten_, _neg_one_;
extern ZVALUE _sqbase_, _pow4base_, _pow8base_;

extern ZVALUE _b32_, _b64_;

extern DLL BOOL _math_abort_;	/* nonzero to abort calculations */
extern ZVALUE _tenpowers_[];	/* table of 10^2^n */

/*
 * Bit fiddeling functions and types
 */
extern HALF bitmask[];		/* bit rotation, norm 0 */
extern HALF lowhalf[];		/* bit masks from low end of HALF */
extern HALF rlowhalf[];		/* reversed bit masks from low end of HALF */
extern HALF highhalf[];		/* bit masks from high end of HALF */
extern HALF rhighhalf[];	/* reversed bit masks from high end of HALF */
#define HAVE_REVERSED_MASKS	/* allows old code to know libcalc.a has them */


/*
 * BITSTR - string of bits within an array of HALFs
 *
 * This typedef records a location of a bit in an array of HALFs.
 * Bit 0 in a HALF is assumed to be the least significant bit in that HALF.
 *
 * The most significant bit is found at (loc,bit).  Bits of lesser
 * significance may be found in previous bits and HALFs.
 */
typedef struct {
	HALF *loc;	/* half address of most significant bit */
	int bit;	/* bit position within half of most significant bit */
	int len;	/* length of string in bits */
} BITSTR;


#endif /* !__ZMATH_H__*/