gumath 0.2.0dev5 → 0.2.0dev8

data/ext/ruby_gumath/gumath/python/gumath/cuda.c

@@ -0,0 +1,78 @@
+#include <Python.h>
+#include "ndtypes.h"
+#include "pyndtypes.h"
+#include "gumath.h"
+#include "pygumath.h"
+
+
+/****************************************************************************/
+/*                              Module globals                              */
+/****************************************************************************/
+
+/* Function table */
+static gm_tbl_t *table = NULL;
+
+
+/****************************************************************************/
+/*                                  Module                                  */
+/****************************************************************************/
+
+static struct PyModuleDef cuda_module = {
+    PyModuleDef_HEAD_INIT,        /* m_base */
+    "cuda",                       /* m_name */
+    NULL,                         /* m_doc */
+    -1,                           /* m_size */
+    NULL,                         /* m_methods */
+    NULL,                         /* m_slots */
+    NULL,                         /* m_traverse */
+    NULL,                         /* m_clear */
+    NULL                          /* m_free */
+};
+
+
+PyMODINIT_FUNC
+PyInit_cuda(void)
+{
+    NDT_STATIC_CONTEXT(ctx);
+    PyObject *m = NULL;
+    static int initialized = 0;
+
+    if (!initialized) {
+       if (import_ndtypes() < 0) {
+            return NULL;
+       }
+       if (import_gumath() < 0) {
+            return NULL;
+       }
+
+       table = gm_tbl_new(&ctx);
+       if (table == NULL) {
+           return Ndt_SetError(&ctx);
+       }
+
+       if (gm_init_cuda_unary_kernels(table, &ctx) < 0) {
+           return Ndt_SetError(&ctx);
+       }
+
+       if (gm_init_cuda_binary_kernels(table, &ctx) < 0) {
+           return Ndt_SetError(&ctx);
+       }
+
+       initialized = 1;
+    }
+
+    m = PyModule_Create(&cuda_module);
+    if (m == NULL) {
+        goto error;
+    }
+
+    if (Gumath_AddCudaFunctions(m, table) < 0) {
+        goto error;
+    }
+
+    return m;
+
+error:
+    Py_CLEAR(m);
+    return NULL;
+}

data/ext/ruby_gumath/gumath/python/gumath/examples.c

@@ -56,11 +56,6 @@ PyInit_examples(void)
        }
 
        /* extending examples */
-#ifndef _MSC_VER
-       if (gm_init_bfloat16_kernels(table, &ctx) < 0) {
-           return Ndt_SetError(&ctx);
-       }
-#endif
        if (gm_init_graph_kernels(table, &ctx) < 0) {
            return Ndt_SetError(&ctx);
        }

data/ext/ruby_gumath/gumath/python/gumath/functions.c

@@ -50,10 +50,10 @@ PyInit_functions(void)
            return Ndt_SetError(&ctx);
        }
 
-       if (gm_init_unary_kernels(table, &ctx) < 0) {
+       if (gm_init_cpu_unary_kernels(table, &ctx) < 0) {
            return Ndt_SetError(&ctx);
        }
-       if (gm_init_binary_kernels(table, &ctx) < 0) {
+       if (gm_init_cpu_binary_kernels(table, &ctx) < 0) {
            return Ndt_SetError(&ctx);
        }
 

data/ext/ruby_gumath/gumath/python/gumath/gumath.h

@@ -0,0 +1,246 @@
+/*
+* BSD 3-Clause License
+*
+* Copyright (c) 2017-2018, plures
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice,
+*    this list of conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+*
+* 3. Neither the name of the copyright holder nor the names of its
+*    contributors may be used to endorse or promote products derived from
+*    this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#ifndef GUMATH_H
+#define GUMATH_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+  #include <cstdint>
+#else
+  #include <stdint.h>
+#endif
+
+#include "ndtypes.h"
+#include "xnd.h"
+
+
+#ifdef _MSC_VER
+  #if defined (GM_EXPORT)
+    #define GM_API __declspec(dllexport)
+  #elif defined(GM_IMPORT)
+    #define GM_API __declspec(dllimport)
+  #else
+    #define GM_API
+  #endif
+
+  #ifndef GM_UNUSED
+    #define GM_UNUSED
+  #endif
+
+  #include "malloc.h"
+  #define ALLOCA(type, name, nmemb) type *name = _alloca(nmemb * sizeof(type))
+#else
+  #define GM_API
+  #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+    #define GM_UNUSED __attribute__((unused))
+  #else
+    #define GM_UNUSED
+  #endif
+
+  #define ALLOCA(type, name, nmemb) type name[nmemb]
+#endif
+
+
+#define GM_MAX_KERNELS 8192
+#define GM_THREAD_CUTOFF 1000000
+
+typedef float float32_t;
+typedef double float64_t;
+
+
+typedef int (* gm_xnd_kernel_t)(xnd_t stack[], ndt_context_t *ctx);
+typedef int (* gm_strided_kernel_t)(char **args, intptr_t *dimensions, intptr_t *steps, void *data);
+
+/*
+ * Collection of specialized kernels for a single function signature.
+ *
+ * NOTE: The specialized kernel lookup scheme is transitional and may
+ * be replaced by something else.
+ *
+ * This should be considered as a first version of a kernel request
+ * protocol.
+ */
+typedef struct {
+    const ndt_t *sig;
+    const ndt_constraint_t *constraint;
+
+    /* Xnd signatures */
+    gm_xnd_kernel_t OptC;    /* C in inner+1 dimensions */
+    gm_xnd_kernel_t OptZ;    /* C in inner dimensions, C or zero stride in (inner+1)th. */
+    gm_xnd_kernel_t OptS;    /* strided in (inner+1)th. */
+    gm_xnd_kernel_t C;       /* C in inner dimensions */
+    gm_xnd_kernel_t Fortran; /* Fortran in inner dimensions */
+    gm_xnd_kernel_t Xnd;     /* selected if non-contiguous or the other fields are NULL */
+
+    /* NumPy signature */
+    gm_strided_kernel_t Strided;
+} gm_kernel_set_t;
+
+typedef struct {
+    const char *name;
+    const char *type;
+    const ndt_methods_t *meth;
+} gm_typedef_init_t;
+
+typedef struct {
+    const char *name;
+    const char *sig;
+    const ndt_constraint_t *constraint;
+    uint32_t cap;
+
+    /* Xnd signatures */
+    gm_xnd_kernel_t OptC;
+    gm_xnd_kernel_t OptZ;
+    gm_xnd_kernel_t OptS;
+    gm_xnd_kernel_t C;
+    gm_xnd_kernel_t Fortran;
+    gm_xnd_kernel_t Xnd;
+
+    /* NumPy signature */
+    gm_strided_kernel_t Strided;
+} gm_kernel_init_t;
+
+/* Actual kernel selected for application */
+typedef struct {
+    uint32_t flag;
+    const gm_kernel_set_t *set;
+} gm_kernel_t;
+
+/* Multimethod with associated kernels */
+typedef struct gm_func gm_func_t;
+typedef const gm_kernel_set_t *(*gm_typecheck_t)(ndt_apply_spec_t *spec, const gm_func_t *f,
+                                                 const ndt_t *in[], const int64_t li[],
+                                                 int nin, int nout, bool check_broadcast,
+                                                 ndt_context_t *ctx);
+struct gm_func {
+    char *name;
+    gm_typecheck_t typecheck; /* Experimental optimized type-checking, may be NULL. */
+    int nkernels;
+    gm_kernel_set_t kernels[GM_MAX_KERNELS];
+};
+
+
+typedef struct _gm_tbl gm_tbl_t;
+
+
+/******************************************************************************/
+/*                                  Functions                                 */
+/******************************************************************************/
+
+GM_API gm_func_t *gm_func_new(const char *name, ndt_context_t *ctx);
+GM_API void gm_func_del(gm_func_t *f);
+
+GM_API gm_func_t *gm_add_func(gm_tbl_t *tbl, const char *name, ndt_context_t *ctx);
+GM_API int gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *kernel, ndt_context_t *ctx);
+GM_API int gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *kernel, ndt_context_t *ctx, gm_typecheck_t f);
+
+GM_API gm_kernel_t gm_select(ndt_apply_spec_t *spec, const gm_tbl_t *tbl, const char *name,
+                             const ndt_t *types[], const int64_t li[], int nin, int nout,
+                             bool check_broadcast, const xnd_t args[], ndt_context_t *ctx);
+GM_API int gm_apply(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims, ndt_context_t *ctx);
+GM_API int gm_apply_thread(const gm_kernel_t *kernel, xnd_t stack[], int outer_dims, const int64_t nthreads, ndt_context_t *ctx);
+
+
+/******************************************************************************/
+/*                                NumPy loops                                 */
+/******************************************************************************/
+
+GM_API int gm_np_flatten(char **args, const int nargs,
+                         int64_t *dimensions, int64_t *strides, const xnd_t stack[],
+                         ndt_context_t *ctx);
+
+GM_API int gm_np_convert_xnd(char **args, const int nargs,
+                             intptr_t *dimensions, const int dims_size,
+                             intptr_t *steps, const int steps_size,
+                             xnd_t stack[], const int outer_dims,
+                             ndt_context_t *ctx);
+
+GM_API int gm_np_map(const gm_strided_kernel_t f,
+                     char **args, int nargs,
+                     intptr_t *dimensions,
+                     intptr_t *steps,
+                     void *data,
+                     int outer_dims);
+
+
+/******************************************************************************/
+/*                                  Xnd loops                                 */
+/******************************************************************************/
+
+GM_API int array_shape_check(xnd_t *x, const int64_t shape, ndt_context_t *ctx);
+GM_API int gm_xnd_map(const gm_xnd_kernel_t f, xnd_t stack[], const int nargs,
+                      const int outer_dims, ndt_context_t *ctx);
+
+
+/******************************************************************************/
+/*                                Gufunc table                                */
+/******************************************************************************/
+GM_API gm_tbl_t *gm_tbl_new(ndt_context_t *ctx);
+GM_API void gm_tbl_del(gm_tbl_t *t);
+
+GM_API int gm_tbl_add(gm_tbl_t *tbl, const char *key, gm_func_t *value, ndt_context_t *ctx);
+GM_API gm_func_t *gm_tbl_find(const gm_tbl_t *tbl, const char *key, ndt_context_t *ctx);
+GM_API int gm_tbl_map(const gm_tbl_t *tbl, int (*f)(const gm_func_t *, void *state), void *state);
+
+
+/******************************************************************************/
+/*                       Library initialization and tables                    */
+/******************************************************************************/
+
+GM_API void gm_init(void);
+GM_API int gm_init_cpu_unary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_cpu_binary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_bitwise_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+
+GM_API int gm_init_cuda_unary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_cuda_binary_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+
+GM_API int gm_init_example_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_graph_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_quaternion_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+GM_API int gm_init_pdist_kernels(gm_tbl_t *tbl, ndt_context_t *ctx);
+
+GM_API void gm_finalize(void);
+
+
+#ifdef __cplusplus
+} /* END extern "C" */
+#endif
+
+
+#endif /* GUMATH_H */

data/ext/ruby_gumath/gumath/python/gumath/libgumath.so

@@ -0,0 +1 @@
+ext/ruby_gumath/gumath/python/gumath/libgumath.so.0.2.0dev3

data/ext/ruby_gumath/gumath/python/gumath/libgumath.so.0

@@ -0,0 +1 @@
+ext/ruby_gumath/gumath/python/gumath/libgumath.so.0.2.0dev3

data/ext/ruby_gumath/gumath/python/gumath/pygumath.h

@@ -49,10 +49,15 @@ extern "C" {
 /* Exposed here for the benefit of Numba. The API should not be regarded
    stable across versions. */
 
+#define GM_CPU_FUNC  0x0001U
+#define GM_CUDA_MANAGED_FUNC 0x0002U
+
 typedef struct {
     PyObject_HEAD
     const gm_tbl_t *tbl; /* kernel table */
+    uint32_t flags;      /* memory target */
     char *name;          /* function name */
+    PyObject *identity;  /* identity element */
 } GufuncObject;
 
 
@@ -60,21 +65,45 @@ typedef struct {
 /*                                Capsule API                               */
 /****************************************************************************/
 
-#define Gumath_AddFunctions_INDEX 0
+#define Gufunc_CheckExact_INDEX 0
+#define Gufunc_CheckExact_RETURN int
+#define Gufunc_CheckExact_ARGS (const PyObject *)
+
+#define Gufunc_Check_INDEX 1
+#define Gufunc_Check_RETURN int
+#define Gufunc_Check_ARGS (const PyObject *)
+
+#define Gumath_AddFunctions_INDEX 2
 #define Gumath_AddFunctions_RETURN int
 #define Gumath_AddFunctions_ARGS (PyObject *, const gm_tbl_t *)
 
-#define GUMATH_MAX_API 1
+#define Gumath_AddCudaFunctions_INDEX 3
+#define Gumath_AddCudaFunctions_RETURN int
+#define Gumath_AddCudaFunctions_ARGS (PyObject *, const gm_tbl_t *)
+
+#define GUMATH_MAX_API 4
 
 
 #ifdef GUMATH_MODULE
+static Gufunc_CheckExact_RETURN Gufunc_CheckExact Gufunc_CheckExact_ARGS;
+static Gufunc_Check_RETURN Gufunc_Check Gufunc_Check_ARGS;
 static Gumath_AddFunctions_RETURN Gumath_AddFunctions Gumath_AddFunctions_ARGS;
+static Gumath_AddCudaFunctions_RETURN Gumath_AddCudaFunctions Gumath_AddCudaFunctions_ARGS;
 #else
 static void **_gumath_api;
 
+#define Gufunc_CheckExact \
+    (*(Gufunc_CheckExact_RETURN (*)Gufunc_CheckExact_ARGS) _gumath_api[Gufunc_CheckExact_INDEX])
+
+#define Gufunc_Check \
+    (*(Gufunc_Check_RETURN (*)Gufunc_Check_ARGS) _gumath_api[Gufunc_Check_INDEX])
+
 #define Gumath_AddFunctions \
     (*(Gumath_AddFunctions_RETURN (*)Gumath_AddFunctions_ARGS) _gumath_api[Gumath_AddFunctions_INDEX])
 
+#define Gumath_AddCudaFunctions \
+    (*(Gumath_AddCudaFunctions_RETURN (*)Gumath_AddCudaFunctions_ARGS) _gumath_api[Gumath_AddCudaFunctions_INDEX])
+
 
 static int
 import_gumath(void)

data/ext/ruby_gumath/gumath/python/gumath_aux.py

@@ -0,0 +1,767 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2017-2018, plures
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# Python NDarray and functions for generating test cases.
+
+from itertools import accumulate, count, product
+from random import randrange, sample
+from collections import namedtuple
+import math
+import struct
+import unittest
+from randdec import all_unary, all_binary
+from randfloat import un_randfloat, bin_randfloat
+import numpy as np
+
+
+def skip_if(condition, reason):
+    if condition:
+        raise unittest.SkipTest(reason)
+
+
+# ======================================================================
+#                          Minimal test cases
+# ======================================================================
+
+TEST_CASES = [
+  ([float(i)/100.0 for i in range(2000)], "2000 * float64", "float64"),
+
+  ([[float(i)/100.0 for i in range(1000)], [float(i+1) for i in range(1000)]],
+   "2 * 1000 * float64", "float64"),
+
+  (1000 * [[float(i+1) for i in range(2)]], "1000 * 2 * float64", "float64"),
+
+  ([float(i)/10.0 for i in range(2000)], "2000 * float32", "float32"),
+
+  ([[float(i)/10.0 for i in range(1000)], [float(i+1) for i in range(1000)]],
+  "2 * 1000 * float32", "float32"),
+
+  (1000 * [[float(i+1) for i in range(2)]], "1000 * 2 * float32", "float32"),
+]
+
+
+# ======================================================================
+#            Definition of generalized slicing and indexing
+# ======================================================================
+
+def have_none(lst):
+    if isinstance(lst, (list, tuple)):
+        return any(have_none(item) for item in lst)
+    if isinstance(lst, dict):
+        return any(have_none(item) for item in lst.values())
+    return lst is None
+
+def sinrec(lst):
+    if isinstance(lst, list):
+        return [sinrec(item) for item in lst]
+    elif isinstance(lst, (int, type(None))):
+        return None if lst is None else math.sin(lst)
+    else:
+        raise TypeError("unexpected operand type '%s'" % type(lst))
+
+def mulrec(lst1, lst2):
+    if isinstance(lst1, list) and isinstance(lst2, list):
+        return [mulrec(*pair) for pair in zip(lst1, lst2)]
+    elif isinstance(lst1, (int, type(None))) and isinstance(lst2, (int, type(None))):
+        return None if lst1 is None or lst2 is None else lst1 * lst2
+    else:
+        raise TypeError("unexpected operand types '%s', '%s'" %
+                        (type(lst1), type(lst2)))
+
+
+def maxlevel(lst):
+    """Return maximum nesting depth"""
+    maxlev = 0
+    def f(lst, level):
+        nonlocal maxlev
+        if isinstance(lst, list):
+            level += 1
+            maxlev = max(level, maxlev)
+            for item in lst:
+                f(item, level)
+    f(lst, 0)
+    return maxlev
+
+def getitem(lst, indices):
+    """Definition for multidimensional slicing and indexing on arbitrarily
+       shaped nested lists.
+    """
+    if not indices:
+        return lst
+
+    i, indices = indices[0], indices[1:]
+    item = list.__getitem__(lst, i)
+
+    if isinstance(i, int):
+        return getitem(item, indices)
+
+    # Empty slice: check if all subsequent indices are in range for the
+    # full slice, raise IndexError otherwise. This is NumPy's behavior.
+    if not item:
+        if lst:
+           _ = getitem(lst, (slice(None),) + indices)
+        elif any(isinstance(k, int) for k in indices):
+           raise IndexError
+        return []
+
+    return [getitem(x, indices) for x in item]
+
+class NDArray(list):
+    """A simple wrapper for using generalized slicing/indexing on a list."""
+    def __init__(self, value, dtype=None):
+        list.__init__(self, value)
+        self.maxlevel = maxlevel(value)
+
+    def __getitem__(self, indices):
+        if not isinstance(indices, tuple):
+            indices = (indices,)
+
+        if len(indices) > self.maxlevel: # NumPy
+            raise IndexError("too many indices")
+
+        if not all(isinstance(i, (int, slice)) for i in indices):
+            raise TypeError(
+                "index must be int or slice or a tuple of integers and slices")
+
+        result = getitem(self, indices)
+        return NDArray(result) if isinstance(result, list) else result
+
+    def sin(self):
+        return NDArray(sinrec(self))
+
+    def __mul__(self, other):
+        return NDArray(mulrec(self, other))
+
+
+
+# ======================================================================
+#                          Generate test cases 
+# ======================================================================
+
+SUBSCRIPT_FIXED_TEST_CASES = [
+  [],
+  [[]],
+  [[], []],
+  [[0], [1]],
+  [[0], [1], [2]],
+  [[0, 1], [1, 2], [2 ,3]],
+  [[[]]],
+  [[[0]]],
+  [[[], []]],
+  [[[0], [1]]],
+  [[[0, 1], [2, 3]]],
+  [[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
+  [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
+]
+
+SUBSCRIPT_VAR_TEST_CASES = [
+  [[[0, 1], [2, 3]], [[4, 5, 6], [7]], [[8, 9]]],
+  [[[0, 1], [2, 3]], [[4, 5, None], [None], [7]], [[], [None, 8]], [[9, 10]]],
+  [[[0, 1, 2], [3, 4, 5, 6], [7, 8, 9, 10]], [[11, 12, 13, 14], [15, 16, 17], [18, 19]]],
+  [[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9]], [[10, 11]]]
+]
+
+def single_fixed(max_ndim=4, min_shape=1, max_shape=10):
+    nat = count()
+    shape = [randrange(min_shape, max_shape+1) for _ in range(max_ndim)]
+
+    def f(ndim):
+        if ndim == 0:
+            return next(nat)
+        return [f(ndim-1) for _ in range(shape[ndim-1])]
+
+    return f(max_ndim)
+
+def gen_fixed(max_ndim=4, min_shape=1, max_shape=10):
+    assert max_ndim >=0 and min_shape >=0 and min_shape <= max_shape
+
+    for _ in range(30):
+        yield single_fixed(max_ndim, min_shape, max_shape)
+
+def single_var(max_ndim=4, min_shape=1, max_shape=10):
+    nat = count()
+
+    def f(ndim):
+        if ndim == 0:
+            return next(nat)
+        if ndim == 1:
+            shape = randrange(min_shape, max_shape+1)
+        else:
+            n = 1 if min_shape == 0 else min_shape
+            shape = randrange(n, max_shape+1)
+        return [f(ndim-1) for _ in range(shape)]
+
+    return f(max_ndim)
+
+def gen_var(max_ndim=4, min_shape=1, max_shape=10):
+    assert max_ndim >=0 and min_shape >=0 and min_shape <= max_shape
+
+    for _ in range(30):
+        yield single_var(max_ndim, min_shape, max_shape)
+
+
+def genindices():
+    for i in range(4):
+        yield (i,)
+    for i in range(4):
+        for j in range(4):
+            yield (i, j)
+    for i in range(4):
+        for j in range(4):
+            for k in range(4):
+                yield (i, j, k)
+
+def rslice(ndim):
+    start = randrange(0, ndim+1)
+    stop = randrange(0, ndim+1)
+    step = 0
+    while step == 0:
+        step = randrange(-ndim-1, ndim+1)
+    start = None if randrange(5) == 4 else start
+    stop = None if randrange(5) == 4 else stop
+    step = None if randrange(5) == 4 else step
+    return slice(start, stop, step)
+
+def rslice_neg(ndim):
+    start = randrange(-ndim-1, ndim+1)
+    stop = randrange(-ndim-1, ndim+1)
+    step = 0
+    while step == 0:
+        step = randrange(-ndim-1, ndim+1)
+    return slice(start, stop, step)
+
+def multislice(ndim):
+    return tuple(rslice(ndim) for _ in range(randrange(1, ndim+1)))
+
+def randslices(ndim):
+    for i in range(5):
+        yield multislice(ndim)
+
+def gen_indices_or_slices():
+    for i in range(5):
+        if randrange(2):
+            yield (randrange(4), randrange(4), randrange(4))
+        else:
+            yield multislice(3)
+
+def genslices(n):
+    """Generate all possible slices for a single dimension."""
+    def range_with_none():
+        yield None
+        yield from range(-n, n+1)
+
+    for t in product(range_with_none(), range_with_none(), range_with_none()):
+        s = slice(*t)
+        if s.step != 0:
+            yield s
+
+def genslices_ndim(ndim, shape):
+    """Generate all possible slice tuples for 'shape'."""
+    iterables = [genslices(shape[n]) for n in range(ndim)]
+    yield from product(*iterables)
+
+def mixed_index(max_ndim):
+    ndim = randrange(1, max_ndim+1)
+    indices = []
+    for i in range(1, ndim+1):
+        if randrange(2):
+            indices.append(randrange(-max_ndim, max_ndim))
+        else:
+            indices.append(rslice(ndim))
+    return tuple(indices)
+
+def mixed_index_neg(max_ndim):
+    ndim = randrange(1, max_ndim+1)
+    indices = []
+    for i in range(1, ndim+1):
+        if randrange(2):
+            indices.append(randrange(-max_ndim, max_ndim))
+        else:
+            indices.append(rslice_neg(ndim))
+    return tuple(indices)
+
+def mixed_indices(max_ndim):
+    for i in range(5):
+        yield mixed_index(max_ndim)
+    for i in range(5):
+        yield mixed_index_neg(max_ndim)
+
+def itos(indices):
+    return ", ".join(str(i) if isinstance(i, int) else "%s:%s:%s" %
+                     (i.start, i.stop, i.step) for i in indices)
+
+
+# ======================================================================
+#                Split a shape into N almost equal slices
+# ======================================================================
+
+def start(i, r, q):
+    return i*(q+1) if i < r else r+i*q
+
+def stop(i, r, q):
+    return (i+1)*(q+1) if i < r else r+(i+1)*q
+
+def step(i, r, q):
+    return q+1 if i < r else q
+
+def sl(i, r, q):
+    return slice(start(i, r, q), stop(i, r, q))
+
+def prepend(x, xs):
+    return [(x,) + t for t in xs]
+
+def last_column(i, r, q, n):
+    return [(sl(i, r, q),) for i in range(n)]
+
+def schedule(n, shape):
+    assert isinstance(n, int) and isinstance(shape, list)
+    if (n <= 0):
+        raise ValueError("n must be greater than zero")
+    if shape == []:
+        return [()]
+    m, ms = shape[0], shape[1:]
+    if (m <= 0):
+        raise ValueError("shape must be greater than zero")
+    if n <= m:
+        q, r = divmod(m, n)
+        return last_column(0, r, q, n)
+    else:
+        q, r = divmod(n, m)
+        return column(0, r, q, m, ms)
+
+def column(i, r, q, m, ms):
+    if i == m: return []
+    return prepend(slice(i, i+1),
+                   schedule(step(i, r, q), ms)) + \
+           column(i+1, r, q, m, ms)
+
+# ======================================================================
+#                   Split an xnd object into N subtrees
+# ======================================================================
+
+def zero_in_shape(shape):
+    for i in shape:
+        if i == 0:
+            return True
+    return False
+
+def split_xnd(x, n, max_outer=None):
+    shape = list(x.type.shape)
+    if zero_in_shape(shape):
+        raise ValueError("split does not support zeros in shape")
+    if max_outer is not None:
+        shape = shape[:max_outer]
+    indices_list = schedule(n, shape)
+    return [x[i] for i in indices_list]
+
+
+# ======================================================================
+#                           Generate test cases
+# ======================================================================
+
+functions = {
+  "unary": {
+    "default": ["copy", "abs"],
+    "arith": ["negative"],
+    "complex_math_with_half": ["exp", "log", "log10", "sqrt", "sin", "cos"],
+    "complex_math": ["tan", "asin", "acos", "atan", "sinh", "cosh", "tanh",
+                     "asinh", "acosh", "atanh"],
+    "real_math_with_half": ["fabs", "exp2", "log2"],
+    "real_math": ["expm1", "log1p", "logb", "cbrt", "erf", "erfc", "lgamma",
+                  "tgamma", "ceil", "floor", "trunc", "round", "nearbyint"],
+    "bitwise": ["invert"],
+  },
+  "binary": {
+    "default": ["add", "subtract", "multiply", "floor_divide", "remainder", "power"],
+    "float_result": ["divide"],
+    "bool_result": ["less_equal", "less", "greater_equal", "greater", "equal", "not_equal"],
+    "bitwise": ["bitwise_and", "bitwise_or", "bitwise_xor"]
+  },
+  "binary_mv": {
+    "default": ["divmod"],
+  }
+}
+
+def complex_noimpl(name):
+    return name in functions["unary"]["real_math"] or \
+           name in functions["unary"]["real_math_with_half"]
+
+def half_noimpl(name):
+    return name in functions["unary"]["real_math"] or \
+           name in functions["unary"]["complex_math"] or \
+           name in ("floor_divide", "remainder")
+
+tunsigned = ["bool", "uint8", "uint16", "uint32", "uint64"]
+tsigned = ["int8", "int16", "int32", "int64"]
+tfloat = ["bfloat16", "float16", "float32", "float64"]
+tcomplex = ["complex32", "complex64", "complex128"]
+
+tinfo = {
+  "bool": (0, 1, 0),
+  "uint8": (0, 2**8-1, 0),
+  "uint16": (0, 2**16-1, 0),
+  "uint32": (0, 2**32-1, 0),
+  "uint64": (0, 2**64-1, 0),
+  "int8": (-2**7,  2**7-1, 0),
+  "int16": (-2**15, 2**15-1, 0),
+  "int32": (-2**31, 2**31-1, 0),
+  "int64": (-2**63, 2**63-1, 0),
+  "float16": (-2**11, 2**11, 15),
+  "bfloat16": (-2**8, 2**8, 127),
+  "float32": (-2**24, 2**24, 127),
+  "float64": (-2**53, 2**53, 1023),
+  "complex32": (-2**11, 2**11, 15),
+  "complex64": (-2**24, 2**24, 127),
+  "complex128": (-2**53, 2**53, 1023)
+}
+
+class Tint(object):
+    def __init__(self, type):
+        if type not in tunsigned + tsigned:
+            raise ValueError("not an integer type: '%s'" % type)
+        self.type = type
+        self.min, self.max, self.exp = tinfo[type]
+        self.all = (self.type, self.min, self.max, self.exp)
+    def __repr__(self):
+        return self.type
+    def __eq__(self, other):
+        return isinstance(Tint, other) and self.all == other.all
+    def __hash__(self):
+        return hash(self.all)
+    def testcases(self):
+        yield 0
+        yield self.min
+        yield self.max
+        for i in range(10):
+            yield randrange(self.min, self.max+1)
+    def cpu_noimpl(self, f=None):
+        return False
+    def cpu_nokern(self, f=None):
+        return False
+    def cuda_noimpl(self, f=None):
+        return False
+    def cuda_nokern(self, f=None):
+        return False
+
+class Tfloat(object):
+    def __init__(self, type):
+        if type not in tfloat:
+            raise ValueError("not a float type: '%s'" % type)
+        self.type = type
+        self.min, self.max, self.exp = tinfo[type]
+        self.all = (self.type, self.min, self.max, self.exp)
+    def __repr__(self):
+        return self.type
+    def __eq__(self, other):
+        return isinstance(Tint, other) and self.all == other.all
+    def __hash__(self):
+        return hash(self.all)
+    def testcases(self):
+        yield 0
+        yield 0.5
+        yield -0.5
+        yield self.min
+        yield self.max
+        prec = randrange(1, 10)
+        for v in all_unary(prec, self.exp, 1):
+            yield float(v)
+        for v in un_randfloat():
+            yield float(v)
+    def cpu_noimpl(self, f=None):
+        return self.type == "float16"
+    def cpu_nokern(self, f=None):
+        return False
+    def cuda_noimpl(self, f=None):
+        if self.type == "float16":
+            return half_noimpl(f)
+    def cuda_nokern(self, f=None):
+        return False
+
+class Tcomplex(object):
+    def __init__(self, type):
+        if type not in tcomplex:
+            raise ValueError("not a complex type: '%s'" % type)
+        self.type = type
+        self.min, self.max, self.exp = tinfo[type]
+        self.all = (self.type, self.min, self.max, self.exp)
+    def __repr__(self):
+        return self.type
+    def __eq__(self, other):
+        return isinstance(Tint, other) and self.all == other.all
+    def __hash__(self):
+        return hash(self.all)
+    def testcases(self):
+        yield 0
+        yield 0.5
+        yield -0.5
+        yield 0.5j
+        yield -0.5j
+        yield self.min
+        yield self.max
+        prec = randrange(1, 10)
+        for v, w in all_binary(prec, self.exp, 1):
+            yield complex(float(v), float(w))
+        for v, w in bin_randfloat():
+            yield complex(float(v), float(w))
+    def cpu_noimpl(self, f=None):
+        if self.type == "complex32":
+            return True
+        return complex_noimpl(f)
+    def cpu_nokern(self, f=None):
+        return f in ("floor_divide", "remainder")
+    def cuda_noimpl(self, f=None):
+        if self.type == "complex32":
+            return True
+        return complex_noimpl(f)
+    def cuda_nokern(self, f=None):
+        return f in ("floor_divide", "remainder")
+
+
+tinfo_default = [
+  Tint("uint8"),
+  Tint("uint16"),
+  Tint("uint32"),
+  Tint("uint64"),
+  Tint("int8"),
+  Tint("int16"),
+  Tint("int32"),
+  Tint("int64"),
+  Tfloat("float16"),
+  Tfloat("bfloat16"),
+  Tfloat("float32"),
+  Tfloat("float64"),
+  Tcomplex("complex32"),
+  Tcomplex("complex64"),
+  Tcomplex("complex128")
+]
+
+tinfo_bitwise = [
+  Tint("bool"),
+  Tint("uint8"),
+  Tint("uint16"),
+  Tint("uint32"),
+  Tint("uint64"),
+  Tint("int8"),
+  Tint("int16"),
+  Tint("int32"),
+  Tint("int64")
+]
+
+implemented_sigs = {
+  "unary": {
+    "default": {}, "float_result": {}
+  },
+  "binary": {
+    "default": {}, "float_result": {}, "bool_result": {}, "bitwise": {}
+  },
+  "binary_mv": {
+    "default": {
+       (Tint("uint8"), Tint("uint8")): (Tint("uint8"), Tint("uint8")),
+       (Tint("uint16"), Tint("uint16")): (Tint("uint16"), Tint("uint16")),
+       (Tint("uint32"), Tint("uint32")): (Tint("uint32"), Tint("uint32")),
+       (Tint("uint64"), Tint("uint64")): (Tint("uint64"), Tint("uint64")),
+       (Tint("int8"), Tint("int8")): (Tint("int8"), Tint("int8")),
+       (Tint("int16"), Tint("int16")): (Tint("int16"), Tint("int16")),
+       (Tint("int32"), Tint("int32")): (Tint("int32"), Tint("int32")),
+       (Tint("int64"), Tint("int64")): (Tint("int64"), Tint("int64")),
+       (Tfloat("float32"), Tfloat("float32")): (Tfloat("float32"), Tfloat("float32")),
+       (Tfloat("float64"), Tfloat("float64")): (Tfloat("float64"), Tfloat("float64"))
+    },
+  }
+}
+
+exact_sigs = {
+  "unary": {
+    "default": {}, "float_result": {}
+  },
+  "binary": {
+    "default": {}, "float_result": {}, "bool_result": {}, "bitwise": {}
+  }
+}
+
+inexact_sigs = {
+  "unary": {
+    "default": {}, "float_result": {}
+  },
+  "binary": {
+    "default": {}, "float_result": {}, "bool_result": {}, "bitwise": {}
+  }
+}
+
+def init_unary_cast(pattern, tinfo, rank):
+    t = tinfo[rank]
+
+    start = max(8, rank) if pattern == "float_result" else rank
+    found_cast = False
+
+    for i in range(start, len(tinfo_default)):
+        cast = tinfo[i]
+        if cast.min <= t.min and t.max <= cast.max:
+            if found_cast or (t.type=="bfloat16") != (cast.type=="bfloat16"):
+                exact_sigs["unary"][pattern][(t,)] = cast
+            else:
+                found_cast = True
+                implemented_sigs["unary"][pattern][(t,)] = cast
+                exact_sigs["unary"][pattern][(t,)] = cast
+        else:
+            inexact_sigs["unary"][pattern][(t,)] = cast
+
+def init_unary_cast_tbl(pattern):
+    if pattern == "default":
+        tinfo = [Tint("bool")] + tinfo_default
+    elif pattern == "float_result":
+        tinfo = tinfo_default
+    elif pattern == "bitwise":
+        tinfo = tinfo_bitwise
+    else:
+        raise ValueError("unsupported function type '%s'" % func)
+
+    for rank, _ in enumerate(tinfo):
+        init_unary_cast(pattern, tinfo, rank)
+
+def is_binary_common_cast(cast, t, u):
+    if cast.min <= t.min and t.max <= cast.max and \
+       cast.min <= u.min and u.max <= cast.max:
+        if isinstance(cast, Tfloat):
+            return t.exp <= cast.exp and u.exp <= cast.exp
+        else:
+            return True
+    return False
+
+def init_binary_cast(pattern, tinfo, rank1, rank2):
+    min_rank = min(rank1, rank2)
+    max_rank = max(rank1, rank2)
+
+    t = tinfo[min_rank]
+    u = tinfo[max_rank]
+
+    start = max(8, max_rank) if pattern == "float_result" else max_rank
+    smallest_common_cast = False
+
+    for i in range(start, len(tinfo_default)):
+        common_cast = tinfo_default[i]
+        w = Tint("bool") if pattern == "bool_result" else common_cast
+        if is_binary_common_cast(common_cast, t, u):
+           if smallest_common_cast:
+               exact_sigs["binary"][pattern][(t, u)] = w
+           else:
+               smallest_common_cast = True
+               implemented_sigs["binary"][pattern][(t, u)] = w
+               exact_sigs["binary"][pattern][(t, u)] = w
+        else:
+            inexact_sigs["binary"][pattern][(t, u)] = w
+
+def init_binary_cast_tbl(pattern):
+    if pattern == "default" or pattern == "float_result" or pattern == "bool_result":
+        tinfo = tinfo_default
+    elif pattern == "bitwise":
+        tinfo = tinfo_bitwise
+    else:
+        raise ValueError("unsupported function type '%s'" % pattern)
+
+    for rank1, _ in enumerate(tinfo):
+        for rank2, _ in enumerate(tinfo):
+            init_binary_cast(pattern, tinfo, rank1, rank2)
+
+_struct_format = {
+  "float16": "e",
+  "float32": "f",
+  "float64": "d",
+  "complex32": "e",
+  "complex64": "f",
+  "complex128": "d"
+}
+
+def roundtrip_ne(v, fmt):
+    if fmt == "e":
+        try:
+            struct.pack(fmt, v)
+        except (OverflowError, struct.error):
+            return True
+        else:
+            return False
+    else:
+        if math.isinf(v):
+            return False
+        s = struct.unpack(fmt, struct.pack(fmt, v))[0]
+        return math.isinf(float(s))
+
+def struct_overflow(v, t):
+    try:
+        fmt = _struct_format[t.type]
+    except KeyError:
+        return False
+
+    if isinstance(t, Tcomplex):
+        return roundtrip_ne(v.real, fmt) or roundtrip_ne(v.imag, fmt)
+    else:
+        return roundtrip_ne(v, fmt)
+
+
+init_unary_cast_tbl("default")
+init_unary_cast_tbl("float_result")
+
+init_binary_cast_tbl("default")
+init_binary_cast_tbl("float_result")
+init_binary_cast_tbl("bool_result")
+init_binary_cast_tbl("bitwise")
+
+
+_np_names = {
+  "asin" : "arcsin",
+  "acos" : "arccos",
+  "atan" : "arctan",
+  "asinh" : "arcsinh",
+  "acosh" : "arccosh",
+  "atanh" : "arctanh",
+  "nearbyint" : "round",
+}
+
+def np_function(name):
+    return _np_names.get(name, name)
+
+def np_noimpl(name):
+    if name == "round":
+        # np.round == gumath.nearbyint
+        return True
+    try:
+        getattr(np, name)
+        return False
+    except AttributeError:
+        return True
+
+def gen_axes(ndim):
+    for i in range(ndim):
+        yield i
+    lst = list(range(ndim))
+    for i in range(ndim):
+        yield tuple(sample(lst, i))