5 * (c) 2004 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the Python interface to Catacomb.
12 * Catacomb/Python is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * Catacomb/Python is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with Catacomb/Python; if not, write to the Free Software Foundation,
24 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 /*----- Header files ------------------------------------------------------*/
29 #include "catacomb-python.h"
31 /*----- Various utilities -------------------------------------------------*/
33 PyTypeObject *field_pytype;
34 PyTypeObject *primefield_pytype;
35 PyTypeObject *niceprimefield_pytype;
36 PyTypeObject *binfield_pytype;
37 PyTypeObject *binpolyfield_pytype;
38 PyTypeObject *binnormfield_pytype;
39 PyTypeObject *fe_pytype;
41 static PyObject *fe_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
45 static const char *const kwlist[] = { "x", 0 };
47 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O:fe", KWLIST, &x))
49 if (FE_PYCHECK(x) && FE_F(x) == FIELD_F(ty)) RETURN_OBJ(x);
50 if ((z = getmp(x)) == 0) return (0);
51 z = F_IN(FIELD_F(ty), z, z);
52 return (fe_pywrap((PyObject *)ty, z));
55 static PyObject *field_dopywrap(PyTypeObject *ty, field *f)
57 field_pyobj *fobj = newtype(ty, 0, f->ops->name);
59 fobj->ty.ht_type.tp_basicsize = sizeof(fe_pyobj);
60 fobj->ty.ht_type.tp_base = fe_pytype;
62 fobj->ty.ht_type.tp_flags = (Py_TPFLAGS_DEFAULT |
64 Py_TPFLAGS_CHECKTYPES |
66 fobj->ty.ht_type.tp_alloc = PyType_GenericAlloc;
67 fobj->ty.ht_type.tp_free = 0;
68 fobj->ty.ht_type.tp_new = fe_pynew;
69 typeready(&fobj->ty.ht_type);
70 return ((PyObject *)fobj);
73 PyObject *field_pywrap(field *f)
77 if (STRCMP(F_NAME(f), ==, "prime")) ty = primefield_pytype;
78 else if (STRCMP(F_NAME(f), ==, "niceprime")) ty = niceprimefield_pytype;
79 else if (STRCMP(F_NAME(f), ==, "binpoly")) ty = binpolyfield_pytype;
80 else if (STRCMP(F_NAME(f), ==, "binnorm")) ty = binnormfield_pytype;
82 return (field_dopywrap(ty, f));
85 field *field_copy(field *f)
87 if (STRCMP(F_NAME(f), ==, "prime"))
88 f = field_prime(f->m);
89 else if (STRCMP(F_NAME(f), ==, "niceprime"))
90 f = field_niceprime(f->m);
91 else if (STRCMP(F_NAME(f), ==, "binpoly"))
92 f = field_binpoly(f->m);
93 else if (STRCMP(F_NAME(f), ==, "binnorm")) {
94 fctx_binnorm *fc = (fctx_binnorm *)f;
95 f = field_binnorm(f->m, fc->ntop.r[fc->ntop.n - 1]);
101 PyObject *fe_pywrap(PyObject *fobj, mp *x)
103 fe_pyobj *z = PyObject_New(fe_pyobj, (PyTypeObject *)fobj);
104 z->f = FIELD_F(fobj);
107 return ((PyObject *)z);
110 static mp *implicitfe(field *f, PyObject *o)
114 if (FE_PYCHECK(o) && FE_F(o) == f) return (MP_COPY(FE_X(o)));
115 switch (f->ops->ty) {
116 case FTY_PRIME: x = implicitmp(o); break;
117 case FTY_BINARY: x = implicitgf(o); break;
118 default: assert(!"huh?");
121 return (F_IN(f, MP_NEW, x));
124 /*----- Field elements ----------------------------------------------------*/
126 static int febinop(PyObject *x, PyObject *y,
127 field **f, PyObject **fobj, mp **xx, mp **yy)
129 if (FE_PYCHECK(x)) *fobj = FE_FOBJ(x);
130 else if (FE_PYCHECK(y)) *fobj = FE_FOBJ(y);
133 if ((*xx = implicitfe(*f, x)) == 0)
135 if ((*yy = implicitfe(*f, y)) == 0) {
142 #define BINOP(name) \
143 static PyObject *fe_py##name(PyObject *x, PyObject *y) { \
147 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL; \
148 zz = ff->ops->name(ff, MP_NEW, xx, yy); \
149 MP_DROP(xx); MP_DROP(yy); \
150 return (fe_pywrap(fobj, zz)); \
157 static PyObject *fe_pydiv(PyObject *x, PyObject *y)
163 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL;
164 if (F_ZEROP(ff, yy)) ZDIVERR("division by zero");
165 yy = F_INV(ff, yy, yy);
166 z = fe_pywrap(fobj, F_MUL(ff, MP_NEW, xx, yy));
168 MP_DROP(xx); MP_DROP(yy);
172 static PyObject *fe_pyexp(PyObject *x, PyObject *y, PyObject *z)
177 if (z != Py_None || !FE_PYCHECK(x)) RETURN_NOTIMPL;
178 if (FE_PYCHECK(y) && FE_F(y)->ops->ty == FTY_PRIME)
179 yy = F_OUT(FE_F(y), MP_NEW, FE_X(y));
180 else if ((yy = implicitmp(y)) == 0)
182 ff = FE_F(x); xx = FE_X(x); MP_COPY(xx);
183 if (MP_NEGP(yy) && F_ZEROP(ff, xx)) ZDIVERR("division by zero");
184 z = fe_pywrap(FE_FOBJ(x), field_exp(ff, MP_NEW, xx, yy));
186 MP_DROP(xx); MP_DROP(yy);
190 static PyObject *fe_pyneg(PyObject *x)
192 return fe_pywrap(FE_FOBJ(x), FE_F(x)->ops->neg(FE_F(x), MP_NEW, FE_X(x)));
195 static PyObject *fe_pyid(PyObject *x) { RETURN_OBJ(x); }
197 static int fe_pynonzerop(PyObject *x) { return !F_ZEROP(FE_F(x), FE_X(x)); }
199 static PyObject *fe_pyrichcompare(PyObject *x, PyObject *y, int op)
207 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL;
209 case Py_EQ: b = MP_EQ(xx, yy); break;
210 case Py_NE: b = !MP_EQ(xx, yy); break;
211 default: TYERR("field elements are unordered");
215 MP_DROP(xx); MP_DROP(yy);
219 static Py_hash_t fe_pyhash(PyObject *me)
220 { return (mphash(FE_X(me))); }
223 static int fe_pycoerce(PyObject **x, PyObject **y)
227 if (FE_PYCHECK(*y)) {
228 if (FE_F(*x) != FE_F(*y) && !field_samep(FE_F(*x), FE_F(*y)))
229 TYERR("field mismatch");
230 Py_INCREF(*x); Py_INCREF(*y);
233 if ((z = implicitfe(FE_F(*x), *y)) != 0) {
235 *y = fe_pywrap(FE_FOBJ(*x), z);
245 static PyObject *fe_pyint(PyObject *x)
249 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x));
250 if (!mp_tolong_checked(xx, &l, 0)) rc = PyInt_FromLong(l);
251 else rc = mp_topylong(xx);
257 static PyObject *fe_pylong(PyObject *x)
259 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x));
260 PyObject *rc = mp_topylong(xx);
266 #define BASEOP(name, radix, pre) \
267 static PyObject *fe_py##name(PyObject *x) { \
268 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x)); \
269 PyObject *rc = mp_topystring(xx, radix, 0, pre, 0); \
276 BASEOP(hex, 16, "0x");
279 static void fe_pydealloc(PyObject *me)
281 Py_DECREF(FE_FOBJ(me));
286 #define UNOP(name, check) \
287 static PyObject *femeth_##name(PyObject *me) { \
288 field *f = FE_F(me); \
290 if (!f->ops->name) TYERR(#name " not supported for this field"); \
292 x = f->ops->name(f, MP_NEW, x); \
293 if (!x) RETURN_NONE; \
294 return (fe_pywrap(FE_FOBJ(me), x)); \
298 UNOP(inv, if (F_ZEROP(f, x)) ZDIVERR("division by zero"); )
308 static PyObject *feget_value(PyObject *me, void *hunoz)
310 mp *x = F_OUT(FE_F(me), MP_NEW, FE_X(me));
311 if (F_TYPE(FE_F(me)) == FTY_BINARY)
312 return (gf_pywrap(x));
314 return (mp_pywrap(x));
317 static PyObject *feget__value(PyObject *me, void *hunoz)
321 if (F_TYPE(FE_F(me)) == FTY_BINARY)
322 return (gf_pywrap(x));
324 return (mp_pywrap(x));
327 static const PyMemberDef fe_pymembers[] = {
328 #define MEMBERSTRUCT fe_pyobj
329 MEMRNM(field, T_OBJECT, PY23(ob_type, ob_base.ob_type), READONLY,
330 "X.field -> field containing X")
335 static const PyGetSetDef fe_pygetset[] = {
336 #define GETSETNAME(op, name) fe##op##_##name
337 GET (value, "X.value -> `natural' MP/GF representation of X")
338 GET (_value, "X._value -> internal MP/GF representation of X")
343 static const PyMethodDef fe_pymethods[] = {
344 #define METHNAME(func) femeth_##func
345 NAMETH(inv, "X.inv() -> X^{-1}")
346 NAMETH(sqr, "X.sqr() -> X^2")
347 NAMETH(sqrt, "X.sqrt() -> sqrt(X)")
348 NAMETH(quadsolve, "X.quadsolve() -> Y where Y^2 + Y = X (binary only)")
349 NAMETH(dbl, "X.dbl() -> 2 * X (prime only)")
350 NAMETH(tpl, "X.tpl() -> 3 * X (prime only)")
351 NAMETH(qdl, "X.qdl() -> 4 * X (prime only)")
352 NAMETH(hlv, "X.hlv() -> X/2 (prime only)")
357 static const PyNumberMethods fe_pynumber = {
358 fe_pyadd, /* @nb_add@ */
359 fe_pysub, /* @nb_subtract@ */
360 fe_pymul, /* @nb_multiply@ */
362 fe_pydiv, /* @nb_divide@ */
364 0, /* @nb_remainder@ */
366 fe_pyexp, /* @nb_power@ */
367 fe_pyneg, /* @nb_negative@ */
368 fe_pyid, /* @nb_positive@ */
369 0, /* @nb_absolute@ */
370 fe_pynonzerop, /* @nb_nonzero@ */
378 fe_pycoerce, /* @nb_coerce@ */
380 fe_pyint, /* @nb_int@ */
381 PY23(fe_pylong, 0), /* @nb_long@ */
382 0 /* meaningless */, /* @nb_float@ */
384 fe_pyoct, /* @nb_oct@ */
385 fe_pyhex, /* @nb_hex@ */
388 0, /* @nb_inplace_add@ */
389 0, /* @nb_inplace_subtract@ */
390 0, /* @nb_inplace_multiply@ */
392 0, /* @nb_inplace_divide@ */
394 0, /* @nb_inplace_remainder@ */
395 0, /* @nb_inplace_power@ */
396 0, /* @nb_inplace_lshift@ */
397 0, /* @nb_inplace_rshift@ */
398 0, /* @nb_inplace_and@ */
399 0, /* @nb_inplace_xor@ */
400 0, /* @nb_inplace_or@ */
402 0, /* @nb_floor_divide@ */
403 fe_pydiv, /* @nb_true_divide@ */
404 0, /* @nb_inplace_floor_divide@ */
405 0, /* @nb_inplace_true_divide@ */
407 fe_pyint, /* @nb_index@ */
410 static const PyTypeObject fe_pytype_skel = {
411 PyVarObject_HEAD_INIT(0, 0) /* Header */
412 "FE", /* @tp_name@ */
413 sizeof(fe_pyobj), /* @tp_basicsize@ */
414 0, /* @tp_itemsize@ */
416 fe_pydealloc, /* @tp_dealloc@ */
418 0, /* @tp_getattr@ */
419 0, /* @tp_setattr@ */
420 0, /* @tp_compare@ */
422 PYNUMBER(fe), /* @tp_as_number@ */
423 0, /* @tp_as_sequence@ */
424 0, /* @tp_as_mapping@ */
425 fe_pyhash, /* @tp_hash@ */
427 fe_pyhex, /* @tp_str@ */
428 0, /* @tp_getattro@ */
429 0, /* @tp_setattro@ */
430 0, /* @tp_as_buffer@ */
431 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
432 Py_TPFLAGS_CHECKTYPES |
436 "Finite field elements, abstract base class.",
438 0, /* @tp_traverse@ */
440 fe_pyrichcompare, /* @tp_richcompare@ */
441 0, /* @tp_weaklistoffset@ */
443 0, /* @tp_iternext@ */
444 PYMETHODS(fe), /* @tp_methods@ */
445 PYMEMBERS(fe), /* @tp_members@ */
446 PYGETSET(fe), /* @tp_getset@ */
449 0, /* @tp_descr_get@ */
450 0, /* @tp_descr_set@ */
451 0, /* @tp_dictoffset@ */
453 PyType_GenericAlloc, /* @tp_alloc@ */
454 abstract_pynew, /* @tp_new@ */
459 /*----- Fields ------------------------------------------------------------*/
461 static PyObject *field_pyrichcompare(PyObject *x, PyObject *y, int op)
463 int b = field_samep(FIELD_F(x), FIELD_F(y));
467 default: TYERR("can't order fields");
474 static PyObject *fmeth_rand(PyObject *me, PyObject *arg, PyObject *kw)
476 static const char *const kwlist[] = { "rng", 0 };
477 grand *r = &rand_global;
479 if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:rand", KWLIST,
482 return (fe_pywrap(me, F_RAND(FIELD_F(me), MP_NEW, r)));
485 static PyObject *fmeth__adopt(PyObject *me, PyObject *arg)
488 if (!PyArg_ParseTuple(arg, "O&:_adopt", convmp, &xx)) return (0);
489 return (fe_pywrap(me, xx));
492 static PyObject *fmeth_parse(PyObject *me, PyObject *arg)
499 if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
501 if ((f = field_parse(&qd)) == 0) VALERR(qd.e);
502 rc = Py_BuildValue("(Ns)", field_pywrap(f), qd.p);
507 static void field_pydealloc(PyObject *me)
509 F_DESTROY(FIELD_F(me));
510 PyType_Type.tp_dealloc(me);
513 static PyObject *fget_zero(PyObject *me, void *hunoz)
514 { return (fe_pywrap(me, MP_COPY(FIELD_F(me)->zero))); }
516 static PyObject *fget_one(PyObject *me, void *hunoz)
517 { return (fe_pywrap(me, MP_COPY(FIELD_F(me)->one))); }
519 static PyObject *fget_q(PyObject *me, void *hunoz)
520 { return (mp_pywrap(MP_COPY(FIELD_F(me)->q))); }
522 static PyObject *fget_nbits(PyObject *me, void *hunoz)
523 { return (PyInt_FromLong(FIELD_F(me)->nbits)); }
525 static PyObject *fget_noctets(PyObject *me, void *hunoz)
526 { return (PyInt_FromLong(FIELD_F(me)->noctets)); }
528 static PyObject *fget_name(PyObject *me, void *hunoz)
529 { return (TEXT_FROMSTR(F_NAME(FIELD_F(me)))); }
531 static PyObject *fget_type(PyObject *me, void *hunoz)
532 { return (PyInt_FromLong(F_TYPE(FIELD_F(me)))); }
534 static const PyGetSetDef field_pygetset[] = {
535 #define GETSETNAME(op, name) f##op##_##name
536 GET (zero, "F.zero -> field additive identity")
537 GET (one, "F.one -> field multiplicative identity")
538 GET (q, "F.q -> number of elements in field")
539 GET (nbits, "F.nbits -> bits needed to represent element")
540 GET (noctets, "F.noctets -> octetss needed to represent element")
541 GET (name, "F.name -> name of this kind of field")
542 GET (type, "F.type -> type code of this kind of field")
547 static const PyMethodDef field_pymethods[] = {
548 #define METHNAME(name) fmeth_##name
549 METH (_adopt, "F._adopt(X) -> FE")
550 KWMETH(rand, "F.rand([rng = rand]) -> FE, uniformly distributed")
551 SMTH (parse, "parse(STR) -> F, REST")
556 static const PyTypeObject field_pytype_skel = {
557 PyVarObject_HEAD_INIT(0, 0) /* Header */
558 "Field", /* @tp_name@ */
559 sizeof(field_pyobj), /* @tp_basicsize@ */
560 0, /* @tp_itemsize@ */
562 field_pydealloc, /* @tp_dealloc@ */
564 0, /* @tp_getattr@ */
565 0, /* @tp_setattr@ */
566 0, /* @tp_compare@ */
568 0, /* @tp_as_number@ */
569 0, /* @tp_as_sequence@ */
570 0, /* @tp_as_mapping@ */
574 0, /* @tp_getattro@ */
575 0, /* @tp_setattro@ */
576 0, /* @tp_as_buffer@ */
577 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
581 "An abstract field. This is an abstract type.",
583 0, /* @tp_traverse@ */
585 field_pyrichcompare, /* @tp_richcompare@ */
586 0, /* @tp_weaklistoffset@ */
588 0, /* @tp_iternext@ */
589 PYMETHODS(field), /* @tp_methods@ */
590 0, /* @tp_members@ */
591 PYGETSET(field), /* @tp_getset@ */
594 0, /* @tp_descr_get@ */
595 0, /* @tp_descr_set@ */
596 0, /* @tp_dictoffset@ */
598 PyType_GenericAlloc, /* @tp_alloc@ */
599 abstract_pynew, /* @tp_new@ */
604 /*----- Prime fields ------------------------------------------------------*/
606 static PyObject *primefield_pynew(PyTypeObject *ty,
607 PyObject *arg, PyObject *kw)
611 static const char *const kwlist[] = { "p", 0 };
613 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:primefield", KWLIST,
616 if ((f = field_prime(xx)) == 0)
617 VALERR("bad prime for primefield");
619 return (field_dopywrap(ty, f));
625 static PyObject *pfget_p(PyObject *me, void *hunoz)
626 { return (mp_pywrap(MP_COPY(FIELD_F(me)->m))); }
628 static const PyGetSetDef primefield_pygetset[] = {
629 #define GETSETNAME(op, name) pf##op##_##name
630 GET (p, "F.p -> prime field characteristic")
634 static const PyTypeObject primefield_pytype_skel = {
635 PyVarObject_HEAD_INIT(0, 0) /* Header */
636 "PrimeField", /* @tp_name@ */
637 sizeof(field_pyobj), /* @tp_basicsize@ */
638 0, /* @tp_itemsize@ */
640 field_pydealloc, /* @tp_dealloc@ */
642 0, /* @tp_getattr@ */
643 0, /* @tp_setattr@ */
644 0, /* @tp_compare@ */
646 0, /* @tp_as_number@ */
647 0, /* @tp_as_sequence@ */
648 0, /* @tp_as_mapping@ */
652 0, /* @tp_getattro@ */
653 0, /* @tp_setattro@ */
654 0, /* @tp_as_buffer@ */
655 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
659 "PrimeField(P): prime fields.",
661 0, /* @tp_traverse@ */
663 0, /* @tp_richcompare@ */
664 0, /* @tp_weaklistoffset@ */
666 0, /* @tp_iternext@ */
667 0, /* @tp_methods@ */
668 0, /* @tp_members@ */
669 PYGETSET(primefield), /* @tp_getset@ */
672 0, /* @tp_descr_get@ */
673 0, /* @tp_descr_set@ */
674 0, /* @tp_dictoffset@ */
676 PyType_GenericAlloc, /* @tp_alloc@ */
677 primefield_pynew, /* @tp_new@ */
682 static PyObject *niceprimefield_pynew(PyTypeObject *ty,
683 PyObject *arg, PyObject *kw)
687 static const char *const kwlist[] = { "p", 0 };
689 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:niceprimefield",
690 KWLIST, convmp, &xx))
692 if ((f = field_niceprime(xx)) == 0)
693 VALERR("bad prime for niceprimefield");
695 return (field_dopywrap(ty, f));
701 static const PyTypeObject niceprimefield_pytype_skel = {
702 PyVarObject_HEAD_INIT(0, 0) /* Header */
703 "NicePrimeField", /* @tp_name@ */
704 sizeof(field_pyobj), /* @tp_basicsize@ */
705 0, /* @tp_itemsize@ */
707 field_pydealloc, /* @tp_dealloc@ */
709 0, /* @tp_getattr@ */
710 0, /* @tp_setattr@ */
711 0, /* @tp_compare@ */
713 0, /* @tp_as_number@ */
714 0, /* @tp_as_sequence@ */
715 0, /* @tp_as_mapping@ */
719 0, /* @tp_getattro@ */
720 0, /* @tp_setattro@ */
721 0, /* @tp_as_buffer@ */
722 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
726 "NicePrimeField(P): prime field using Solinas reduction.",
728 0, /* @tp_traverse@ */
730 0, /* @tp_richcompare@ */
731 0, /* @tp_weaklistoffset@ */
733 0, /* @tp_iternext@ */
734 0, /* @tp_methods@ */
735 0, /* @tp_members@ */
739 0, /* @tp_descr_get@ */
740 0, /* @tp_descr_set@ */
741 0, /* @tp_dictoffset@ */
743 PyType_GenericAlloc, /* @tp_alloc@ */
744 niceprimefield_pynew, /* @tp_new@ */
749 /*----- Binary fields -----------------------------------------------------*/
751 static PyObject *bfget_m(PyObject *me, void *hunoz)
752 { return (PyInt_FromLong(FIELD_F(me)->nbits)); }
754 static PyObject *bfget_p(PyObject *me, void *hunoz)
755 { return (gf_pywrap(MP_COPY(FIELD_F(me)->m))); }
757 static const PyGetSetDef binfield_pygetset[] = {
758 #define GETSETNAME(op, name) bf##op##_##name
759 GET (m, "F.m -> field polynomial degree")
760 GET (p, "F.p -> field polynomial")
765 static const PyTypeObject binfield_pytype_skel = {
766 PyVarObject_HEAD_INIT(0, 0) /* Header */
767 "BinField", /* @tp_name@ */
768 sizeof(field_pyobj), /* @tp_basicsize@ */
769 0, /* @tp_itemsize@ */
771 field_pydealloc, /* @tp_dealloc@ */
773 0, /* @tp_getattr@ */
774 0, /* @tp_setattr@ */
775 0, /* @tp_compare@ */
777 0, /* @tp_as_number@ */
778 0, /* @tp_as_sequence@ */
779 0, /* @tp_as_mapping@ */
783 0, /* @tp_getattro@ */
784 0, /* @tp_setattro@ */
785 0, /* @tp_as_buffer@ */
786 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
790 "Binary fields. Abstract class.",
792 0, /* @tp_traverse@ */
794 0, /* @tp_richcompare@ */
795 0, /* @tp_weaklistoffset@ */
797 0, /* @tp_iternext@ */
798 0, /* @tp_methods@ */
799 0, /* @tp_members@ */
800 PYGETSET(binfield), /* @tp_getset@ */
803 0, /* @tp_descr_get@ */
804 0, /* @tp_descr_set@ */
805 0, /* @tp_dictoffset@ */
807 PyType_GenericAlloc, /* @tp_alloc@ */
808 abstract_pynew, /* @tp_new@ */
813 static PyObject *binpolyfield_pynew(PyTypeObject *ty,
814 PyObject *arg, PyObject *kw)
818 static const char *const kwlist[] = { "p", 0 };
820 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:binpolyfield", KWLIST,
823 if ((f = field_binpoly(xx)) == 0) VALERR("bad poly for binpolyfield");
825 return (field_dopywrap(ty, f));
831 static const PyTypeObject binpolyfield_pytype_skel = {
832 PyVarObject_HEAD_INIT(0, 0) /* Header */
833 "BinPolyField", /* @tp_name@ */
834 sizeof(field_pyobj), /* @tp_basicsize@ */
835 0, /* @tp_itemsize@ */
837 field_pydealloc, /* @tp_dealloc@ */
839 0, /* @tp_getattr@ */
840 0, /* @tp_setattr@ */
841 0, /* @tp_compare@ */
843 0, /* @tp_as_number@ */
844 0, /* @tp_as_sequence@ */
845 0, /* @tp_as_mapping@ */
849 0, /* @tp_getattro@ */
850 0, /* @tp_setattro@ */
851 0, /* @tp_as_buffer@ */
852 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
856 "BinPolyField(P): binary fields with polynomial basis representation.",
858 0, /* @tp_traverse@ */
860 0, /* @tp_richcompare@ */
861 0, /* @tp_weaklistoffset@ */
863 0, /* @tp_iternext@ */
864 0, /* @tp_methods@ */
865 0, /* @tp_members@ */
869 0, /* @tp_descr_get@ */
870 0, /* @tp_descr_set@ */
871 0, /* @tp_dictoffset@ */
873 PyType_GenericAlloc, /* @tp_alloc@ */
874 binpolyfield_pynew, /* @tp_new@ */
879 static PyObject *binnormfield_pynew(PyTypeObject *ty,
880 PyObject *arg, PyObject *kw)
884 static const char *const kwlist[] = { "p", "beta", 0 };
886 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:binnormfield",
887 KWLIST, convgf, &xx, convgf, &yy))
889 if ((f = field_binnorm(xx, yy)) == 0) VALERR("bad args for binnormfield");
890 MP_DROP(xx); MP_DROP(yy);
891 return (field_dopywrap(ty, f));
893 mp_drop(xx); mp_drop(yy);
897 static PyObject *bnfget_beta(PyObject *me, void *hunoz)
899 fctx_binnorm *fc = (fctx_binnorm *)FIELD_F(me);
900 return (gf_pywrap(MP_COPY(fc->ntop.r[fc->ntop.n - 1])));
903 static const PyGetSetDef binnormfield_pygetset[] = {
904 #define GETSETNAME(op, name) bnf##op##_##name
905 GET (beta, "F.beta -> conversion factor")
910 static const PyTypeObject binnormfield_pytype_skel = {
911 PyVarObject_HEAD_INIT(0, 0) /* Header */
912 "BinNormField", /* @tp_name@ */
913 sizeof(field_pyobj), /* @tp_basicsize@ */
914 0, /* @tp_itemsize@ */
916 field_pydealloc, /* @tp_dealloc@ */
918 0, /* @tp_getattr@ */
919 0, /* @tp_setattr@ */
920 0, /* @tp_compare@ */
922 0, /* @tp_as_number@ */
923 0, /* @tp_as_sequence@ */
924 0, /* @tp_as_mapping@ */
928 0, /* @tp_getattro@ */
929 0, /* @tp_setattro@ */
930 0, /* @tp_as_buffer@ */
931 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
935 "BinNormField(P, BETA): binary fields with normal basis representation.",
937 0, /* @tp_traverse@ */
939 0, /* @tp_richcompare@ */
940 0, /* @tp_weaklistoffset@ */
942 0, /* @tp_iternext@ */
943 0, /* @tp_methods@ */
944 0, /* @tp_members@ */
945 PYGETSET(binnormfield), /* @tp_getset@ */
948 0, /* @tp_descr_get@ */
949 0, /* @tp_descr_set@ */
950 0, /* @tp_dictoffset@ */
952 PyType_GenericAlloc, /* @tp_alloc@ */
953 binnormfield_pynew, /* @tp_new@ */
958 /*----- Setup -------------------------------------------------------------*/
960 static const struct nameval consts[] = {
961 CONST(FTY_PRIME), CONST(FTY_BINARY),
965 void field_pyinit(void)
968 INITTYPE(field, type);
969 INITTYPE(primefield, field);
970 INITTYPE(niceprimefield, primefield);
971 INITTYPE(binfield, field);
972 INITTYPE(binpolyfield, binfield);
973 INITTYPE(binnormfield, binfield);
976 void field_pyinsert(PyObject *mod)
978 INSERT("FE", fe_pytype);
979 INSERT("Field", field_pytype);
980 INSERT("PrimeField", primefield_pytype);
981 INSERT("NicePrimeField", niceprimefield_pytype);
982 INSERT("BinField", binfield_pytype);
983 INSERT("BinPolyField", binpolyfield_pytype);
984 INSERT("BinNormField", binnormfield_pytype);
985 setconstants(mod, consts);
988 /*----- That's all, folks -------------------------------------------------*/