gumath 0.2.0dev5

data/ext/ruby_gumath/gumath/configure.ac

@@ -0,0 +1,167 @@
+
+AC_PREREQ([2.67])
+AC_INIT(gumath, 0.2.0dev3, skrah@bytereef.org, gumath, https://github.com/plures/)
+AC_CONFIG_HEADER(config.h)
+AC_CONFIG_FILES([Makefile libgumath/Makefile])
+
+# System and machine type (only used for Darwin):
+AC_MSG_CHECKING(system as reported by uname -s)
+ac_sys_system=`uname -s`
+AC_MSG_RESULT($ac_sys_system)
+
+LIBSTATIC=libgumath.a
+case $ac_sys_system in
+    darwin*|Darwin*)
+        LIBRARY_PATH="DYLD_LIBRARY_PATH"
+        LIBNAME="libgumath.dylib"
+        LIBSONAME="libgumath.0.dylib"
+        LIBSHARED="libgumath.0.2.0dev3.dylib"
+        CONFIGURE_LDFLAGS="-dynamiclib -install_name @rpath/$LIBSONAME -undefined dynamic_lookup -compatibility_version 0.2 -current_version 0.2.0"
+        ;;
+    *)
+        LIBRARY_PATH="LD_LIBRARY_PATH"
+        LIBNAME="libgumath.so"
+        LIBSONAME="libgumath.so.0"
+        LIBSHARED="libgumath.so.0.2.0dev3"
+        CONFIGURE_LDFLAGS="-shared -Wl,-soname,$LIBSONAME"
+        ;;
+esac
+
+AC_SUBST(LIBSTATIC)
+AC_SUBST(LIBRARY_PATH)
+AC_SUBST(LIBNAME)
+AC_SUBST(LIBSONAME)
+AC_SUBST(LIBSHARED)
+
+
+# Apparently purely informational for this particular build:
+AC_CANONICAL_HOST
+AC_SUBST(build)
+AC_SUBST(host)
+
+# Language and compiler:
+AC_LANG_C
+saved_cflags=$CFLAGS
+AC_PROG_CC
+CFLAGS=$saved_cflags
+
+# ar and ranlib:
+AC_CHECK_TOOL(AR, ar, ar)
+AC_PROG_RANLIB
+AC_SUBST(RANLIB)
+
+
+# Checks for header files:
+AC_HEADER_STDC
+AC_CHECK_HEADER([pthread.h],
+  [AC_DEFINE([HAVE_PTHREAD_H], 1, [Define to 1 if you have the <pthread.h> header file.])],
+  [])
+
+# Install program:
+AC_PROG_INSTALL
+AC_SUBST(INSTALL)
+
+# Add an explicit include directory.
+AC_MSG_CHECKING(for --with-includes)
+AC_ARG_WITH(includes,
+            AS_HELP_STRING([--with-includes="/usr/local/include"],
+            [absolute path to an include directory]),
+            [],
+            [with_includes="none"])
+
+AC_MSG_RESULT($with_includes)
+
+if test "$with_includes" = "none"; then
+    CONFIGURE_INCLUDES=../ndtypes/libndtypes
+    CONFIGURE_INCLUDES_TEST=../../ndtypes/libndtypes
+else
+    CONFIGURE_INCLUDES=$with_includes
+    CONFIGURE_INCLUDES_TEST=$with_includes
+fi
+
+AC_SUBST(CONFIGURE_INCLUDES)
+AC_SUBST(CONFIGURE_INCLUDES_TEST)
+
+# Add an explicit library path.
+AC_MSG_CHECKING(for --with-libs)
+AC_ARG_WITH(libs,
+            AS_HELP_STRING([--with-libs="/usr/local/lib"],
+            [absolute path to a library directory]),
+            [],
+            [with_libs="none"])
+
+AC_MSG_RESULT($with_libs)
+
+if test "$with_libs" = "none"; then
+    CONFIGURE_LIBS=../ndtypes/libndtypes
+    CONFIGURE_LIBS_TEST=../../ndtypes/libndtypes
+else
+    CONFIGURE_LIBS=$with_libs
+    CONFIGURE_LIBS_TEST=$with_libs
+fi
+
+AC_SUBST(CONFIGURE_LIBS)
+AC_SUBST(CONFIGURE_LIBS_TEST)
+
+# Without documentation:
+AC_MSG_CHECKING([for --with-docs])
+AC_ARG_WITH([docs],
+  AS_HELP_STRING([--with-docs], [install documentation - enabled by default]),,
+  with_docs=yes)
+AC_MSG_RESULT([$with_docs])
+if test "$with_docs" = yes; then
+   NDT_INSTALL_DOCS="install_docs"
+else
+   NDT_INSTALL_DOCS=""
+fi
+
+AC_SUBST(NDT_INSTALL_DOCS)
+
+# Compiler dependent settings:
+GM_WARN=
+GM_OPT="-O2"
+case $CC in
+    *gcc*)
+        GM_WARN="-Wall -Wextra -std=c11 -pedantic"
+        GM_OPT="-O3"
+        ;;
+    *icc*)
+        AR=xiar
+        GM_WARN="-Wall"
+        GM_OPT="-O3"
+        ;;
+    *clang*)
+        GM_WARN="-Wall -Wextra -std=c11 -pedantic"
+        GM_OPT="-O3"
+        ;;
+esac
+
+
+
+# Substitute variables and generate output:
+if test -z "$LD"; then
+    LD="$CC"
+fi
+AC_SUBST(LD)
+AC_SUBST(AR)
+AC_SUBST(GM_WARN)
+AC_SUBST(GM_OPT)
+
+
+if test -z "$CFLAGS"; then
+    CONFIGURE_CFLAGS="$GM_INCLUDE $GM_WARN $GM_CONFIG $GM_OPT"
+else
+    CONFIGURE_CFLAGS="$GM_INCLUDE $GM_WARN $GM_CONFIG $GM_OPT $CFLAGS"
+fi
+
+if test -z "$LDFLAGS"; then
+    CONFIGURE_LDFLAGS="$GM_LINK $CONFIGURE_LDFLAGS"
+else
+    CONFIGURE_LDFLAGS="$GM_LINK $CONFIGURE_LDFLAGS $LDFLAGS"
+fi
+
+AC_SUBST(CONFIGURE_CFLAGS)
+AC_SUBST(CONFIGURE_LDFLAGS)
+
+AC_OUTPUT
+

data/ext/ruby_gumath/gumath/doc/_static/copybutton.js

@@ -0,0 +1,66 @@
+// Copyright 2014 PSF. Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+// File originates from the cpython source found in Doc/tools/sphinxext/static/copybutton.js
+
+$(document).ready(function() {
+    /* Add a [>>>] button on the top-right corner of code samples to hide
+     * the >>> and ... prompts and the output and thus make the code
+     * copyable. */
+    var div = $('.highlight-py .highlight,' +
+                '.highlight-default .highlight,' +
+                '.highlight-py3 .highlight')
+    var pre = div.find('pre');
+
+    // get the styles from the current theme
+    pre.parent().parent().css('position', 'relative');
+    var hide_text = 'Hide the prompts and output';
+    var show_text = 'Show the prompts and output';
+    var border_width = pre.css('border-top-width');
+    var border_style = pre.css('border-top-style');
+    var border_color = pre.css('border-top-color');
+    var button_styles = {
+        'cursor':'pointer', 'position': 'absolute', 'top': '0', 'right': '0',
+        'border-color': border_color, 'border-style': border_style,
+        'border-width': border_width, 'color': border_color, 'text-size': '75%',
+        'font-family': 'monospace', 'padding-left': '0.2em', 'padding-right': '0.2em',
+        'border-radius': '0 3px 0 0'
+    }
+
+    // create and add the button to all the code blocks that contain >>>
+    div.each(function(index) {
+        var jthis = $(this);
+        if (jthis.find('.gp').length > 0) {
+            var button = $('<span class="copybutton">&gt;&gt;&gt;</span>');
+            button.css(button_styles)
+            button.attr('title', hide_text);
+            button.data('hidden', 'false');
+            jthis.prepend(button);
+        }
+        // tracebacks (.gt) contain bare text elements that need to be
+        // wrapped in a span to work with .nextUntil() (see later)
+        jthis.find('pre:has(.gt)').contents().filter(function() {
+            return ((this.nodeType == 3) && (this.data.trim().length > 0));
+        }).wrap('<span>');
+    });
+
+    // define the behavior of the button when it's clicked
+    $('.copybutton').click(function(e){
+        e.preventDefault();
+        var button = $(this);
+        if (button.data('hidden') === 'false') {
+            // hide the code output
+            button.parent().find('.go, .gp, .gt').hide();
+            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden');
+            button.css('text-decoration', 'line-through');
+            button.attr('title', show_text);
+            button.data('hidden', 'true');
+        } else {
+            // show the code output
+            button.parent().find('.go, .gp, .gt').show();
+            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible');
+            button.css('text-decoration', 'none');
+            button.attr('title', hide_text);
+            button.data('hidden', 'false');
+        }
+    });
+});
+

data/ext/ruby_gumath/gumath/doc/conf.py

@@ -0,0 +1,26 @@
+import sys, os, docutils
+
+
+extensions = ['sphinx.ext.intersphinx', 'sphinx.ext.doctest']
+
+source_suffix = '.rst'
+master_doc = 'index'
+project = 'gumath'
+copyright = '2017-2018, Plures Project'
+version = 'v0.2.0dev3'
+release = 'v0.2.0dev3'
+exclude_patterns = ['doc', 'build']
+pygments_style = 'sphinx'
+html_static_path = ['_static']
+
+primary_domain = 'py'
+add_function_parentheses = False
+
+
+def setup(app):
+    app.add_crossref_type('topic', 'topic', 'single: %s',
+                          docutils.nodes.strong)
+    app.add_javascript("copybutton.js")
+
+
+

data/ext/ruby_gumath/gumath/doc/gumath/functions.rst

@@ -0,0 +1,62 @@
+.. meta::
+   :robots: index,follow
+   :description: xnd container
+   :keywords: xnd, types, examples
+
+.. sectionauthor:: Stefan Krah <skrah at bytereef.org>
+
+
+Builtin functions
+=================
+
+The gumath.functions module wraps the builtin libgumath kernels and serves
+as an example of a modular namespace.
+
+
+All builtin functions
+---------------------
+
+.. doctest::
+
+   >>> from gumath import functions as fn
+   >>> dir(fn)
+   ['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'add', 'asin', 'asinh', 'atan', 'atanh', 'cbrt', 'ceil', 'copy', 'cos', 'cosh', 'divide', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'floor', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'logb', 'multiply', 'nearbyint', 'round', 'sin', 'sinh', 'sqrt', 'subtract', 'tan', 'tanh', 'tgamma', 'trunc']
+
+
+Unary functions
+---------------
+
+.. doctest::
+
+   >>> from xnd import xnd
+   >>> x = xnd([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+   >>> fn.log(x)
+   xnd([[0.0, 0.6931471805599453, 1.0986122886681098], [1.3862943611198906, 1.6094379124341003, 1.791759469228055]],
+       type='2 * 3 * float64')
+
+On an array with a *float64* dtype, *log* works as expected.
+
+
+.. doctest::
+
+   >>> x = xnd([[1, 2, 3], [4, 5, 6]])
+   >>> x.type
+   ndt("2 * 3 * int64")
+   >>> fn.log(x)
+   Traceback (most recent call last):
+     File "<stdin>", line 1, in <module>
+   RuntimeError: invalid dtype
+
+This function call would require an implicit inexact conversion from *int64* to
+*float64*.  All builtin libgumath kernels only allow exact conversions, so the
+example fails.
+
+
+.. doctest::
+
+   >>> x = xnd([[1, 2, 3], [4, 5, 6]], dtype="int32")
+   >>> fn.log(x)
+   xnd([[0.0, 0.6931471805599453, 1.0986122886681098], [1.3862943611198906, 1.6094379124341003, 1.791759469228055]],
+       type='2 * 3 * float64')
+
+*int32* to *float64* conversions are exact, so the call succeeds.

data/ext/ruby_gumath/gumath/doc/gumath/index.rst

@@ -0,0 +1,26 @@
+.. meta::
+   :robots: index, follow
+   :description: gumath documentation
+   :keywords: kernels, dispatch, Python
+
+.. sectionauthor:: Stefan Krah <skrah at bytereef.org>
+
+
+gumath
+------
+
+The gumath Python module provides the infrastructure for managing and
+dispatching libgumath kernels.  Kernels target xnd containers from the
+xnd Python module.
+
+gumath supports modular namespaces.  Typically, a namespace is implemented
+as one Python module that uses gumath for calling kernels.
+
+The xndtools project automates generating kernels and creating namespace
+modules.
+
+
+.. toctree::
+   :maxdepth: 1
+
+   functions.rst

data/ext/ruby_gumath/gumath/doc/index.rst

@@ -0,0 +1,45 @@
+.. meta::
+   :robots: index, follow
+   :description: gumath documentation
+   :keywords: libgumath, gumath, C, Python, array computing
+
+.. sectionauthor:: Stefan Krah <skrah at bytereef.org>
+
+
+gumath
+======
+
+Gumath is a package for extensible dispatch of computational kernels that
+target xnd containers.  Kernels can be added at runtime, which allows the
+use of JIT compilers.
+
+
+Libgumath
+---------
+
+C library.
+
+.. toctree::
+   :maxdepth: 1
+
+   libgumath/index.rst
+
+
+Gumath
+------
+
+Python module.
+
+.. toctree::
+   :maxdepth: 1
+
+   gumath/index.rst
+
+
+Releases
+--------
+
+.. toctree::
+   :maxdepth: 1
+
+   releases/index.rst

data/ext/ruby_gumath/gumath/doc/libgumath/data-structures.rst

@@ -0,0 +1,130 @@
+.. meta::
+   :robots: index,follow
+   :description: libndtypes documentation
+
+.. sectionauthor:: Stefan Krah <skrah at bytereef.org>
+
+
+Data structures
+===============
+
+libgumath is a lightweight library for managing and dispatching computational
+kernels that target XND containers.
+
+Functions are multimethods in a lookup table. Typically, applications that
+use libgumath should create a new lookup table for each namespace. For example,
+Python modules generally should have a module-specific lookup table.
+
+
+Kernel signatures
+-----------------
+
+.. topic:: kernels
+
+.. code-block:: c
+
+   typedef int (* gm_xnd_kernel_t)(xnd_t stack[], ndt_context_t *ctx);
+
+The signature of an *xnd* kernel. *stack* contains incoming and outgoing
+arguments. In case of an error, kernels are expected to set a context error
+message and return *-1*.
+
+In case of success, the return value is *0*.
+
+
+.. code-block:: c
+
+   typedef int (* gm_strided_kernel_t)(char **args, intptr_t *dimensions, intptr_t *steps, void *data);
+
+The signature of a NumPy compatible kernel.  These signatures are for
+applications that want to use existing NumPy compatible kernels on XND
+containers.
+
+XND containers are automatically converted to a temporary ndarray before
+kernel application.
+
+
+Kernel set
+----------
+
+.. code-block:: c
+
+   /* Collection of specialized kernels for a single function signature. */
+   typedef struct {
+      ndt_t *sig;
+      const ndt_constraint_t *constraint;
+
+      /* Xnd signatures */
+      gm_xnd_kernel_t C;       /* dispatch ensures c-contiguous */
+      gm_xnd_kernel_t Fortran; /* dispatch ensures f-contiguous */
+      gm_xnd_kernel_t Xnd;     /* selected if non-contiguous or both C and Fortran are NULL */
+
+      /* NumPy signature */
+      gm_strided_kernel_t Strided;
+   } gm_kernel_set_t;
+
+A kernel set contains the function signature, an optional constraint function,
+and up to four specialized kernels, each of which may be *NULL*.
+
+The dispatch calls the kernels in the following order of preference:
+
+If the inner dimensions of the incoming arguments are C-contiguous, the *C*
+kernel is called first. In case of *Fortran* inner dimensions, *Fortran*
+is called first.
+
+If an *Xnd* kernel is present, it is called next, then the *Strided* kernel.
+
+
+Kernel set initialization
+-------------------------
+
+.. topic:: kernel set initialization
+
+.. code-block:: c
+
+   typedef struct {
+      const char *name;
+      const char *sig;
+      const ndt_constraint_t *constraint;
+
+      gm_xnd_kernel_t C;
+      gm_xnd_kernel_t Fortran;
+      gm_xnd_kernel_t Xnd;
+      gm_strided_kernel_t Strided;
+   } gm_kernel_init_t;
+
+   int gm_add_kernel(gm_tbl_t *tbl, const gm_kernel_init_t *kernel, ndt_context_t *ctx);
+
+The *gm_kernel_init_t* is used for initializing a kernel set.  Usually, a C
+translation unit contains an array of hundreds of *gm_kernel_init_t* structs
+together with a function that initializes a specific lookup table.
+
+
+Multimethod struct
+------------------
+
+.. topic:: kernel set initialization
+
+.. code-block:: c
+
+   /* 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[], int nin, 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];
+   };
+
+This is the multimethod struct for a given function name.  Each multimethod has
+a *nkernels* associated kernel sets with unique type signatures.
+
+If *typecheck* is *NULL*, the generic libndtypes multimethod dispatch is used
+to locate the kernel. This is an O(N) operation, whose search time is negligible
+for large array operations.
+
+The *typecheck* field can be set to an optimized lookup function that has
+internal knowledge of kernel set locations.  The only restriction to the
+function is that it must behave exactly as the generic libndtypes typecheck.