X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/f368b46e168e8accdb0c578ccbba7e7d2ee8c0de..24b3d57bcf320d9d7a90a40d5f6176b1f087ab3e:/mp.c

diff --git a/mp.c b/mp.c
index 0a0e206..983e193 100644
--- a/mp.c
+++ b/mp.c
@@ -269,11 +269,44 @@ int convgf(PyObject *o, void *p)
   return (1);
 }
 
+static mp *implicitmp(PyObject *o)
+{
+  if (!o ||
+      GF_PYCHECK(o) ||
+      ECPT_PYCHECK(o) ||
+      FE_PYCHECK(o) ||
+      GE_PYCHECK(o))
+    return (0);
+  return (tomp(o));
+}
+
+static mp *implicitgf(PyObject *o)
+{
+  if (!o ||
+      MP_PYCHECK(o) ||
+      ECPT_PYCHECK(o) ||
+      FE_PYCHECK(o) ||
+      GE_PYCHECK(o))
+    return (0);
+  return (tomp(o));
+}
+
 static int mpbinop(PyObject *x, PyObject *y, mp **xx, mp **yy)
 {
-  if ((*xx = tomp(x)) == 0)
+  if ((*xx = implicitmp(x)) == 0)
     return (-1);
-  if ((*yy = tomp(y)) == 0) {
+  if ((*yy = implicitmp(y)) == 0) {
+    MP_DROP(*xx);
+    return (-1);
+  }
+  return (0);
+}
+
+static int gfbinop(PyObject *x, PyObject *y, mp **xx, mp **yy)
+{
+  if ((*xx = implicitgf(x)) == 0)
+    return (-1);
+  if ((*yy = implicitgf(y)) == 0) {
     MP_DROP(*xx);
     return (-1);
   }
@@ -286,7 +319,7 @@ static int mpbinop(PyObject *x, PyObject *y, mp **xx, mp **yy)
 #define BINOP(pre, name)						\
   static PyObject *pre##_py##name(PyObject *x, PyObject *y) {		\
     mp *xx, *yy, *zz;							\
-    if (mpbinop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
+    if (pre##binop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
     zz = pre##_##name(MP_NEW, xx, yy);					\
     MP_DROP(xx); MP_DROP(yy);						\
     return (pre##_pywrap(zz));						\
@@ -330,7 +363,7 @@ static PyObject *mp_pyid(PyObject *x) { RETURN_OBJ(x); }
     mp *xx, *yy;							\
     PyObject *z = 0;							\
     long n;								\
-    if (mpbinop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
+    if (pre##binop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
     if (mp_tolong_checked(yy, &n)) goto end;				\
     if (n < 0)								\
       z = pre##_pywrap(mp_##rname(MP_NEW, xx, -n));			\
@@ -351,7 +384,7 @@ SHIFTOP(gf, lsr, lsl)
     mp *xx, *yy;							\
     PyObject *z = 0;							\
     INIT_##qq(q) INIT_##rr(r)						\
-    if (mpbinop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
+    if (pre##binop(x, y, &xx, &yy)) RETURN_NOTIMPL;			\
     if (MP_ZEROP(yy))							\
       ZDIVERR("division by zero");					\
     pre##_div(ARG_##qq(q), ARG_##rr(r), xx, yy);			\
@@ -396,7 +429,7 @@ static PyObject *mp_pyexp(PyObject *x, PyObject *y, PyObject *z)
   mp *r = 0;
   PyObject *rc = 0;
 
-  if ((xx = tomp(x)) == 0 || (yy = tomp(y)) == 0 ||
+  if ((xx = implicitmp(x)) == 0 || (yy = implicitmp(y)) == 0 ||
       (z && z != Py_None && (zz = tomp(z)) == 0)) {
     mp_drop(xx); mp_drop(yy); mp_drop(zz);
     RETURN_NOTIMPL;
@@ -535,8 +568,8 @@ end:
 #define BITOP(pre, name, c)						\
   static PyObject *pre##meth_##name(PyObject *me, PyObject *arg)	\
   {									\
-    int i;								\
-    if (!PyArg_ParseTuple(arg, "i:" #name, &i)) return (0);		\
+    unsigned long i;							\
+    if (!PyArg_ParseTuple(arg, "O&:" #name, convulong, &i)) return (0);	\
     return (pre##_pywrap(mp_##name##c(MP_NEW, MP_X(me), i)));		\
   }
 BITOP(mp, setbit, 2c);
@@ -547,15 +580,15 @@ BITOP(gf, clearbit, );
 
 static PyObject *mpmeth_testbit(PyObject *me, PyObject *arg)
 {
-  int i;
-  if (!PyArg_ParseTuple(arg, "i:testbit", &i)) return (0);
+  unsigned long i;
+  if (!PyArg_ParseTuple(arg, "O&:testbit", convulong, &i)) return (0);
   return (getbool(mp_testbit2c(MP_X(me), i)));
 }
 
 static PyObject *gfmeth_testbit(PyObject *me, PyObject *arg)
 {
-  int i;
-  if (!PyArg_ParseTuple(arg, "i:testbit", &i)) return (0);
+  unsigned long i;
+  if (!PyArg_ParseTuple(arg, "O&:testbit", convulong, &i)) return (0);
   return (getbool(mp_testbit(MP_X(me), i)));
 }
 
@@ -876,7 +909,7 @@ Notes:\n\
 };
 
 static PyObject *meth__MP_fromstring(PyObject *me,
-				    PyObject *arg, PyObject *kw)
+				     PyObject *arg, PyObject *kw)
 {
   int r = 0;
   char *p;
@@ -898,53 +931,165 @@ end:
   return (z);
 }
 
-static PyObject *meth__MP_product(PyObject *me, PyObject *arg)
+#define LOADOP(pre, py, name)						\
+  static PyObject *meth__##py##_##name(PyObject *me, PyObject *arg)	\
+  {									\
+    char *p;								\
+    int len;								\
+    if (!PyArg_ParseTuple(arg, "Os#:" #name, &me, &p, &len)) return (0); \
+    return (pre##_pywrap(mp_##name(MP_NEW, p, len)));			\
+  }
+LOADOP(mp, MP, loadl)
+LOADOP(mp, MP, loadb)
+LOADOP(mp, MP, loadl2c)
+LOADOP(mp, MP, loadb2c)
+LOADOP(gf, GF, loadl)
+LOADOP(gf, GF, loadb)
+#undef LOADOP
+
+/*----- Products of small integers ----------------------------------------*/
+
+typedef struct mpmul_pyobj {
+  PyObject_HEAD
+  int livep;
+  mpmul mm;
+} mpmul_pyobj;
+
+#define MPMUL_LIVEP(o) (((mpmul_pyobj *)(o))->livep)
+#define MPMUL_PY(o) (&((mpmul_pyobj *)(o))->mm)
+
+static void mpmul_pydealloc(PyObject *me)
+{
+  if (MPMUL_LIVEP(me))
+    mp_drop(mpmul_done(MPMUL_PY(me)));
+  FREEOBJ(me);
+}
+
+static PyObject *mmmeth_factor(PyObject *me, PyObject *arg)
 {
-  mpmul m;
   PyObject *q, *i;
   mp *x;
 
-  if (PyTuple_Size(arg) != 2) {
+  if (!MPMUL_LIVEP(me)) VALERR("MPMul object invalid");
+  if (PyTuple_Size(arg) != 1)
     i = PyObject_GetIter(arg);
-    PyIter_Next(i);
-  } else {
-    if ((q = PyTuple_GetItem(arg, 1)) == 0) return (0);
+  else {
+    if ((q = PyTuple_GetItem(arg, 0)) == 0) goto end;
     if ((i = PyObject_GetIter(q)) == 0) {
       PyErr_Clear(); /* that's ok */
       i = PyObject_GetIter(arg);
     }
   }
-  if (!i) return (0);
-  mpmul_init(&m);
+  if (!i) goto end;
   while ((q = PyIter_Next(i)) != 0) {
     x = getmp(q); Py_DECREF(q); if (!x) {
-      MP_DROP(mpmul_done(&m));
       Py_DECREF(i);
-      return (0);
+      goto end;
     }
-    mpmul_add(&m, x);
+    mpmul_add(MPMUL_PY(me), x);
     MP_DROP(x);
   }
-  x = mpmul_done(&m);
   Py_DECREF(i);
+  RETURN_ME;
+end:
+  return (0);
+}
+
+static PyObject *mmmeth_done(PyObject *me, PyObject *arg)
+{
+  mp *x;
+
+  if (!PyArg_ParseTuple(arg, ":done")) goto end;
+  if (!MPMUL_LIVEP(me)) VALERR("MPMul object invalid");
+  x = mpmul_done(MPMUL_PY(me));
+  MPMUL_LIVEP(me) = 0;
   return (mp_pywrap(x));
+end:
+  return (0);
 }
 
-#define LOADOP(pre, py, name)						\
-  static PyObject *meth__##py##_##name(PyObject *me, PyObject *arg)	\
-  {									\
-    char *p;								\
-    int len;								\
-    if (!PyArg_ParseTuple(arg, "Os#:" #name, &me, &p, &len)) return (0); \
-    return (pre##_pywrap(mp_##name(MP_NEW, p, len)));			\
+static PyObject *mpmul_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
+{
+  mpmul_pyobj *mm;
+
+  if (kw) TYERR("keyword arguments not allowed here");
+  mm = (mpmul_pyobj *)ty->tp_alloc(ty, 0);
+  mpmul_init(&mm->mm);
+  mm->livep = 1;
+  if (mmmeth_factor((PyObject *)mm, arg) == 0) {
+    Py_DECREF(mm);
+    goto end;
   }
-LOADOP(mp, MP, loadl)
-LOADOP(mp, MP, loadb)
-LOADOP(mp, MP, loadl2c)
-LOADOP(mp, MP, loadb2c)
-LOADOP(gf, GF, loadl)
-LOADOP(gf, GF, loadb)
-#undef LOADOP
+  return ((PyObject *)mm);
+end:
+  return (0);
+}
+
+static PyObject *mmget_livep(PyObject *me, void *hunoz)
+  { return (getbool(MPMUL_LIVEP(me))); }
+
+static PyGetSetDef mpmul_pygetset[] = {
+#define GETSETNAME(op, name) mm##op##_##name
+  GET	(livep,			"MM.livep -> flag: object still valid?")
+#undef GETSETNAME
+  { 0 }
+};
+
+static PyMethodDef mpmul_pymethods[] = {
+#define METHNAME(name) mmmeth_##name
+  METH	(factor,		"MM.factor(ITERABLE) or MM.factor(I, ...)")
+  METH	(done,			"MM.done() -> PRODUCT")
+#undef METHNAME
+  { 0 }
+};
+
+static PyTypeObject *mpmul_pytype, mpmul_pytype_skel = {
+  PyObject_HEAD_INIT(0) 0,		/* Header */
+  "catacomb.MPMul",			/* @tp_name@ */
+  sizeof(mpmul_pyobj),			/* @tp_basicsize@ */
+  0,					/* @tp_itemsize@ */
+
+  mpmul_pydealloc,			/* @tp_dealloc@ */
+  0,					/* @tp_print@ */
+  0,					/* @tp_getattr@ */
+  0,					/* @tp_setattr@ */
+  0,					/* @tp_compare@ */
+  0,					/* @tp_repr@ */
+  0,					/* @tp_as_number@ */
+  0,					/* @tp_as_sequence@ */
+  0,					/* @tp_as_mapping@ */
+  0,					/* @tp_hash@ */
+  0,					/* @tp_call@ */
+  0,					/* @tp_str@ */
+  0,					/* @tp_getattro@ */
+  0,					/* @tp_setattro@ */
+  0,					/* @tp_as_buffer@ */
+  Py_TPFLAGS_DEFAULT |			/* @tp_flags@ */
+    Py_TPFLAGS_BASETYPE,
+
+  /* @tp_doc@ */
+"An object for multiplying many small integers.",
+
+  0,					/* @tp_traverse@ */
+  0,					/* @tp_clear@ */
+  0,					/* @tp_richcompare@ */
+  0,					/* @tp_weaklistoffset@ */
+  0,					/* @tp_iter@ */
+  0,					/* @tp_iternext@ */
+  mpmul_pymethods,			/* @tp_methods@ */
+  0,					/* @tp_members@ */
+  mpmul_pygetset,			/* @tp_getset@ */
+  0,					/* @tp_base@ */
+  0,					/* @tp_dict@ */
+  0,					/* @tp_descr_get@ */
+  0,					/* @tp_descr_set@ */
+  0,					/* @tp_dictoffset@ */
+  0,					/* @tp_init@ */
+  PyType_GenericAlloc,			/* @tp_alloc@ */
+  mpmul_pynew,				/* @tp_new@ */
+  0,					/* @tp_free@ */
+  0					/* @tp_is_gc@ */
+};
 
 /*----- Montgomery reduction ----------------------------------------------*/
 
@@ -1660,7 +1805,7 @@ static PyObject *gf_pyrichcompare(PyObject *x, PyObject *y, int op)
   int xl, yl;
   int b;
 
-  if (mpbinop(x, y, &xx, &yy)) RETURN_NOTIMPL;
+  if (gfbinop(x, y, &xx, &yy)) RETURN_NOTIMPL;
   switch (op) {
     case Py_EQ: b = MP_EQ(xx, yy); break;
     case Py_NE: b = !MP_EQ(xx, yy); break;
@@ -1958,13 +2103,14 @@ static PyObject *meth__GF_fromstring(PyObject *me,
   if (!PyArg_ParseTupleAndKeywords(arg, kw, "Os#|i:fromstring",
 				   kwlist, &me, &p, &len, &r))
     goto end;
-  if (!good_radix_p(r, 1)) VALERR("radix out of range");
+  if (!good_radix_p(r, 1)) VALERR("bad radix");
   sc.buf = p; sc.lim = p + len;
-  if ((zz = mp_read(MP_NEW, r, &mptext_stringops, &sc)) == 0 || MP_NEGP(zz))
-    z = Py_BuildValue("(Os#)", Py_None, p, len);
-  else
-    z = Py_BuildValue("(Ns#)", gf_pywrap(zz),
-		      sc.buf, (int)(sc.lim - sc.buf));
+  if ((zz = mp_read(MP_NEW, r, &mptext_stringops, &sc)) == 0 ||
+      MP_NEGP(zz)) {
+    if (zz) MP_DROP(zz);
+    SYNERR("bad binary polynomial");
+  }
+  z = Py_BuildValue("(Ns#)", gf_pywrap(zz), sc.buf, (int)(sc.lim - sc.buf));
 end:
   return (z);
 }
@@ -1995,6 +2141,58 @@ end:
   return (rc);
 }
 
+static PyObject *grmeth_trace(PyObject *me, PyObject *arg)
+{
+  PyObject *rc = 0;
+  mp *xx = 0;
+
+  if (!PyArg_ParseTuple(arg, "O&:trace", convgf, &xx)) goto end;
+  rc = PyInt_FromLong(gfreduce_trace(GFREDUCE_PY(me), xx));
+end:
+  if (xx) MP_DROP(xx);
+  return (rc);
+}
+
+static PyObject *grmeth_halftrace(PyObject *me, PyObject *arg)
+{
+  PyObject *rc = 0;
+  mp *xx = 0;
+
+  if (!PyArg_ParseTuple(arg, "O&:halftrace", convgf, &xx)) goto end;
+  rc = gf_pywrap(gfreduce_halftrace(GFREDUCE_PY(me), MP_NEW, xx));
+end:
+  if (xx) MP_DROP(xx);
+  return (rc);
+}
+
+static PyObject *grmeth_sqrt(PyObject *me, PyObject *arg)
+{
+  PyObject *rc = 0;
+  mp *xx = 0, *yy;
+
+  if (!PyArg_ParseTuple(arg, "O&:sqrt", convgf, &xx)) goto end;
+  if ((yy = gfreduce_sqrt(GFREDUCE_PY(me), MP_NEW, xx)) == 0)
+    VALERR("no modular square root");
+  rc = gf_pywrap(yy);
+end:
+  if (xx) MP_DROP(xx);
+  return (rc);
+}
+
+static PyObject *grmeth_quadsolve(PyObject *me, PyObject *arg)
+{
+  PyObject *rc = 0;
+  mp *xx = 0, *yy;
+
+  if (!PyArg_ParseTuple(arg, "O&:quadsolve", convgf, &xx)) goto end;
+  if ((yy = gfreduce_quadsolve(GFREDUCE_PY(me), MP_NEW, xx)) == 0)
+    VALERR("no solution found");
+  rc = gf_pywrap(yy);
+end:
+  if (xx) MP_DROP(xx);
+  return (rc);
+}
+
 static PyObject *grmeth_reduce(PyObject *me, PyObject *arg)
 {
   PyObject *z = 0;
@@ -2044,6 +2242,10 @@ static PyGetSetDef gfreduce_pygetset[] = {
 static PyMethodDef gfreduce_pymethods[] = {
 #define METHNAME(name) grmeth_##name
   METH	(reduce,	"R.reduce(X) -> X mod B.m")
+  METH	(trace,	       "R.trace(X) -> Tr(X) = x + x^2 + ... + x^{2^{m - 1}}")
+  METH	(halftrace,   "R.halftrace(X) -> x + x^{2^2} + ... + x^{2^{m - 1}}")
+  METH	(sqrt,		"R.sqrt(X) -> Y where Y^2 = X mod R")
+  METH	(quadsolve,	"R.quadsolve(X) -> Y where Y^2 + Y = X mod R")
   METH	(exp,		"R.exp(X, N) -> X^N mod B.m")
 #undef METHNAME
   { 0 }
@@ -2258,8 +2460,6 @@ loadl2c(STR) -> X: read little-endian bytes, two's complement")
 loadb2c(STR) -> X: read big-endian bytes, two's complement")
   METH	(_MP_frombuf,		"\
 frombuf(STR) -> (X, REST): read buffer format")
-  METH	(_MP_product,		"\
-product(ITER) -> X: product of things iterated over")
   METH	(_GF_loadl,		"\
 loadl(STR) -> X: read little-endian bytes")
   METH	(_GF_loadb,		"\
@@ -2274,6 +2474,7 @@ void mp_pyinit(void)
 {
   INITTYPE(mp, root);
   INITTYPE(gf, root);
+  INITTYPE(mpmul, root);
   INITTYPE(mpmont, root);
   INITTYPE(mpbarrett, root);
   INITTYPE(mpreduce, root);
@@ -2286,6 +2487,7 @@ void mp_pyinit(void)
 void mp_pyinsert(PyObject *mod)
 {
   INSERT("MP", mp_pytype);
+  INSERT("MPMul", mpmul_pytype);
   INSERT("MPMont", mpmont_pytype);
   INSERT("MPBarrett", mpbarrett_pytype);
   INSERT("MPReduce", mpreduce_pytype);