gumath 0.2.0dev5

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

@@ -0,0 +1,140 @@
+/*
+* 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"
+
+
+/*****************************************************************************/
+/*                         Euclidian pairwise distance                       */
+/*****************************************************************************/
+
+/* Numerically unstable: This is just an example for the constraint feature. */
+
+static int
+pdist(xnd_t stack[], ndt_context_t *ctx)
+{
+    const ndt_t *t = stack[0].type;
+    const ndt_t *u = t->FixedDim.type;
+    const int64_t N = t->FixedDim.shape;
+    const int64_t M = u->FixedDim.shape;
+    int64_t l = 0;
+    (void)ctx;
+
+    for (int64_t i = 0; i < N; i++) {
+        const xnd_t vector1 = xnd_fixed_dim_next(&stack[0], i);
+        for (int64_t j = i+1; j < N; j++) {
+            const xnd_t vector2 = xnd_fixed_dim_next(&stack[0], j);
+            double sum = 0.0;
+            for (int64_t k = 0; k < M; k++) {
+                const xnd_t value1 = xnd_fixed_dim_next(&vector1, k);
+                const xnd_t value2 = xnd_fixed_dim_next(&vector2, k);
+                const double v1 = *(double *)value1.ptr;
+                const double v2 = *(double *)value2.ptr;
+                sum += pow(v1-v2, 2);
+            }
+            const xnd_t res = xnd_fixed_dim_next(&stack[1], l++);
+            *(double *)res.ptr = sqrt(sum);
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * Validate N, M and compute unknown output dimension P.
+ *
+ * shape[0] = N
+ * shape[1] = N
+ * shape[2] = P
+ *
+ * 'args' is unused here.  Other functions may inspect the incoming xnd
+ * arguments in order to resolve further constraints based on values.
+ */
+static int
+pdist_constraint(int64_t *shapes, const void *args, ndt_context_t *ctx)
+{
+    (void)args;
+
+    if (shapes[0] == 0 || shapes[1] == 0) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "euclidian_pdist() requires a non-empty matrix");
+        return -1;
+    }
+
+    shapes[2] = (shapes[0] * (shapes[0]-1)) / 2;
+    return 0;
+}
+
+static const ndt_constraint_t constraint = {
+  .f = pdist_constraint,
+  .nin = 2,
+  .nout = 1,
+  .symbols = {"N", "M", "P"}
+};
+
+
+static const gm_kernel_init_t kernels[] = {
+  { .name = "euclidian_pdist",
+    .sig = "N * M * float64 -> P * float64",
+    .constraint = &constraint,
+    .Xnd = pdist },
+
+  { .name = NULL, .sig = NULL }
+};
+
+
+/****************************************************************************/
+/*                       Initialize kernel table                            */
+/****************************************************************************/
+
+int
+gm_init_pdist_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/quaternion.c

@@ -0,0 +1,156 @@
+/*
+* 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"
+
+
+static int
+gm_multiply_strided_1D_q64_q64(char *args[], intptr_t dimensions[], intptr_t steps[],
+                               void *data GM_UNUSED)
+{
+    const char *src1 = args[0];
+    const char *src2 = args[1];
+    char *dest = args[2];
+    const ndt_complex64_t (*s1)[2];
+    const ndt_complex64_t (*s2)[2];
+    ndt_complex64_t (*d1)[2];
+    intptr_t n = dimensions[0];
+    intptr_t i, j, k, l;
+
+    for (i = 0; i < n; i++) {
+      s1 = (const ndt_complex64_t (*)[2])src1;
+      s2 = (const ndt_complex64_t (*)[2])src2;
+      d1 = (ndt_complex64_t (*)[2])dest;
+      for (j = 0; j < 2; j++){
+        for (k = 0; k < 2; k++) {
+          ndt_complex64_t sum = 0;
+          for (l = 0; l < 2; l++) {
+            sum += s1[j][l] * s2[l][k];
+          }
+          d1[j][k] = sum;
+        }
+      }
+      src1 += steps[0];
+      src2 += steps[1];
+      dest += steps[2];
+    }
+
+    return 0;
+}
+
+static int
+gm_multiply_strided_1D_q128_q128(char *args[], intptr_t dimensions[], intptr_t steps[],
+                                 void *data GM_UNUSED)
+{
+    const char *src1 = args[0];
+    const char *src2 = args[1];
+    char *dest = args[2];
+    const ndt_complex128_t (*s1)[2];
+    const ndt_complex128_t (*s2)[2];
+    ndt_complex128_t (*d1)[2];
+    intptr_t n = dimensions[0];
+    intptr_t i, j, k, l;
+
+    for (i = 0; i < n; i++) {
+      s1 = (const ndt_complex128_t (*)[2])src1;
+      s2 = (const ndt_complex128_t (*)[2])src2;
+      d1 = (ndt_complex128_t (*)[2])dest;
+      for (j = 0; j < 2; j++){
+        for (k = 0; k < 2; k++) {
+          ndt_complex128_t sum = 0;
+          for (l = 0; l < 2; l++) {
+            sum += s1[j][l] * s2[l][k];
+          }
+          d1[j][k] = sum;
+        }
+      }
+      src1 += steps[0];
+      src2 += steps[1];
+      dest += steps[2];
+    }
+
+    return 0;
+}
+
+
+static const gm_typedef_init_t typedefs[] = {
+  { .name = "quaternion64", .type = "2 * 2 * complex64", .meth=NULL },
+  { .name = "quaternion128", .type = "2 * 2 * complex128", .meth=NULL },
+  { .name = NULL, .type = NULL }
+};
+
+static const gm_kernel_init_t kernels[] = {
+  { .name = "multiply",
+    .sig = "... * N * quaternion64, ... * N * quaternion64 -> ... * N * quaternion64",
+    .Strided = gm_multiply_strided_1D_q64_q64 },
+
+  { .name = "multiply",
+    .sig = "... * N * quaternion128, ... * N * quaternion128 -> ... * N * quaternion128",
+    .Strided = gm_multiply_strided_1D_q128_q128 },
+
+  { .name = NULL, .sig = NULL }
+};
+
+
+/****************************************************************************/
+/*                       Initialize kernel table                            */
+/****************************************************************************/
+
+int
+gm_init_quaternion_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/func.c

@@ -0,0 +1,177 @@
+/*
+ * 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 <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <complex.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "gumath.h"
+
+
+/******************************************************************************/
+/*                         Type allocation/deallocation                       */
+/******************************************************************************/
+
+gm_func_t *
+gm_func_new(const char *name, ndt_context_t *ctx)
+{
+    gm_func_t *f;
+
+    f = ndt_alloc_size(sizeof *f);
+    if (f == NULL) {
+        return ndt_memory_error(ctx);
+    }
+
+    f->name = ndt_strdup(name, ctx);
+    if (f->name == NULL) {
+        ndt_free(f);
+        return NULL;
+    }
+    f->typecheck = NULL;
+    f->nkernels = 0;
+
+    return f;
+}
+
+void
+gm_func_del(gm_func_t *f)
+{
+    ndt_free(f->name);
+
+    for (int i = 0; i < f->nkernels; i++) {
+        ndt_del(f->kernels[i].sig);
+    }
+
+    ndt_free(f);
+}
+
+gm_func_t *
+gm_add_func(gm_tbl_t *tbl, const char *name, ndt_context_t *ctx)
+{
+    gm_func_t *f = gm_func_new(name, ctx);
+
+    if (f == NULL) {
+        return NULL;
+    }
+
+    if (gm_tbl_add(tbl, name, f, ctx) < 0) {
+        gm_func_del(f);
+        return NULL;
+    }
+
+    return f;
+}
+
+int
+gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t *ctx)
+{
+    gm_func_t *f = gm_tbl_find(tbl, k->name, ctx);
+    gm_kernel_set_t kernel;
+    ndt_t *t;
+
+    if (f == NULL) {
+        ndt_err_clear(ctx);
+        f = gm_add_func(tbl, k->name, ctx);
+        if (f == NULL) {
+            return -1;
+        }
+    }
+
+    t = ndt_from_string_v(k->sig, ctx);
+    if (t == NULL) {
+        return -1;
+    }
+
+    if (f->nkernels == GM_MAX_KERNELS) {
+        ndt_del(t);
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "%s: maximum number of kernels reached for", f->name);
+        return -1;
+    }
+
+    kernel.sig = t;
+    kernel.constraint = k->constraint;
+    kernel.Opt = k->Opt;
+    kernel.C = k->C;
+    kernel.Fortran = k->Fortran;
+    kernel.Strided = k->Strided;
+    kernel.Xnd = k->Xnd;
+
+    f->kernels[f->nkernels++] = kernel;
+    return 0;
+}
+
+int
+gm_add_kernel_typecheck(gm_tbl_t *tbl, const gm_kernel_init_t *k, ndt_context_t *ctx,
+                        gm_typecheck_t typecheck)
+{
+    gm_func_t *f = gm_tbl_find(tbl, k->name, ctx);
+    gm_kernel_set_t kernel;
+    ndt_t *t;
+
+    if (f == NULL) {
+        ndt_err_clear(ctx);
+        f = gm_add_func(tbl, k->name, ctx);
+        if (f == NULL) {
+            return -1;
+        }
+        f->typecheck = typecheck;
+    }
+
+    t = ndt_from_string_v(k->sig, ctx);
+    if (t == NULL) {
+        return -1;
+    }
+
+    if (f->nkernels == GM_MAX_KERNELS) {
+        ndt_del(t);
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "%s: maximum number of kernels reached for", f->name);
+        return -1;
+    }
+
+    kernel.sig = t;
+    kernel.constraint = k->constraint;
+    kernel.Opt = k->Opt;
+    kernel.C = k->C;
+    kernel.Fortran = k->Fortran;
+    kernel.Strided = k->Strided;
+    kernel.Xnd = k->Xnd;
+
+    f->kernels[f->nkernels++] = kernel;
+    return 0;
+}