More changes. Still embryonic.

[u/mdw/catacomb] / mpx.h

diff --git a/mpx.h b/mpx.h
index 96bb358..509da02 100644 (file)
--- a/mpx.h
+++ b/mpx.h
@@ -1,6 +1,6 @@
 /* -*-c-*-
  *
- * $Id: mpx.h,v 1.5 1999/11/20 22:23:27 mdw Exp $
+ * $Id: mpx.h,v 1.8 1999/12/11 10:57:43 mdw Exp $
  *
  * Low level multiprecision arithmetic
  *
@@ -30,6 +30,15 @@
 /*----- Revision history --------------------------------------------------* 
  *
  * $Log: mpx.h,v $
+ * 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.
+ *
  * Revision 1.5  1999/11/20 22:23:27  mdw
  * Add function versions of some low-level macros with wider use.
  *
@@ -47,8 +56,8 @@
  *
  */
 
-#ifndef MPX_H
-#define MPX_H
+#ifndef CATACOMB_MPX_H
+#define CATACOMB_MPX_H
 
 #ifdef __cplusplus
   extern "C" {
@@ -71,7 +80,7 @@
 
 #include <string.h>
 
-#ifndef MPW_H
+#ifndef CATACOMB_MPW_H
 #  include "mpw.h"
 #endif
 
@@ -481,10 +490,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;                                              \
@@ -532,6 +539,74 @@ extern void mpx_udiv(mpw */*qv*/, mpw */*qvl*/, mpw */*rv*/, mpw */*rvl*/,
                     const mpw */*dv*/, const mpw */*dvl*/,
                     mpw */*sv*/, mpw */*svl*/);
 
+/*----- Karatsuba multiplication algorithms -------------------------------*/
+
+/* --- @KARATSUBA_CUTOFF@ --- *
+ *
+ * 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 KARATSUBA_CUTOFF 16
+
+/* --- @KARATSUBA_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 KARATSUBA_SLOP 32
+
+/* --- @mpx_kmul@ --- *
+ *
+ * Arguments:  @mpw *dv, *dvl@ = pointer to destination buffer
+ *             @const mpw *av, *avl@ = pointer to first argument
+ *             @const mpw *bv, *bvl@ = pointer to second argument
+ *             @mpw *sv, *svl@ = pointer to scratch workspace
+ *
+ * Returns:    ---
+ *
+ * Use:                Multiplies two multiprecision integers using Karatsuba's
+ *             algorithm.  This is rather faster than traditional long
+ *             multiplication (e.g., @mpx_umul@) on large numbers, although
+ *             more expensive on small ones.
+ *
+ *             The destination and scratch buffers must be twice as large as
+ *             the larger argument.  The scratch space must be twice as
+ *             large as the larger argument, plus the magic number
+ *             @KARATSUBA_SLOP@.
+ */
+
+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_ksqr@ --- *
+ *
+ * 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:                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 @KARATSUBA_SLOP@.
+ */
+
+extern void mpx_ksqr(mpw */*dv*/, mpw */*dvl*/,
+                    const mpw */*av*/, const mpw */*avl*/,
+                    mpw */*sv*/, mpw */*svl*/);
+
 /*----- That's all, folks -------------------------------------------------*/
 
 #ifdef __cplusplus