X-Git-Url: https://git.distorted.org.uk/u/mdw/catacomb/blobdiff_plain/a86e33af1ea11503350b37dbf64a7518c27b583e..2685767a6125c1620719c7de6234aedf41857b7e:/mpx.h

diff --git a/mpx.h b/mpx.h
index 7d8a2cd..b633e43 100644
--- a/mpx.h
+++ b/mpx.h
@@ -1,6 +1,6 @@
 /* -*-c-*-
  *
- * $Id: mpx.h,v 1.6 1999/12/10 23:23:51 mdw Exp $
+ * $Id: mpx.h,v 1.12 2001/04/03 19:36:05 mdw Exp $
  *
  * Low level multiprecision arithmetic
  *
@@ -30,6 +30,24 @@
 /*----- Revision history --------------------------------------------------* 
  *
  * $Log: mpx.h,v $
+ * Revision 1.12  2001/04/03 19:36:05  mdw
+ * Add some simple bitwise operations so that Perl can use them.
+ *
+ * Revision 1.11  2000/10/08 15:48:35  mdw
+ * Rename Karatsuba constants now that we have @gfx_kmul@ too.
+ *
+ * Revision 1.10  2000/10/08 12:06:12  mdw
+ * Provide @mpx_ueq@ for rapidly testing equality of two integers.
+ *
+ * Revision 1.9  1999/12/22 15:49:07  mdw
+ * New function for division by a small integer.
+ *
+ * Revision 1.8  1999/12/11 10:57:43  mdw
+ * Karatsuba squaring algorithm.
+ *
+ * Revision 1.7  1999/12/11 01:51:28  mdw
+ * Change Karatsuba parameters slightly.
+ *
  * Revision 1.6  1999/12/10 23:23:51  mdw
  * Karatsuba-Ofman multiplication algorithm.
  *
@@ -289,6 +307,34 @@ extern void mpx_lsr(mpw */*dv*/, mpw */*dvl*/,
 		    const mpw */*av*/, const mpw */*avl*/,
 		    size_t /*n*/);
 
+/*----- Bitwise operations ------------------------------------------------*/
+
+/* --- @mpx_and@, @mpx_or@, @mpx_xor@, @mpx_not@ --- *
+ *
+ * Arguments:	@mpw *dv, *dvl@ = destination vector
+ *		@const mpw *av, *avl@ = first source vector
+ *		@const mpw *bv, *bvl@ = second source vector
+ *
+ * Returns:	---
+ *
+ * Use;		Does the obvious bitwise operations.
+ */
+
+extern void mpx_and(mpw */*dv*/, mpw */*dvl*/,
+		    const mpw */*av*/, const mpw */*avl*/,
+		    const mpw */*bv*/, const mpw */*bvl*/);
+
+extern void mpx_or(mpw */*dv*/, mpw */*dvl*/,
+		   const mpw */*av*/, const mpw */*avl*/,
+		   const mpw */*bv*/, const mpw */*bvl*/);
+
+extern void mpx_xor(mpw */*dv*/, mpw */*dvl*/,
+		    const mpw */*av*/, const mpw */*avl*/,
+		    const mpw */*bv*/, const mpw */*bvl*/);
+
+extern void mpx_not(mpw */*dv*/, mpw */*dvl*/,
+		    const mpw */*av*/, const mpw */*avl*/);
+
 /*----- Unsigned arithmetic -----------------------------------------------*/
 
 /* --- @mpx_2c@ --- *
@@ -304,6 +350,19 @@ extern void mpx_lsr(mpw */*dv*/, mpw */*dvl*/,
 extern void mpx_2c(mpw */*dv*/, mpw */*dvl*/,
 		   const mpw */*v*/, const mpw */*vl*/);
 
+/* --- @mpx_ueq@ --- *
+ *
+ * Arguments:	@const mpw *av, *avl@ = first argument vector base and limit
+ *		@const mpw *bv, *bvl@ = second argument vector base and limit
+ *
+ * Returns:	Nonzero if the two vectors are equal.
+ *
+ * Use:		Performs an unsigned integer test for equality.
+ */
+
+extern int mpx_ueq(const mpw */*av*/, const mpw */*avl*/,
+		   const mpw */*bv*/, const mpw */*bvl*/);
+
 /* --- @mpx_ucmp@ --- *
  *
  * Arguments:	@const mpw *av, *avl@ = first argument vector base and limit
@@ -484,10 +543,8 @@ extern void mpx_umuln(mpw */*dv*/, mpw */*dvl*/,
   mpw _cc = 0;								\
   mpd _m = (m);								\
 									\
-  while (_av < _avl) {							\
+  while (_dv < _dvl && _av < _avl) {					\
     mpd _x;								\
-    if (_dv >= _dvl)							\
-      break;								\
     _x = (mpd)*_dv + (mpd)_m * (mpd)*_av++ + _cc;			\
     *_dv++ = MPW(_x);							\
     _cc = _x >> MPW_BITS;						\
@@ -512,6 +569,64 @@ extern void mpx_umlan(mpw */*dv*/, mpw */*dvl*/,
 extern void mpx_usqr(mpw */*dv*/, mpw */*dvl*/,
 		     const mpw */*av*/, const mpw */*avl*/);
 
+/* --- @mpx_udiv@ --- *
+ *
+ * Arguments:	@mpw *qv, *qvl@ = quotient vector base and limit
+ *		@mpw *rv, *rvl@ = dividend/remainder vector base and limit
+ *		@const mpw *dv, *dvl@ = divisor vector base and limit
+ *		@mpw *sv, *svl@ = scratch workspace 
+ *
+ * Returns:	---
+ *
+ * Use:		Performs unsigned integer division.  If the result overflows
+ *		the quotient vector, high-order bits are discarded.  (Clearly
+ *		the remainder vector can't overflow.)  The various vectors
+ *		may not overlap in any way.  Yes, I know it's a bit odd
+ *		requiring the dividend to be in the result position but it
+ *		does make some sense really.  The remainder must have
+ *		headroom for at least two extra words.  The scratch space
+ *		must be at least one word larger than the divisor.
+ */
+
+extern void mpx_udiv(mpw */*qv*/, mpw */*qvl*/, mpw */*rv*/, mpw */*rvl*/,
+		     const mpw */*dv*/, const mpw */*dvl*/,
+		     mpw */*sv*/, mpw */*svl*/);
+
+/* --- @mpx_udivn@ --- *
+ *
+ * Arguments:	@mpw *qv, *qvl@ = storage for the quotient (may overlap
+ *			dividend)
+ *		@const mpw *rv, *rvl@ = dividend
+ *		@mpw d@ = single-precision divisor
+ *
+ * Returns:	Remainder after divison.
+ *
+ * Use:		Performs a single-precision division operation.
+ */
+
+extern mpw mpx_udivn(mpw */*qv*/, mpw */*qvl*/,
+		     const mpw */*rv*/, const mpw */*rvl*/, mpw /*d*/);
+
+/*----- Karatsuba multiplication algorithms -------------------------------*/
+
+/* --- @MPK_THRESH@ --- *
+ *
+ * This is the limiting length for using Karatsuba algorithms.  It's best to
+ * use the simpler classical multiplication method on numbers smaller than
+ * this.
+ */
+
+#define MPK_THRESH 16
+
+/* --- @MPK_SLOP@ --- *
+ *
+ * The extra number of words required as scratch space by the Karatsuba
+ * routines.  This is a (generous) guess, since the actual amount of space
+ * required is proportional to the recursion depth.
+ */
+
+#define MPK_SLOP 64
+
 /* --- @mpx_kmul@ --- *
  *
  * Arguments:	@mpw *dv, *dvl@ = pointer to destination buffer
@@ -527,38 +642,37 @@ extern void mpx_usqr(mpw */*dv*/, mpw */*dvl*/,
  *		more expensive on small ones.
  *
  *		The destination and scratch buffers must be twice as large as
- *		the larger argument.
+ *		the larger argument.  The scratch space must be twice as
+ *		large as the larger argument, plus the magic number
+ *		@MPK_SLOP@.
  */
 
-#define KARATSUBA_CUTOFF 16
-#define KARATSUBA_SLOP 32
-
 extern void mpx_kmul(mpw */*dv*/, mpw */*dvl*/,
 		     const mpw */*av*/, const mpw */*avl*/,
 		     const mpw */*bv*/, const mpw */*bvl*/,
 		     mpw */*sv*/, mpw */*svl*/);
 
-/* --- @mpx_udiv@ --- *
+/* --- @mpx_ksqr@ --- *
  *
- * Arguments:	@mpw *qv, *qvl@ = quotient vector base and limit
- *		@mpw *rv, *rvl@ = dividend/remainder vector base and limit
- *		@const mpw *dv, *dvl@ = divisor vector base and limit
- *		@mpw *sv, *svl@ = scratch workspace 
+ * Arguments:	@mpw *dv, *dvl@ = pointer to destination buffer
+ *		@const mpw *av, *avl@ = pointer to first argument
+ *		@mpw *sv, *svl@ = pointer to scratch workspace
  *
  * Returns:	---
  *
- * Use:		Performs unsigned integer division.  If the result overflows
- *		the quotient vector, high-order bits are discarded.  (Clearly
- *		the remainder vector can't overflow.)  The various vectors
- *		may not overlap in any way.  Yes, I know it's a bit odd
- *		requiring the dividend to be in the result position but it
- *		does make some sense really.  The remainder must have
- *		headroom for at least two extra words.  The scratch space
- *		must be at least one word larger than the divisor.
+ * Use:		Squares a multiprecision integers using something similar to
+ *		Karatsuba's multiplication algorithm.  This is rather faster
+ *		than traditional long multiplication (e.g., @mpx_umul@) on
+ *		large numbers, although more expensive on small ones, and
+ *		rather simpler than full-blown Karatsuba multiplication.
+ *
+ *		The destination must be twice as large as the argument.  The
+ *		scratch space must be twice as large as the argument, plus
+ *		the magic number @MPK_SLOP@.
  */
 
-extern void mpx_udiv(mpw */*qv*/, mpw */*qvl*/, mpw */*rv*/, mpw */*rvl*/,
-		     const mpw */*dv*/, const mpw */*dvl*/,
+extern void mpx_ksqr(mpw */*dv*/, mpw */*dvl*/,
+		     const mpw */*av*/, const mpw */*avl*/,
 		     mpw */*sv*/, mpw */*svl*/);
 
 /*----- That's all, folks -------------------------------------------------*/