numexpr 2.10.2__cp313-cp313-win32.whl

numexpr/numexpr_config.hpp

@@ -0,0 +1,51 @@
+#ifndef NUMEXPR_CONFIG_HPP
+#define NUMEXPR_CONFIG_HPP
+
+// x86 platform works with unaligned reads and writes
+// MW: I have seen exceptions to this when the compiler chooses to use aligned SSE
+#if (defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64))
+#  define USE_UNALIGNED_ACCESS 1
+#endif
+
+// #ifdef SCIPY_MKL_H
+// #define USE_VML
+// #endif
+
+#ifdef USE_VML
+/* The values below have been tuned for a Skylake processor (E3-1245 v5 @ 3.50GHz) */
+#define BLOCK_SIZE1 1024
+#else
+/* The values below have been tuned for a Skylake processor (E3-1245 v5 @ 3.50GHz) */
+#define BLOCK_SIZE1 1024
+#endif
+
+// The default threadpool size. It's prefer that the user set this via an 
+// environment variable, "NUMEXPR_MAX_THREADS"
+#define DEFAULT_MAX_THREADS 64
+
+// Remove dependence on NPY_MAXARGS, which would be a runtime constant instead of compiletime
+// constant. If numpy raises NPY_MAXARGS, we should notice and raise this as well
+#define NE_MAXARGS 64
+
+#if defined(_WIN32)
+  #include "win32/pthread.h"
+  #include <process.h>
+  #define getpid _getpid
+#else
+  #include <pthread.h>
+  #include "unistd.h"
+#endif
+
+#ifdef USE_VML
+#include "mkl_vml.h"
+#include "mkl_service.h"
+#endif
+
+#ifdef _WIN32
+  #ifndef __MINGW32__
+    #include "missing_posix_functions.hpp"
+  #endif
+  #include "msvc_function_stubs.hpp"
+#endif
+
+#endif // NUMEXPR_CONFIG_HPP

numexpr/numexpr_object.cpp

@@ -0,0 +1,408 @@
+/*********************************************************************
+  Numexpr - Fast numerical array expression evaluator for NumPy.
+
+      License: MIT
+      Author:  See AUTHORS.txt
+
+  See LICENSE.txt for details about copyright and rights to use.
+**********************************************************************/
+
+#include "module.hpp"
+#include <structmember.h>
+
+#include "numexpr_config.hpp"
+#include "interpreter.hpp"
+#include "numexpr_object.hpp"
+
+static int
+size_from_char(char c)
+{
+    switch (c) {
+        case 'b': return sizeof(char);
+        case 'i': return sizeof(int);
+        case 'l': return sizeof(long long);
+        case 'f': return sizeof(float);
+        case 'd': return sizeof(double);
+        case 'c': return 2*sizeof(double);
+        case 's': return 0;  /* strings are ok but size must be computed */
+        default:
+            PyErr_SetString(PyExc_TypeError, "signature value not in 'bilfdcs'");
+            return -1;
+    }
+}
+
+static void
+NumExpr_dealloc(NumExprObject *self)
+{
+    Py_XDECREF(self->signature);
+    Py_XDECREF(self->tempsig);
+    Py_XDECREF(self->constsig);
+    Py_XDECREF(self->fullsig);
+    Py_XDECREF(self->program);
+    Py_XDECREF(self->constants);
+    Py_XDECREF(self->input_names);
+    PyMem_Del(self->mem);
+    PyMem_Del(self->rawmem);
+    PyMem_Del(self->memsteps);
+    PyMem_Del(self->memsizes);
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject *
+NumExpr_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    NumExprObject *self = (NumExprObject *)type->tp_alloc(type, 0);
+    if (self != NULL) {
+#define INIT_WITH(name, object) \
+        self->name = object; \
+        if (!self->name) { \
+            Py_DECREF(self); \
+            return NULL; \
+        }
+
+        INIT_WITH(signature, PyBytes_FromString(""));
+        INIT_WITH(tempsig, PyBytes_FromString(""));
+        INIT_WITH(constsig, PyBytes_FromString(""));
+        INIT_WITH(fullsig, PyBytes_FromString(""));
+        INIT_WITH(program, PyBytes_FromString(""));
+        INIT_WITH(constants, PyTuple_New(0));
+        Py_INCREF(Py_None);
+        self->input_names = Py_None;
+        self->mem = NULL;
+        self->rawmem = NULL;
+        self->memsteps = NULL;
+        self->memsizes = NULL;
+        self->rawmemsize = 0;
+        self->n_inputs = 0;
+        self->n_constants = 0;
+        self->n_temps = 0;
+#undef INIT_WITH
+    }
+    return (PyObject *)self;
+}
+
+#define CHARP(s) ((char *)(s))
+
+static int
+NumExpr_init(NumExprObject *self, PyObject *args, PyObject *kwds)
+{
+    int i, j, mem_offset;
+    int n_inputs, n_constants, n_temps;
+    PyObject *signature = NULL, *tempsig = NULL, *constsig = NULL;
+    PyObject *fullsig = NULL, *program = NULL, *constants = NULL;
+    PyObject *input_names = NULL, *o_constants = NULL;
+    int *itemsizes = NULL;
+    char **mem = NULL, *rawmem = NULL;
+    npy_intp *memsteps;
+    npy_intp *memsizes;
+    int rawmemsize;
+    static char *kwlist[] = {CHARP("signature"), CHARP("tempsig"),
+			     CHARP("program"),  CHARP("constants"),
+			     CHARP("input_names"), NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "SSS|OO", kwlist,
+                                     &signature,
+                                     &tempsig,
+                                     &program, &o_constants,
+                                     &input_names)) {
+        return -1;
+    }
+
+    n_inputs = (int)PyBytes_Size(signature);
+    n_temps = (int)PyBytes_Size(tempsig);
+
+    if (o_constants) {
+        if (!PySequence_Check(o_constants) ) {
+                PyErr_SetString(PyExc_TypeError, "constants must be a sequence");
+                return -1;
+        }
+        n_constants = (int)PySequence_Length(o_constants);
+        if (!(constants = PyTuple_New(n_constants)))
+            return -1;
+        if (!(constsig = PyBytes_FromStringAndSize(NULL, n_constants))) {
+            Py_DECREF(constants);
+            return -1;
+        }
+        if (!(itemsizes = PyMem_New(int, n_constants))) {
+            Py_DECREF(constants);
+            return -1;
+        }
+        for (i = 0; i < n_constants; i++) {
+            PyObject *o;
+            if (!(o = PySequence_GetItem(o_constants, i))) { /* new reference */
+                Py_DECREF(constants);
+                Py_DECREF(constsig);
+                PyMem_Del(itemsizes);
+                return -1;
+            }
+            PyTuple_SET_ITEM(constants, i, o); /* steals reference */
+            if (PyBool_Check(o)) {
+                PyBytes_AS_STRING(constsig)[i] = 'b';
+                itemsizes[i] = size_from_char('b');
+                continue;
+            }
+
+            if (PyArray_IsScalar(o, Int32)) {
+                PyBytes_AS_STRING(constsig)[i] = 'i';
+                itemsizes[i] = size_from_char('i');
+                continue;
+            }
+
+            if (PyArray_IsScalar(o, Int64)) {
+                PyBytes_AS_STRING(constsig)[i] = 'l';
+                itemsizes[i] = size_from_char('l');
+                continue;
+            }
+            /* The Float32 scalars are the only ones that should reach here */
+            if (PyArray_IsScalar(o, Float32)) {
+                PyBytes_AS_STRING(constsig)[i] = 'f';
+                itemsizes[i] = size_from_char('f');
+                continue;
+            }
+            if (PyFloat_Check(o)) {
+                /* Python float constants are double precision by default */
+                PyBytes_AS_STRING(constsig)[i] = 'd';
+                itemsizes[i] = size_from_char('d');
+                continue;
+            }
+            if (PyComplex_Check(o)) {
+                PyBytes_AS_STRING(constsig)[i] = 'c';
+                itemsizes[i] = size_from_char('c');
+                continue;
+            }
+            if (PyBytes_Check(o)) {
+                PyBytes_AS_STRING(constsig)[i] = 's';
+                itemsizes[i] = (int)PyBytes_GET_SIZE(o);
+                continue;
+            }
+            PyErr_SetString(PyExc_TypeError, "constants must be of type bool/int/long/float/double/complex/bytes");
+            Py_DECREF(constsig);
+            Py_DECREF(constants);
+            PyMem_Del(itemsizes);
+            return -1;
+        }
+    } else {
+        n_constants = 0;
+        if (!(constants = PyTuple_New(0)))
+            return -1;
+        if (!(constsig = PyBytes_FromString(""))) {
+            Py_DECREF(constants);
+            return -1;
+        }
+    }
+
+    fullsig = PyBytes_FromFormat("%c%s%s%s", get_return_sig(program),
+        PyBytes_AS_STRING(signature), PyBytes_AS_STRING(constsig),
+        PyBytes_AS_STRING(tempsig));
+    if (!fullsig) {
+        Py_DECREF(constants);
+        Py_DECREF(constsig);
+        PyMem_Del(itemsizes);
+        return -1;
+    }
+
+    if (!input_names) {
+        input_names = Py_None;
+    }
+
+    /* Compute the size of registers. We leave temps out (will be
+       malloc'ed later on). */
+    rawmemsize = 0;
+    for (i = 0; i < n_constants; i++)
+        rawmemsize += itemsizes[i];
+    rawmemsize *= BLOCK_SIZE1;
+
+    mem = PyMem_New(char *, 1 + n_inputs + n_constants + n_temps);
+    rawmem = PyMem_New(char, rawmemsize);
+    memsteps = PyMem_New(npy_intp, 1 + n_inputs + n_constants + n_temps);
+    memsizes = PyMem_New(npy_intp, 1 + n_inputs + n_constants + n_temps);
+    if (!mem || !rawmem || !memsteps || !memsizes) {
+        Py_DECREF(constants);
+        Py_DECREF(constsig);
+        Py_DECREF(fullsig);
+        PyMem_Del(itemsizes);
+        PyMem_Del(mem);
+        PyMem_Del(rawmem);
+        PyMem_Del(memsteps);
+        PyMem_Del(memsizes);
+        return -1;
+    }
+    /*
+       0                                                  -> output
+       [1, n_inputs+1)                                    -> inputs
+       [n_inputs+1, n_inputs+n_consts+1)                  -> constants
+       [n_inputs+n_consts+1, n_inputs+n_consts+n_temps+1) -> temps
+    */
+    /* Fill in 'mem' and 'rawmem' for constants */
+    mem_offset = 0;
+    for (i = 0; i < n_constants; i++) {
+        char c = PyBytes_AS_STRING(constsig)[i];
+        int size = itemsizes[i];
+        mem[i+n_inputs+1] = rawmem + mem_offset;
+        mem_offset += BLOCK_SIZE1 * size;
+        memsteps[i+n_inputs+1] = memsizes[i+n_inputs+1] = size;
+        /* fill in the constants */
+        if (c == 'b') {
+            char *bmem = (char*)mem[i+n_inputs+1];
+            char value = (char)PyLong_AsLong(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < BLOCK_SIZE1; j++) {
+                bmem[j] = value;
+            }
+        } else if (c == 'i') {
+            int *imem = (int*)mem[i+n_inputs+1];
+            int value = (int)PyLong_AsLong(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < BLOCK_SIZE1; j++) {
+                imem[j] = value;
+            }
+        } else if (c == 'l') {
+            long long *lmem = (long long*)mem[i+n_inputs+1];
+            long long value = PyLong_AsLongLong(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < BLOCK_SIZE1; j++) {
+                lmem[j] = value;
+            }
+        } else if (c == 'f') {
+            /* In this particular case the constant is in a NumPy scalar
+             and in a regular Python object */
+            float *fmem = (float*)mem[i+n_inputs+1];
+            float value = PyArrayScalar_VAL(PyTuple_GET_ITEM(constants, i),
+                                            Float);
+            for (j = 0; j < BLOCK_SIZE1; j++) {
+                fmem[j] = value;
+            }
+        } else if (c == 'd') {
+            double *dmem = (double*)mem[i+n_inputs+1];
+            double value = PyFloat_AS_DOUBLE(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < BLOCK_SIZE1; j++) {
+                dmem[j] = value;
+            }
+        } else if (c == 'c') {
+            double *cmem = (double*)mem[i+n_inputs+1];
+            Py_complex value = PyComplex_AsCComplex(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < 2*BLOCK_SIZE1; j+=2) {
+                cmem[j] = value.real;
+                cmem[j+1] = value.imag;
+            }
+        } else if (c == 's') {
+            char *smem = (char*)mem[i+n_inputs+1];
+            char *value = PyBytes_AS_STRING(PyTuple_GET_ITEM(constants, i));
+            for (j = 0; j < size*BLOCK_SIZE1; j+=size) {
+                memcpy(smem + j, value, size);
+            }
+        }
+    }
+    /* This is no longer needed since no unusual item sizes appear
+       in temporaries (there are no string temporaries). */
+    PyMem_Del(itemsizes);
+
+    /* Fill in 'memsteps' and 'memsizes' for temps */
+    for (i = 0; i < n_temps; i++) {
+        char c = PyBytes_AS_STRING(tempsig)[i];
+        int size = size_from_char(c);
+        memsteps[i+n_inputs+n_constants+1] = size;
+        memsizes[i+n_inputs+n_constants+1] = size;
+    }
+    /* See if any errors occured (e.g., in size_from_char) or if mem_offset is wrong */
+    if (PyErr_Occurred() || mem_offset != rawmemsize) {
+        if (mem_offset != rawmemsize) {
+            PyErr_Format(PyExc_RuntimeError, "mem_offset does not match rawmemsize");
+        }
+        Py_DECREF(constants);
+        Py_DECREF(constsig);
+        Py_DECREF(fullsig);
+        PyMem_Del(mem);
+        PyMem_Del(rawmem);
+        PyMem_Del(memsteps);
+        PyMem_Del(memsizes);
+        return -1;
+    }
+
+
+    #define REPLACE_OBJ(arg) \
+    {PyObject *tmp = self->arg; \
+     self->arg = arg; \
+     Py_XDECREF(tmp);}
+    #define INCREF_REPLACE_OBJ(arg) {Py_INCREF(arg); REPLACE_OBJ(arg);}
+    #define REPLACE_MEM(arg) {PyMem_Del(self->arg); self->arg=arg;}
+
+    INCREF_REPLACE_OBJ(signature);
+    INCREF_REPLACE_OBJ(tempsig);
+    REPLACE_OBJ(constsig);
+    REPLACE_OBJ(fullsig);
+    INCREF_REPLACE_OBJ(program);
+    REPLACE_OBJ(constants);
+    INCREF_REPLACE_OBJ(input_names);
+    REPLACE_MEM(mem);
+    REPLACE_MEM(rawmem);
+    REPLACE_MEM(memsteps);
+    REPLACE_MEM(memsizes);
+    self->rawmemsize = rawmemsize;
+    self->n_inputs = n_inputs;
+    self->n_constants = n_constants;
+    self->n_temps = n_temps;
+
+    #undef REPLACE_OBJ
+    #undef INCREF_REPLACE_OBJ
+    #undef REPLACE_MEM
+
+    return check_program(self);
+}
+
+static PyMethodDef NumExpr_methods[] = {
+    {"run", (PyCFunction) NumExpr_run, METH_VARARGS|METH_KEYWORDS, NULL},
+    {NULL, NULL}
+};
+
+static PyMemberDef NumExpr_members[] = {
+    {CHARP("signature"), T_OBJECT_EX, offsetof(NumExprObject, signature), READONLY, NULL},
+    {CHARP("constsig"), T_OBJECT_EX, offsetof(NumExprObject, constsig), READONLY, NULL},
+    {CHARP("tempsig"), T_OBJECT_EX, offsetof(NumExprObject, tempsig), READONLY, NULL},
+    {CHARP("fullsig"), T_OBJECT_EX, offsetof(NumExprObject, fullsig), READONLY, NULL},
+
+    {CHARP("program"), T_OBJECT_EX, offsetof(NumExprObject, program), READONLY, NULL},
+    {CHARP("constants"), T_OBJECT_EX, offsetof(NumExprObject, constants),
+     READONLY, NULL},
+    {CHARP("input_names"), T_OBJECT, offsetof(NumExprObject, input_names), 0, NULL},
+    {NULL},
+};
+
+PyTypeObject NumExprType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "numexpr.NumExpr",         /*tp_name*/
+    sizeof(NumExprObject),     /*tp_basicsize*/
+    0,                         /*tp_itemsize*/
+    (destructor)NumExpr_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 */
+    (ternaryfunc)NumExpr_run,  /*tp_call*/
+    0,                         /*tp_str*/
+    0,                         /*tp_getattro*/
+    0,                         /*tp_setattro*/
+    0,                         /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+    "NumExpr objects",         /* tp_doc */
+    0,                       /* tp_traverse */
+    0,                       /* tp_clear */
+    0,                       /* tp_richcompare */
+    0,                       /* tp_weaklistoffset */
+    0,                       /* tp_iter */
+    0,                       /* tp_iternext */
+    NumExpr_methods,           /* tp_methods */
+    NumExpr_members,           /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    (initproc)NumExpr_init,    /* tp_init */
+    0,                         /* tp_alloc */
+    NumExpr_new,               /* tp_new */
+};
+

numexpr/numexpr_object.hpp

@@ -0,0 +1,34 @@
+#ifndef NUMEXPR_OBJECT_HPP
+#define NUMEXPR_OBJECT_HPP
+/*********************************************************************
+  Numexpr - Fast numerical array expression evaluator for NumPy.
+
+      License: MIT
+      Author:  See AUTHORS.txt
+
+  See LICENSE.txt for details about copyright and rights to use.
+**********************************************************************/
+
+struct NumExprObject
+{
+    PyObject_HEAD
+    PyObject *signature;    /* a python string */
+    PyObject *tempsig;
+    PyObject *constsig;
+    PyObject *fullsig;
+    PyObject *program;      /* a python string */
+    PyObject *constants;    /* a tuple of int/float/complex */
+    PyObject *input_names;  /* tuple of strings */
+    char **mem;             /* pointers to registers */
+    char *rawmem;           /* a chunks of raw memory for storing registers */
+    npy_intp *memsteps;
+    npy_intp *memsizes;
+    int  rawmemsize;
+    int  n_inputs;
+    int  n_constants;
+    int  n_temps;
+};
+
+extern PyTypeObject NumExprType;
+
+#endif // NUMEXPR_OBJECT_HPP

numexpr/opcodes.hpp

@@ -0,0 +1,179 @@
+/*********************************************************************
+  Numexpr - Fast numerical array expression evaluator for NumPy.
+
+      License: MIT
+      Author:  See AUTHORS.txt
+
+  See LICENSE.txt for details about copyright and rights to use.
+**********************************************************************/
+
+/*
+OPCODE(n, enum_name, exported, return_type, arg1_type, arg2_type, arg3_type)
+
+`exported` is NULL if the opcode shouldn't exported by the Python module.
+
+Types are Tb, Ti, Tl, Tf, Td, Tc, Ts, Tn, and T0; these symbols should be
+#defined to whatever is needed. (T0 is the no-such-arg type.)
+
+*/
+OPCODE(0, OP_NOOP, "noop", T0, T0, T0, T0)
+
+OPCODE(1, OP_COPY_BB, "copy_bb", Tb, Tb, T0, T0)
+
+OPCODE(2, OP_INVERT_BB, "invert_bb", Tb, Tb, T0, T0)
+OPCODE(3, OP_AND_BBB, "and_bbb", Tb, Tb, Tb, T0)
+OPCODE(4, OP_OR_BBB, "or_bbb", Tb, Tb, Tb, T0)
+
+OPCODE(5, OP_EQ_BBB, "eq_bbb", Tb, Tb, Tb, T0)
+OPCODE(6, OP_NE_BBB, "ne_bbb", Tb, Tb, Tb, T0)
+
+OPCODE(7, OP_GT_BII, "gt_bii", Tb, Ti, Ti, T0)
+OPCODE(8, OP_GE_BII, "ge_bii", Tb, Ti, Ti, T0)
+OPCODE(9, OP_EQ_BII, "eq_bii", Tb, Ti, Ti, T0)
+OPCODE(10, OP_NE_BII, "ne_bii", Tb, Ti, Ti, T0)
+
+OPCODE(11, OP_GT_BLL, "gt_bll", Tb, Tl, Tl, T0)
+OPCODE(12, OP_GE_BLL, "ge_bll", Tb, Tl, Tl, T0)
+OPCODE(13, OP_EQ_BLL, "eq_bll", Tb, Tl, Tl, T0)
+OPCODE(14, OP_NE_BLL, "ne_bll", Tb, Tl, Tl, T0)
+
+OPCODE(15, OP_GT_BFF, "gt_bff", Tb, Tf, Tf, T0)
+OPCODE(16, OP_GE_BFF, "ge_bff", Tb, Tf, Tf, T0)
+OPCODE(17, OP_EQ_BFF, "eq_bff", Tb, Tf, Tf, T0)
+OPCODE(18, OP_NE_BFF, "ne_bff", Tb, Tf, Tf, T0)
+
+OPCODE(19, OP_GT_BDD, "gt_bdd", Tb, Td, Td, T0)
+OPCODE(20, OP_GE_BDD, "ge_bdd", Tb, Td, Td, T0)
+OPCODE(21, OP_EQ_BDD, "eq_bdd", Tb, Td, Td, T0)
+OPCODE(22, OP_NE_BDD, "ne_bdd", Tb, Td, Td, T0)
+
+OPCODE(23, OP_GT_BSS, "gt_bss", Tb, Ts, Ts, T0)
+OPCODE(24, OP_GE_BSS, "ge_bss", Tb, Ts, Ts, T0)
+OPCODE(25, OP_EQ_BSS, "eq_bss", Tb, Ts, Ts, T0)
+OPCODE(26, OP_NE_BSS, "ne_bss", Tb, Ts, Ts, T0)
+
+OPCODE(27, OP_CAST_IB, "cast_ib", Ti, Tb, T0, T0)
+OPCODE(28, OP_COPY_II, "copy_ii", Ti, Ti, T0, T0)
+OPCODE(29, OP_ONES_LIKE_II, "ones_like_ii", Ti, T0, T0, T0)
+OPCODE(30, OP_NEG_II, "neg_ii", Ti, Ti, T0, T0)
+OPCODE(31, OP_ADD_III, "add_iii", Ti, Ti, Ti, T0)
+OPCODE(32, OP_SUB_III, "sub_iii", Ti, Ti, Ti, T0)
+OPCODE(33, OP_MUL_III, "mul_iii", Ti, Ti, Ti, T0)
+OPCODE(34, OP_DIV_III, "div_iii", Ti, Ti, Ti, T0)
+OPCODE(35, OP_POW_III, "pow_iii", Ti, Ti, Ti, T0)
+OPCODE(36, OP_MOD_III, "mod_iii", Ti, Ti, Ti, T0)
+
+OPCODE(37, OP_LSHIFT_III, "lshift_iii", Ti, Ti, Ti, T0)
+OPCODE(38, OP_RSHIFT_III, "rshift_iii", Ti, Ti, Ti, T0)
+
+OPCODE(39, OP_WHERE_IBII, "where_ibii", Ti, Tb, Ti, Ti)
+
+OPCODE(40, OP_CAST_LI, "cast_li", Tl, Ti, T0, T0)
+OPCODE(41, OP_COPY_LL, "copy_ll", Tl, Tl, T0, T0)
+OPCODE(42, OP_ONES_LIKE_LL, "ones_like_ll", Tl, T0, T0, T0)
+OPCODE(43, OP_NEG_LL, "neg_ll", Tl, Tl, T0, T0)
+OPCODE(44, OP_ADD_LLL, "add_lll", Tl, Tl, Tl, T0)
+OPCODE(45, OP_SUB_LLL, "sub_lll", Tl, Tl, Tl, T0)
+OPCODE(46, OP_MUL_LLL, "mul_lll", Tl, Tl, Tl, T0)
+OPCODE(47, OP_DIV_LLL, "div_lll", Tl, Tl, Tl, T0)
+OPCODE(48, OP_POW_LLL, "pow_lll", Tl, Tl, Tl, T0)
+OPCODE(49, OP_MOD_LLL, "mod_lll", Tl, Tl, Tl, T0)
+
+OPCODE(50, OP_LSHIFT_LLL, "lshift_lll", Tl, Tl, Tl, T0)
+OPCODE(51, OP_RSHIFT_LLL, "rshift_lll", Tl, Tl, Tl, T0)
+
+OPCODE(52, OP_WHERE_LBLL, "where_lbll", Tl, Tb, Tl, Tl)
+
+OPCODE(53, OP_CAST_FI, "cast_fi", Tf, Ti, T0, T0)
+OPCODE(54, OP_CAST_FL, "cast_fl", Tf, Tl, T0, T0)
+OPCODE(55, OP_COPY_FF, "copy_ff", Tf, Tf, T0, T0)
+OPCODE(56, OP_ONES_LIKE_FF, "ones_like_ff", Tf, T0, T0, T0)
+OPCODE(57, OP_NEG_FF, "neg_ff", Tf, Tf, T0, T0)
+OPCODE(58, OP_ADD_FFF, "add_fff", Tf, Tf, Tf, T0)
+OPCODE(59, OP_SUB_FFF, "sub_fff", Tf, Tf, Tf, T0)
+OPCODE(60, OP_MUL_FFF, "mul_fff", Tf, Tf, Tf, T0)
+OPCODE(61, OP_DIV_FFF, "div_fff", Tf, Tf, Tf, T0)
+OPCODE(62, OP_POW_FFF, "pow_fff", Tf, Tf, Tf, T0)
+OPCODE(63, OP_MOD_FFF, "mod_fff", Tf, Tf, Tf, T0)
+OPCODE(64, OP_SQRT_FF, "sqrt_ff", Tf, Tf, T0, T0)
+OPCODE(65, OP_WHERE_FBFF, "where_fbff", Tf, Tb, Tf, Tf)
+OPCODE(66, OP_FUNC_FFN, "func_ffn", Tf, Tf, Tn, T0)
+OPCODE(67, OP_FUNC_FFFN, "func_fffn", Tf, Tf, Tf, Tn)
+
+OPCODE(68, OP_CAST_DI, "cast_di", Td, Ti, T0, T0)
+OPCODE(69, OP_CAST_DL, "cast_dl", Td, Tl, T0, T0)
+OPCODE(70, OP_CAST_DF, "cast_df", Td, Tf, T0, T0)
+OPCODE(71, OP_COPY_DD, "copy_dd", Td, Td, T0, T0)
+OPCODE(72, OP_ONES_LIKE_DD, "ones_like_dd", Td, T0, T0, T0)
+OPCODE(73, OP_NEG_DD, "neg_dd", Td, Td, T0, T0)
+OPCODE(74, OP_ADD_DDD, "add_ddd", Td, Td, Td, T0)
+OPCODE(75, OP_SUB_DDD, "sub_ddd", Td, Td, Td, T0)
+OPCODE(76, OP_MUL_DDD, "mul_ddd", Td, Td, Td, T0)
+OPCODE(77, OP_DIV_DDD, "div_ddd", Td, Td, Td, T0)
+OPCODE(78, OP_POW_DDD, "pow_ddd", Td, Td, Td, T0)
+OPCODE(79, OP_MOD_DDD, "mod_ddd", Td, Td, Td, T0)
+OPCODE(80, OP_SQRT_DD, "sqrt_dd", Td, Td, T0, T0)
+OPCODE(81, OP_WHERE_DBDD, "where_dbdd", Td, Tb, Td, Td)
+OPCODE(82, OP_FUNC_DDN, "func_ddn", Td, Td, Tn, T0)
+OPCODE(83, OP_FUNC_DDDN, "func_dddn", Td, Td, Td, Tn)
+
+OPCODE(84, OP_EQ_BCC, "eq_bcc", Tb, Tc, Tc, T0)
+OPCODE(85, OP_NE_BCC, "ne_bcc", Tb, Tc, Tc, T0)
+
+OPCODE(86, OP_CAST_CI, "cast_ci", Tc, Ti, T0, T0)
+OPCODE(87, OP_CAST_CL, "cast_cl", Tc, Tl, T0, T0)
+OPCODE(88, OP_CAST_CF, "cast_cf", Tc, Tf, T0, T0)
+OPCODE(89, OP_CAST_CD, "cast_cd", Tc, Td, T0, T0)
+OPCODE(90, OP_ONES_LIKE_CC, "ones_like_cc", Tc, T0, T0, T0)
+OPCODE(91, OP_COPY_CC, "copy_cc", Tc, Tc, T0, T0)
+OPCODE(92, OP_NEG_CC, "neg_cc", Tc, Tc, T0, T0)
+OPCODE(93, OP_ADD_CCC, "add_ccc", Tc, Tc, Tc, T0)
+OPCODE(94, OP_SUB_CCC, "sub_ccc", Tc, Tc, Tc, T0)
+OPCODE(95, OP_MUL_CCC, "mul_ccc", Tc, Tc, Tc, T0)
+OPCODE(96, OP_DIV_CCC, "div_ccc", Tc, Tc, Tc, T0)
+OPCODE(97, OP_WHERE_CBCC, "where_cbcc", Tc, Tb, Tc, Tc)
+OPCODE(98, OP_FUNC_CCN, "func_ccn", Tc, Tc, Tn, T0)
+OPCODE(99, OP_FUNC_CCCN, "func_cccn", Tc, Tc, Tc, Tn)
+
+OPCODE(100, OP_REAL_DC, "real_dc", Td, Tc, T0, T0)
+OPCODE(101, OP_IMAG_DC, "imag_dc", Td, Tc, T0, T0)
+OPCODE(102, OP_COMPLEX_CDD, "complex_cdd", Tc, Td, Td, T0)
+
+OPCODE(103, OP_COPY_SS, "copy_ss", Ts, Ts, T0, T0)
+
+OPCODE(104, OP_WHERE_BBBB, "where_bbbb", Tb, Tb, Tb, Tb)
+
+OPCODE(105, OP_CONTAINS_BSS, "contains_bss", Tb, Ts, Ts, T0)
+
+OPCODE(106, OP_REDUCTION, NULL, T0, T0, T0, T0)
+
+/* Last argument in a reduction is the axis of the array the
+   reduction should be applied along. */
+
+OPCODE(107, OP_SUM_IIN, "sum_iin", Ti, Ti, Tn, T0)
+OPCODE(108, OP_SUM_LLN, "sum_lln", Tl, Tl, Tn, T0)
+OPCODE(109, OP_SUM_FFN, "sum_ffn", Tf, Tf, Tn, T0)
+OPCODE(110, OP_SUM_DDN, "sum_ddn", Td, Td, Tn, T0)
+OPCODE(111, OP_SUM_CCN, "sum_ccn", Tc, Tc, Tn, T0)
+
+OPCODE(112, OP_PROD, NULL, T0, T0, T0, T0)
+OPCODE(113, OP_PROD_IIN, "prod_iin", Ti, Ti, Tn, T0)
+OPCODE(114, OP_PROD_LLN, "prod_lln", Tl, Tl, Tn, T0)
+OPCODE(115, OP_PROD_FFN, "prod_ffn", Tf, Tf, Tn, T0)
+OPCODE(116, OP_PROD_DDN, "prod_ddn", Td, Td, Tn, T0)
+OPCODE(117, OP_PROD_CCN, "prod_ccn", Tc, Tc, Tn, T0)
+
+OPCODE(118, OP_MIN, NULL, T0, T0, T0, T0)
+OPCODE(119, OP_MIN_IIN, "min_iin", Ti, Ti, Tn, T0)
+OPCODE(120, OP_MIN_LLN, "min_lln", Tl, Tl, Tn, T0)
+OPCODE(121, OP_MIN_FFN, "min_ffn", Tf, Tf, Tn, T0)
+OPCODE(122, OP_MIN_DDN, "min_ddn", Td, Td, Tn, T0)
+
+OPCODE(123, OP_MAX, NULL, T0, T0, T0, T0)
+OPCODE(124, OP_MAX_IIN, "max_iin", Ti, Ti, Tn, T0)
+OPCODE(125, OP_MAX_LLN, "max_lln", Tl, Tl, Tn, T0)
+OPCODE(126, OP_MAX_FFN, "max_ffn", Tf, Tf, Tn, T0)
+OPCODE(127, OP_MAX_DDN, "max_ddn", Td, Td, Tn, T0)
+
+/* Should be the last opcode */
+OPCODE(128, OP_END, NULL, T0, T0, T0, T0)