/* -*-c-*-
*
- * $Id: mpx.h,v 1.9 1999/12/22 15:49:07 mdw Exp $
+ * $Id: mpx.h,v 1.17 2004/03/27 00:04:46 mdw Exp $
*
* Low level multiprecision arithmetic
*
/*----- Revision history --------------------------------------------------*
*
* $Log: mpx.h,v $
+ * Revision 1.17 2004/03/27 00:04:46 mdw
+ * Implement efficient reduction for pleasant-looking primes.
+ *
+ * Revision 1.16 2003/05/16 09:09:24 mdw
+ * Fix @mp_lsl2c@. Turns out to be surprisingly tricky.
+ *
+ * Revision 1.15 2002/10/19 17:56:50 mdw
+ * Fix bit operations. Test them (a bit) better.
+ *
+ * Revision 1.14 2002/10/09 00:36:03 mdw
+ * Fix bounds on workspace for Karatsuba operations.
+ *
+ * Revision 1.13 2002/10/06 22:52:50 mdw
+ * Pile of changes for supporting two's complement properly.
+ *
+ * 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.
*
*/
#define MPX_OCTETS(o, v, vl) do { \
- const mpw *_v = (v), *_vl = (vl); \
- MPX_SHRINK(_v, _vl); \
- if (_v == _vl) \
- (o) = 0; \
- else { \
- size_t _o = (MPW_BITS / 8) * (_vl - _v - 1); \
- mpw _w = _vl[-1]; \
- unsigned _k = MPW_BITS / 2; \
- while (_k >= 8) { \
- if (_w >> _k) { \
- _w >>= _k; \
- _o += _k >> 3; \
- } \
- _k >>= 1; \
- } \
- if (_w) \
- _o++; \
- (o) = _o; \
- } \
+ unsigned long _bb; \
+ MPX_BITS(_bb, (v), (vl)); \
+ (o) = (_bb + 7) >> 3; \
+} while (0)
+
+/* --- @MPX_OCTETS2C@ --- *
+ *
+ * Arguments: @size_t o@ = result variable
+ * @const mpw *v, *vl@ = pointer to array of words
+ *
+ * Use: Calculates the number of octets in a multiprecision value, if
+ * you represent it as two's complement.
+ */
+
+#define MPX_OCTETS2C(o, v, vl) do { \
+ unsigned long _bb; \
+ MPX_BITS(_bb, (v), (vl)); \
+ (o) = (_bb >> 3) + 1; \
} while (0)
/* --- @MPX_COPY@ --- *
memset(_v, 0, MPWS(_vl - _v)); \
} while (0)
+/* --- @MPX_ONE@ --- *
+ *
+ * Arguments: @v, vl@ = base and limit of vector to clear
+ *
+ * Use: Fills the area between the two vector pointers with ones.
+ */
+
+#define MPX_ONE(v, vl) do { \
+ mpw * _v = (v); \
+ const mpw *_vl = (vl); \
+ while (_v < _vl) \
+ *_v++ = MPW_MAX; \
+} while (0)
+
/*----- Loading and storing -----------------------------------------------*/
/* --- @mpx_storel@ --- *
extern void mpx_loadb(mpw */*v*/, mpw */*vl*/,
const void */*p*/, size_t /*sz*/);
+/* --- @mpx_storel2cn@ --- *
+ *
+ * Arguments: @const mpw *v, *vl@ = base and limit of source vector
+ * @void *pp@ = pointer to octet array
+ * @size_t sz@ = size of octet array
+ *
+ * Returns: ---
+ *
+ * Use: Stores a negative MP in an octet array, least significant
+ * octet first, as two's complement. High-end octets are
+ * silently discarded if there isn't enough space for them.
+ * This obviously makes the output bad.
+ */
+
+extern void mpx_storel2cn(const mpw */*v*/, const mpw */*vl*/,
+ void */*p*/, size_t /*sz*/);
+
+/* --- @mpx_loadl2cn@ --- *
+ *
+ * Arguments: @mpw *v, *vl@ = base and limit of destination vector
+ * @const void *pp@ = pointer to octet array
+ * @size_t sz@ = size of octet array
+ *
+ * Returns: ---
+ *
+ * Use: Loads a negative MP in an octet array, least significant
+ * octet first, as two's complement. High-end octets are
+ * ignored if there isn't enough space for them. This probably
+ * means you made the wrong choice coming here.
+ */
+
+extern void mpx_loadl2cn(mpw */*v*/, mpw */*vl*/,
+ const void */*p*/, size_t /*sz*/);
+
+/* --- @mpx_storeb2cn@ --- *
+ *
+ * Arguments: @const mpw *v, *vl@ = base and limit of source vector
+ * @void *pp@ = pointer to octet array
+ * @size_t sz@ = size of octet array
+ *
+ * Returns: ---
+ *
+ * Use: Stores a negative MP in an octet array, most significant
+ * octet first, as two's complement. High-end octets are
+ * silently discarded if there isn't enough space for them,
+ * which probably isn't what you meant.
+ */
+
+extern void mpx_storeb2cn(const mpw */*v*/, const mpw */*vl*/,
+ void */*p*/, size_t /*sz*/);
+
+/* --- @mpx_loadb2cn@ --- *
+ *
+ * Arguments: @mpw *v, *vl@ = base and limit of destination vector
+ * @const void *pp@ = pointer to octet array
+ * @size_t sz@ = size of octet array
+ *
+ * Returns: ---
+ *
+ * Use: Loads a negative MP in an octet array, most significant octet
+ * first as two's complement. High-end octets are ignored if
+ * there isn't enough space for them. This probably means you
+ * chose this function wrongly.
+ */
+
+extern void mpx_loadb2cn(mpw */*v*/, mpw */*vl*/,
+ const void */*p*/, size_t /*sz*/);
+
+
/*----- Logical shifting --------------------------------------------------*/
/* --- @mpx_lsl@ --- *
const mpw */*av*/, const mpw */*avl*/,
size_t /*n*/);
+/* --- @mpx_lslc@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = destination vector base and limit
+ * @const mpw *av, *avl@ = source vector base and limit
+ * @size_t n@ = number of bit positions to shift by
+ *
+ * Returns: ---
+ *
+ * Use: Performs a logical shift left operation on an integer, only
+ * it fills in the bits with ones instead of zeroes.
+ */
+
+extern void mpx_lslc(mpw */*dv*/, mpw */*dvl*/,
+ const mpw */*av*/, const mpw */*avl*/,
+ size_t /*n*/);
+
/* --- @mpx_lsr@ --- *
*
* Arguments: @mpw *dv, *dvl@ = destination vector base and limit
const mpw */*av*/, const mpw */*avl*/,
size_t /*n*/);
+/*----- Bitwise operations ------------------------------------------------*/
+
+/* --- @mpx_bitop@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = destination vector
+ * @const mpw *av, *avl@ = first source vector
+ * @const mpw *bv, *bvl@ = second source vector
+ *
+ * Returns: ---
+ *
+ * Use: Provide the dyadic boolean functions. The functions are
+ * named after the truth table they generate:
+ *
+ * a: 0011
+ * b: 0101
+ * @mpx_bitXXXX@
+ */
+
+#define MPX_DOBIN(what) \
+ what(0000) what(0001) what(0010) what(0011) \
+ what(0100) what(0101) what(0110) what(0111) \
+ what(1000) what(1001) what(1010) what(1011) \
+ what(1100) what(1101) what(1110) what(1111)
+
+#define MPX_BITDECL(string) \
+ extern void mpx_bit##string(mpw */*dv*/, mpw */*dvl*/, \
+ const mpw */*av*/, const mpw */*avl*/, \
+ const mpw */*bv*/, const mpw */*bvl*/);
+MPX_DOBIN(MPX_BITDECL)
+
+/* --- @mpx_[n]and@, @mpx_[n]or@, @mpx_xor@ --- *
+ *
+ * Synonyms for the commonly-used functions above.
+ */
+
+#define mpx_and mpx_bit0001
+#define mpx_or mpx_bit0111
+#define mpx_nand mpx_bit1110
+#define mpx_nor mpx_bit1000
+#define mpx_xor mpx_bit0110
+
+/* --- @mpx_not@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = destination vector
+ * @const mpw *av, *avl@ = first source vector
+ *
+ * Returns: ---
+ *
+ * Use; Bitwise NOT.
+ */
+
+extern void mpx_not(mpw */*dv*/, mpw */*dvl*/,
+ const mpw */*av*/, const mpw */*avl*/);
+
/*----- Unsigned arithmetic -----------------------------------------------*/
/* --- @mpx_2c@ --- *
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
extern void mpx_uaddn(mpw */*dv*/, mpw */*dvl*/, mpw /*n*/);
+/* --- @mpx_uaddnlsl@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = destination and first argument vector
+ * @mpw a@ = second argument
+ * @unsigned o@ = offset in bits
+ *
+ * Returns: ---
+ *
+ * Use: Computes %$d + 2^o a$%. If the result overflows then
+ * high-order bits are discarded, as usual. We must have
+ * @0 < o < MPW_BITS@.
+ */
+
+extern void mpx_uaddnlsl(mpw */*dv*/, mpw */*dvl*/,
+ mpw /*a*/, unsigned /*o*/);
+
/* --- @mpx_usub@ --- *
*
* Arguments: @mpw *dv, *dvl@ = destination vector base and limit
extern void mpx_usubn(mpw */*dv*/, mpw */*dvl*/, mpw /*n*/);
+/* --- @mpx_usubnlsl@ --- *
+ *
+ * Arguments: @mpw *dv, *dvl@ = destination and first argument vector
+ * @mpw a@ = second argument
+ * @unsigned o@ = offset in bits
+ *
+ * Returns: ---
+ *
+ * Use: Computes %$d - 2^o a$%. If the result overflows then
+ * high-order bits are discarded, as usual, so you get two's
+ * complement. Which might be what you wanted... We must have
+ * @0 < o < MPW_BITS@.
+ */
+
+extern void mpx_usubnlsl(mpw */*dv*/, mpw */*dvl*/,
+ mpw /*a*/, unsigned /*o*/);
+
/* --- @mpx_umul@ --- *
*
* Arguments: @mpw *dv, *dvl@ = destination vector base and limit
/*----- Karatsuba multiplication algorithms -------------------------------*/
-/* --- @KARATSUBA_CUTOFF@ --- *
+/* --- @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 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.
+ * this. It is unsafe to make this constant less than four (i.e., the
+ * algorithms will fail).
*/
-#define KARATSUBA_SLOP 64
+#define MPK_THRESH 16
/* --- @mpx_kmul@ --- *
*
* 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@.
+ * The destination must be three times as large as the larger
+ * argument. The scratch space must be five times as large as
+ * the larger argument.
*/
extern void mpx_kmul(mpw */*dv*/, mpw */*dvl*/,
* 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@.
+ * The destination must be three times as large as the larger
+ * argument. The scratch space must be five times as large as
+ * the larger argument.
*/
extern void mpx_ksqr(mpw */*dv*/, mpw */*dvl*/,