gumath 0.2.0dev5

data/ext/ruby_gumath/gumath/libgumath/extending/bfloat16.c

@@ -0,0 +1,130 @@
+/*
+* 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.
+*/
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+#include <complex.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+
+
+/* Avoid Python.h dependency. */
+struct _object;
+double PyFloat_AsDouble(const struct _object *);
+struct _object *PyFloat_FromDouble (double v);
+struct _object *PyErr_Occurred(void);
+
+
+/*****************************************************************************/
+/*                Initialize a single bfloat16 from a PyObject               */
+/*****************************************************************************/
+
+/* XXX Maybe rename "init", "repr" to "from_object", "to_object". */
+static bool
+bfloat16_init(void *dest, const void *src, ndt_context_t *ctx)
+{
+    const struct _object *v = (const struct _object *)src;
+    xnd_t *x = (xnd_t *)dest;
+    const ndt_t *t = x->type;
+    float f;
+    (void)ctx;
+
+    f = (float)PyFloat_AsDouble(v);
+    if (f == -1 && PyErr_Occurred()) {
+        return 0;
+    }
+
+    const char *cp = ndt_is_big_endian(t) ? (char *)&f : ((char *)&f)+2;
+    memcpy(x->ptr, cp, sizeof(uint16_t));
+    return 1;
+}
+
+static void *
+bfloat16_repr(const void *src, ndt_context_t *ctx)
+{
+    const xnd_t *x = (const xnd_t *)src;
+    const ndt_t *t = x->type;
+    float f = 0;
+    (void)ctx;
+
+    char *cp = ndt_is_big_endian(t) ? (char *)&f : ((char *)&f)+2;
+    memcpy(cp, x->ptr, sizeof(uint16_t));
+
+    return PyFloat_FromDouble(f);
+}
+
+
+static const ndt_methods_t bfloat16_methods = {
+  .init = bfloat16_init,
+  .constraint = NULL,
+  .repr = bfloat16_repr,
+};
+
+static const gm_typedef_init_t typedefs[] = {
+  { .name = "bfloat16", .type = "uint16", .meth=&bfloat16_methods },
+  { .name = NULL, .type = NULL, .meth=NULL }
+};
+
+static const gm_kernel_init_t kernels[] = {
+  { .name = NULL, .sig = NULL }
+};
+
+
+/****************************************************************************/
+/*                       Initialize kernel table                            */
+/****************************************************************************/
+
+int
+gm_init_bfloat16_kernels(gm_tbl_t *tbl, ndt_context_t *ctx)
+{
+    const gm_typedef_init_t *t;
+    const gm_kernel_init_t *k;
+
+    for (t = typedefs; t->name != NULL; t++) {
+        if (ndt_typedef_from_string(t->name, t->type, t->meth, ctx) < 0) {
+            return -1;
+        }
+    }
+
+    for (k = kernels; k->name != NULL; k++) {
+        if (gm_add_kernel(tbl, k, ctx) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}

data/ext/ruby_gumath/gumath/libgumath/extending/examples.c

@@ -0,0 +1,176 @@
+/*
+* 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.
+*/
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+#include <complex.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+
+
+/****************************************************************************/
+/*                               Xnd kernels                                */
+/****************************************************************************/
+
+/*
+ * Count valid/missing values in a 1D array of records and return the result
+ * as a record.
+ *
+ * Signature:
+ *    "... * N * {index: int64, name: string, value: ?int64} -> ... * {valid: int64, missing: int64}"
+ */
+static int
+count_valid_missing(xnd_t stack[], ndt_context_t *ctx)
+{
+    const xnd_t *array = &stack[0];
+    int64_t N = array->type->FixedDim.shape; /* N in the above signature */
+    xnd_t *out = &stack[1];
+    int64_t ok = 0;
+    int64_t na = 0;
+
+    for (int64_t i = 0; i < N; i++) {
+        const xnd_t record = xnd_fixed_dim_next(array, i);
+        const xnd_t value = xnd_record_next(&record, 2, ctx);
+        if (value.ptr == NULL) {
+            return -1;
+        }
+
+        if (xnd_is_na(&value)) {
+            na++;
+        }
+        else {
+            ok++;
+        }
+    }
+
+    xnd_t valid = xnd_record_next(out, 0, ctx);
+    *(int64_t *)(valid.ptr) = ok;
+
+    xnd_t missing = xnd_record_next(out, 1, ctx);
+    *(int64_t *)(missing.ptr) = na;
+
+    return 0;
+}
+
+int
+gm_0D_add_scalar(xnd_t stack[], ndt_context_t *ctx)
+{
+    const xnd_t *x = &stack[0];
+    const xnd_t *y = &stack[1];
+    xnd_t *z = &stack[2];
+    int64_t N = xnd_fixed_shape(x);
+    int64_t yy = *(int64_t *)y->ptr;
+    (void)ctx;
+
+    for (int64_t i = 0; i < N; i++) {
+        const xnd_t xx = xnd_fixed_dim_next(x, i);
+        const xnd_t zz = xnd_fixed_dim_next(z, i);
+        *(int64_t *)zz.ptr = *(int64_t *)xx.ptr + yy;
+    }
+
+    return 0;
+}
+
+int
+gm_randint(xnd_t stack[], ndt_context_t *ctx)
+{
+    const xnd_t *x = &stack[0];
+    (void)ctx;
+
+    *(int32_t *)x->ptr = rand();
+    return 0;
+}
+
+int
+gm_randtuple(xnd_t stack[], ndt_context_t *ctx)
+{
+    const xnd_t *x = &stack[0];
+    const xnd_t *y = &stack[1];
+    (void)ctx;
+
+    *(int32_t *)x->ptr = rand();
+    *(int32_t *)y->ptr = rand();
+    return 0;
+}
+
+int
+gm_divmod10(xnd_t stack[], ndt_context_t *ctx)
+{
+    const xnd_t *x = &stack[0];
+    int64_t xx = *(int64_t *)x->ptr;
+    const xnd_t *y = &stack[1];
+    const xnd_t *z = &stack[2];
+    (void)ctx;
+
+    *(int64_t *)y->ptr = xx / 10;
+    *(int64_t *)z->ptr = xx % 10;
+    return 0;
+}
+
+
+static const gm_kernel_init_t kernels[] = {
+  { .name = "add_scalar", .sig = "... * N * int64, ... * int64 -> ... * N * int64", .Xnd = gm_0D_add_scalar },
+
+  { .name = "count_valid_missing",
+    .sig = "... * N * {index: int64, name: string, value: ?int64} -> ... * {valid: int64, missing: int64}",
+    .Xnd = count_valid_missing },
+
+  { .name = "randint", .sig = "void -> int32", .Xnd = gm_randint },
+  { .name = "randtuple", .sig = "void -> int32, int32", .Xnd = gm_randtuple },
+  { .name = "divmod10", .sig = "int64 -> int64, int64", .Xnd = gm_divmod10 },
+
+  { .name = NULL, .sig = NULL }
+};
+
+
+/****************************************************************************/
+/*                       Initialize kernel table                            */
+/****************************************************************************/
+
+int
+gm_init_example_kernels(gm_tbl_t *tbl, ndt_context_t *ctx)
+{
+    const gm_kernel_init_t *k;
+
+    for (k = kernels; k->name != NULL; k++) {
+        if (gm_add_kernel(tbl, k, ctx) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}

data/ext/ruby_gumath/gumath/libgumath/extending/graph.c

@@ -0,0 +1,393 @@
+/*
+* 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.
+*/
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+#include <complex.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "gumath.h"
+
+
+/*****************************************************************************/
+/*                           Check graph invariants                          */
+/*****************************************************************************/
+
+static bool
+graph_constraint(const void *graph, ndt_context_t *ctx)
+{
+    const xnd_t *g = (xnd_t *)graph;
+    int64_t start2, step2; /* start, step of ndim2 (the graph) */
+    int64_t start1, step1; /* start, step of ndim1 (an array of edges) */
+    int64_t N;  /* number of nodes */
+
+
+    N = ndt_var_indices(&start2, &step2, g->type, g->index, ctx);
+    if (N < 0) {
+        return false;
+    }
+
+    for (int32_t u = 0; u < N; u++) {
+        const xnd_t edges = xnd_var_dim_next(g, start2, step2, u);
+        const int64_t nedges = ndt_var_indices(&start1, &step1, edges.type,
+                                               edges.index, ctx);
+        if (nedges < 0) {
+            return false;
+        }
+
+        for (int64_t k = 0; k < nedges; k++) {
+            const xnd_t tuple = xnd_var_dim_next(&edges, start1, step1, k);
+            const xnd_t target = xnd_tuple_next(&tuple, 0, ctx);
+            const int32_t v = *(int32_t *)target.ptr;
+
+            if (v < 0 || v >= N) {
+                ndt_err_format(ctx, NDT_ValueError,
+                    "node id must be in range [0, N-1]");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*****************************************************************************/
+/*      Bellman-Ford single-source shortest-paths algorithm (CLRS p588)      */
+/*****************************************************************************/
+
+
+static const int32_t NIL = INT32_MIN;
+
+/*
+ * Allocate and initialize distance and predecessor arrays.
+ * d := distance array
+ * p := predecessor array
+ * N := number of nodes
+ * u := single source node id
+ */
+static int
+init(double **d, int32_t **p, int64_t N, int32_t u, ndt_context_t *ctx)
+{
+    *d = ndt_alloc(N, sizeof **d);
+    if (*d == NULL) {
+        (void)ndt_memory_error(ctx);
+        return -1;
+    }
+
+    *p = ndt_alloc(N, sizeof **p);
+    if (*p == NULL) {
+        ndt_free(*d);
+        (void)ndt_memory_error(ctx);
+        return -1;
+    }
+
+    for (int64_t i = 0; i < N; i++) {
+        (*d)[i] = INFINITY;
+        (*p)[i] = NIL;
+    }
+
+    (*d)[u] = 0;
+
+    return 0;
+}
+
+/*
+ * d := distance array
+ * p := predecessor array
+ * u := source node id
+ * v := target node id
+ * cost := cost of going from source to target
+ */
+static inline void
+relax(double d[], int32_t p[], int32_t u, int32_t v, double cost)
+{
+    if (d[u] + cost < d[v]) {
+        d[v] = d[u] + cost;
+        p[v] = u;
+    }
+}
+
+/*
+ * Write the shortest path single_source ==> v to dest.
+ * If dest==NULL and dsize==0, return the length of the path.
+ *
+ * dest := path array
+ * p := predecessor array
+ * single_source := single source node id
+ * v := target node id
+ */
+static int64_t
+write_path(int32_t *dest, const int32_t dsize,
+           const int32_t p[], const int64_t psize,
+           const int32_t s, int32_t v)
+{
+    int64_t n = dsize;
+
+    while (1) {
+
+        assert(0 <= v && v < psize);
+        assert(dest == NULL || n >= 0);
+
+        if (v == s || p[v] != NIL) {
+            n--;
+            if (dest != NULL) dest[n] = v;
+            if (v == s) break;
+        }
+        else if (p[v] == NIL) {
+            return 0;
+        }
+
+        v = p[v];
+    }
+
+    return dest == NULL ? -n : n;
+}
+
+static xnd_t
+mk_return_array(int32_t p[], const int64_t N, const int32_t u,
+                ndt_context_t *ctx)
+{
+    int32_t *ndim2_offsets = NULL;
+    int32_t *ndim1_offsets = NULL;
+    ndt_t *t;
+    int64_t sum;
+    int32_t v;
+
+    if (N+1 > INT32_MAX) {
+        goto offset_overflow;
+    }
+
+    ndim2_offsets = ndt_alloc(2, sizeof *ndim2_offsets);
+    if (ndim2_offsets == NULL) {
+        (void)ndt_memory_error(ctx);
+        return xnd_error;
+    }
+    ndim2_offsets[0] = 0;
+    ndim2_offsets[1] = (int32_t)N;
+
+
+    ndim1_offsets = ndt_alloc(N+1, sizeof *ndim1_offsets);
+    if (ndim1_offsets == NULL) {
+        (void)ndt_memory_error(ctx);
+        return xnd_error;
+    }
+
+    sum = 0;
+    for (v = 0; v < N; v++) {
+        ndim1_offsets[v] = (int32_t)sum;
+        int64_t n = write_path(NULL, 0, p, N, u, v);
+        sum += n;
+        if (sum > INT32_MAX) {
+            goto offset_overflow;
+        }
+    }
+    ndim1_offsets[v] = (int32_t)sum;
+
+
+    t = ndt_from_string("node", ctx);
+    if (t == NULL) {
+        goto error;
+    }
+
+    t = ndt_var_dim(t, InternalOffsets, (int32_t)(N+1), ndim1_offsets, 0, NULL, ctx);
+    ndim1_offsets = NULL;
+    if (t == NULL) {
+        goto error;
+    }
+
+    t = ndt_var_dim(t, InternalOffsets, 2, ndim2_offsets, 0, NULL, ctx);
+    ndim2_offsets = NULL;
+    if (t == NULL) {
+        goto error;
+    }
+
+    xnd_master_t *x = xnd_empty_from_type(t, XND_OWN_EMBEDDED, ctx);
+    if (x == NULL) {
+        goto error;
+    }
+    xnd_t out = x->master;
+    ndt_free(x);
+
+    t = out.type->VarDim.type;
+    for (v = 0; v < N; v++) {
+        int32_t shape = t->Concrete.VarDim.offsets[v+1]-t->Concrete.VarDim.offsets[v];
+        char *ptr = out.ptr + t->Concrete.VarDim.offsets[v] * t->Concrete.VarDim.itemsize;
+        (void)write_path((int32_t *)ptr, shape, p, N, u, v);
+    }
+
+    return out;
+
+error:
+    ndt_free(ndim2_offsets);
+    ndt_free(ndim1_offsets);
+    return xnd_error;
+
+offset_overflow:
+    ndt_err_format(ctx, NDT_ValueError, "overflow in int32_t offsets");
+    goto error;
+}
+
+static int
+shortest_path(xnd_t stack[], ndt_context_t *ctx)
+{
+    const int32_t single_source = *(int32_t *)stack[1].ptr; /* start node */
+    int64_t start2, step2; /* start, step of ndim2 (the graph) */
+    int64_t start1, step1; /* start, step of ndim1 (an array of edges) */
+    double *d;  /* distance array */
+    int32_t *p; /* predecessor array */
+    int64_t N;  /* number of nodes */
+
+    /* graph in adjacency list representation */
+    const xnd_t graph = xnd_nominal_next(&stack[0], ctx);
+    if (graph.ptr == NULL) {
+        return -1;
+    }
+
+    N = ndt_var_indices(&start2, &step2, graph.type, graph.index, ctx);
+    if (N < 0) {
+        return -1;
+    }
+
+    if (init(&d, &p, N, single_source, ctx) < 0) {
+        return -1;
+    }
+
+    for (int64_t i = 0; i < N-1; i++) {
+        for (int32_t u = 0; u < N; u++) {
+            const xnd_t edges = xnd_var_dim_next(&graph, start2, step2, u);
+            const int64_t nedges = ndt_var_indices(&start1, &step1, edges.type,
+                                                   edges.index, ctx);
+            if (nedges < 0) {
+                return -1;
+            }
+
+            for (int64_t k = 0; k < nedges; k++) {
+                const xnd_t tuple = xnd_var_dim_next(&edges, start1, step1, k);
+                const xnd_t target = xnd_tuple_next(&tuple, 0, ctx);
+                const xnd_t uvcost = xnd_tuple_next(&tuple, 1, ctx);
+
+                const int32_t v = *(int32_t *)target.ptr;
+                const double cost = *(double *)uvcost.ptr;
+
+                relax(d, p, u, v, cost);
+            }
+        }
+    }
+
+    for (int32_t u = 0; u < N; u++) {
+        const xnd_t edges = xnd_var_dim_next(&graph, start2, step2, u);
+        const int64_t nedges = ndt_var_indices(&start1, &step1, edges.type,
+                                               edges.index, ctx);
+        if (nedges < 0) {
+            return -1;
+        }
+
+        for (int64_t k = 0; k < nedges; k++) {
+            const xnd_t tuple = xnd_var_dim_next(&edges, start1, step1, k);
+            const xnd_t target = xnd_tuple_next(&tuple, 0, ctx);
+            const xnd_t uvcost = xnd_tuple_next(&tuple, 1, ctx);
+
+            const int32_t v = *(int32_t *)target.ptr;
+            const double cost = *(double *)uvcost.ptr;
+
+            if (d[u] + cost < d[v]) {
+                ndt_err_format(ctx, NDT_ValueError,
+                    "graph contains a negative weight cycle");
+                ndt_free(d);
+                ndt_free(p);
+                return -1;
+            }
+        }
+    }
+
+    ndt_free(d);
+
+    /* Push return value (possibly xnd_error) onto the stack. */
+    stack[2] = mk_return_array(p, N, single_source, ctx);
+
+    ndt_free(p);
+
+    return stack[2].ptr == NULL ? -1 : 0;
+}
+
+
+static const ndt_methods_t graph_methods = {
+  .init = NULL,
+  .constraint = graph_constraint,
+  .repr = NULL
+};
+
+static const gm_typedef_init_t typedefs[] = {
+  { .name = "node", .type = "int32", .meth=NULL, },
+  { .name = "cost", .type = "float64", .meth=NULL },
+  { .name = "graph", .type = "var * var * (node, cost)", .meth=&graph_methods },
+  { .name = NULL, .type = NULL, .meth=NULL }
+};
+
+static const gm_kernel_init_t kernels[] = {
+  { .name = "single_source_shortest_paths",
+    .sig = "graph, node -> var * var * node",
+    .Xnd = shortest_path },
+
+  { .name = NULL, .sig = NULL }
+};
+
+
+/****************************************************************************/
+/*                       Initialize kernel table                            */
+/****************************************************************************/
+
+int
+gm_init_graph_kernels(gm_tbl_t *tbl, ndt_context_t *ctx)
+{
+    const gm_typedef_init_t *t;
+    const gm_kernel_init_t *k;
+
+    for (t = typedefs; t->name != NULL; t++) {
+        if (ndt_typedef_from_string(t->name, t->type, t->meth, ctx) < 0) {
+            return -1;
+        }
+    }
+
+    for (k = kernels; k->name != NULL; k++) {
+        if (gm_add_kernel(tbl, k, ctx) < 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}