Draft of ModPoly

#include <Python.h>
#include <structmember.h>


#define BAD_MODULUS -1
#define BAD_DEGREE -1
#define ModPoly_Check(v) (PyObject_TypeCheck(v, &ModPolyType))


typedef struct {
    PyObject_HEAD
    /* Type specific fields */
    PyObject *r_modulus;
    PyObject *n_modulus;
    PyObject *degree;
} ModPoly;


static PyTypeObject ModPolyType;
static PyObject *ModPoly_Equal(PyObject *, PyObject *);


static void
ModPoly_dealloc(ModPoly *self)
{
    Py_XDECREF(self->r_modulus);
    Py_XDECREF(self->n_modulus);
    Py_XDECREF(self->degree);
    self->ob_type->tp_free((PyObject *)self);
}


static PyObject *
ModPoly_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    ModPoly *self;

    self = (ModPoly *)type->tp_alloc(type, 0);
    if (self != NULL) {
        self->r_modulus = PyInt_FromLong(BAD_MODULUS);
        if (self->r_modulus == NULL) {
            Py_DECREF(self);
            return NULL;
        }

        self->n_modulus = PyInt_FromLong(BAD_MODULUS);
        if (self->n_modulus == NULL) {
            Py_DECREF(self);
            return NULL;
        }

        self->degree = PyInt_FromLong(BAD_DEGREE);
        if (self->degree == NULL) {
            Py_DECREF(self);
            return NULL;
        }
    }

    return (PyObject *)self;
}


static int
ModPoly_init(ModPoly *self, PyObject *args, PyObject *kwds)
{
    PyObject *r_modulus=NULL, *n_modulus=NULL, *coefs=NULL, *tmp;

    static char *kwlist[] = {"r_modulus", "n_modulus", "coefficients", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist,
                                     &r_modulus, &n_modulus, &coefs))
        return -1;

    if (r_modulus) {
        if (!PyInt_Check(r_modulus) && PyLong_Check(r_modulus)) {
            PyErr_SetString(PyExc_TypeError, "The r modulus must be an integer.");
            return -1;
        }
        tmp = self->r_modulus;
        Py_INCREF(r_modulus);
        self->r_modulus = r_modulus;
        Py_XDECREF(tmp);
    }

    if (n_modulus) {
        if (!PyInt_Check(n_modulus) && PyLong_Check(n_modulus)) {
            PyErr_SetString(PyExc_TypeError, "The n modulus must be an integer.");
            Py_DECREF(self->r_modulus);
            return -1;
        }
        tmp = self->n_modulus;
        Py_INCREF(n_modulus);
        self->n_modulus = n_modulus;
        Py_XDECREF(tmp);
    }

    self->degree = PyInt_FromLong(1);
    if (self->degree == NULL) {
        Py_DECREF(self->r_modulus);
        Py_DECREF(self->n_modulus);
        return -1;
    }

    return 0;
}


static PyObject *
ModPoly_compare(PyObject *a, PyObject *b, int op)
{
    switch (op) {
        case Py_EQ:
            return ModPoly_Equal(a, b);
            break;
        case Py_NE: {
            PyObject *res = ModPoly_Equal(a, b);
            int r;
            if (res == NULL)
                return NULL;
            r = PyObject_Not(res);
            Py_DECREF(res);
            if (r) {
                Py_RETURN_TRUE;
            } else {
                Py_RETURN_FALSE;
            }
            break; }
        default:
            Py_INCREF(Py_NotImplemented);
            return Py_NotImplemented;
            break;
    }
}


static PyObject *
ModPoly_Equal(PyObject *a, PyObject *b)
{
    if (!ModPoly_Check(b)) {
        Py_RETURN_FALSE;
    }
    ModPoly *A=(ModPoly *)a, *B=(ModPoly *)b;

    if (!PyObject_RichCompareBool(A->r_modulus, B->r_modulus,Py_EQ)) {
        Py_RETURN_FALSE;
    } else if (!PyObject_RichCompareBool(A->n_modulus, B->n_modulus,Py_EQ)) {
        Py_RETURN_FALSE;
    }

    Py_RETURN_TRUE;
}



static PyMemberDef ModPoly_members[] = {
    {"r_modulus", T_OBJECT_EX, offsetof(ModPoly, r_modulus), READONLY,
     "The exponent of the polynomial modulus (x^r-1)."},
    {"n_modulus", T_OBJECT_EX, offsetof(ModPoly, n_modulus), READONLY,
     "The coefficient modulus."},
    {"degree", T_OBJECT_EX, offsetof(ModPoly, degree), READONLY,
     "The polynomial degree."},
    {NULL}
};



static PyTypeObject ModPolyType = {
    PyObject_HEAD_INIT(NULL)
        0,                                                                      /* ob_size        */
        "algebra.polynomials.ModPolynomial",                    /* tp_name        */
        sizeof(ModPoly),                                                /* tp_basicsize   */
        0,                                                                      /* tp_itemsize    */
        (destructor)ModPoly_dealloc,                            /* 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 | Py_TPFLAGS_BASETYPE,               /* tp_flags       */
        "Represent a polynomial on (Z/nZ)[x]/x^r-1",            /* tp_doc         */
    0,                                                          /* tp_traverse */
    0,                                                          /* tp_clear */
    (richcmpfunc)ModPoly_compare,                           /* tp_richcompare */
    0,                                                          /* tp_weaklistoffset */
    0,                                                          /* tp_iter */
    0,                                                          /* tp_iternext */
    0,                                                      /* tp_methods */
    ModPoly_members,                                        /* tp_members */
    0,                                                      /* tp_getset */
    0,                                                      /* tp_base */
    0,                                                      /* tp_dict */
    0,                                                      /* tp_descr_get */
    0,                                                      /* tp_descr_set */
    0,                                                      /* tp_dictoffset */
    (initproc)ModPoly_init,                                 /* tp_init */
    0,                                                      /* tp_alloc */
    ModPoly_new,                                            /* tp_new */
};

static PyMethodDef module_methods[] = {
    {NULL, NULL, 0, NULL}  /* Sentinel */
};


#ifndef PyMODINIT_FUNC
#define PyMODINIT_FUNC void
#endif

PyMODINIT_FUNC
init_modpoly(void)
{
        PyObject *m;
    ModPolyType.tp_new = PyType_GenericNew;
        if (PyType_Ready(&ModPolyType) < 0)
                return;

        m = Py_InitModule3("_modpoly", module_methods,
                           "Representation of polynomials on (Z/nZ)[x]/x^r-1.");
        if (m == NULL)
                return;

        Py_INCREF(&ModPolyType);
        PyModule_AddObject(m, "ModPolynomial", (PyObject *)&ModPolyType);
}