xnd 0.2.0dev6 → 0.2.0dev7

data/ext/ruby_xnd/xnd/configure.ac

@@ -41,9 +41,12 @@ AC_SUBST(host)
 
 # Language and compiler:
 AC_LANG_C
-saved_cflags=$CFLAGS
+saved_cflags="$CFLAGS"
+saved_cxxflags="$CXXFLAGS"
 AC_PROG_CC
-CFLAGS=$saved_cflags
+AC_PROG_CXX
+CFLAGS="$saved_cflags"
+CXXFLAGS="$saved_cxxflags"
 
 # ar and ranlib:
 AC_CHECK_TOOL(AR, ar, ar)
@@ -58,6 +61,37 @@ AC_HEADER_STDC
 AC_PROG_INSTALL
 AC_SUBST(INSTALL)
 
+# Cuda compiler:
+AC_MSG_CHECKING(for nvcc)
+saved_cc="$CC"
+saved_cflags="$CFLAGS"
+saved_cxxflags="$CXXFLAGS"
+CC=nvcc
+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+void
+f(void)
+{
+    return;
+}
+]])],
+[have_nvcc=yes],
+[have_nvcc=no],
+[have_nvcc=undefined])
+CC="$saved_cc"
+CFLAGS="$saved_cflags"
+CXXFLAGS="$saved_cxxflags"
+AC_MSG_RESULT($have_nvcc)
+
+CUDA_CXX=
+CONFIGURE_CUDA_CXXFLAGS=
+if test "$have_nvcc" = yes; then
+    CUDA_CXX="nvcc"
+    CONFIGURE_CUDA_CXXFLAGS="-std=c++11"
+    AC_DEFINE(HAVE_CUDA, 1, [Define to 1 if you have the nvcc cuda compiler.])
+fi
+AC_SUBST(CUDA_CXX)
+AC_SUBST(CONFIGURE_CUDA_CXXFLAGS)
+
 # Add an explicit include directory.
 AC_MSG_CHECKING(for --with-includes)
 AC_ARG_WITH(includes,
@@ -116,20 +150,20 @@ AC_SUBST(NDT_INSTALL_DOCS)
 
 # Compiler dependent settings:
 XND_WARN=
-XND_OPT="-O2"
+XND_OPT="-O2 -g"
 case $CC in
     *gcc*)
         XND_WARN="-Wall -Wextra -std=c11 -pedantic"
-        XND_OPT="-O2"
+        XND_OPT="-O2 -g"
         ;;
     *icc*)
         AR=xiar
         XND_WARN="-Wall"
-        XND_OPT="-O2"
+        XND_OPT="-O2 -g"
         ;;
     *clang*)
         XND_WARN="-Wall -Wextra -std=c11 -pedantic"
-        XND_OPT="-O2"
+        XND_OPT="-O2 -g"
         ;;
 esac
 
@@ -137,7 +171,7 @@ esac
 
 # Substitute variables and generate output:
 if test -z "$LD"; then
-    LD="$CC"
+    LD="$CXX"
 fi
 AC_SUBST(LD)
 AC_SUBST(AR)
@@ -151,6 +185,12 @@ else
     CONFIGURE_CFLAGS="$XND_INCLUDE $XND_WARN $XND_CONFIG $XND_OPT $CFLAGS"
 fi
 
+if test -z "$CXXFLAGS"; then
+    CONFIGURE_CXXFLAGS="$XND_INCLUDE -Wall -Wextra -O2 -g"
+else
+    CONFIGURE_CXXFLAGS="$XND_INCLUDE -Wall -Wextra -O2 -g $CXXFLAGS"
+fi
+
 if test -z "$LDFLAGS"; then
     CONFIGURE_LDFLAGS="$XND_LINK $CONFIGURE_LDFLAGS"
 else
@@ -158,6 +198,7 @@ else
 fi
 
 AC_SUBST(CONFIGURE_CFLAGS)
+AC_SUBST(CONFIGURE_CXXFLAGS)
 AC_SUBST(CONFIGURE_LDFLAGS)
 
 AC_OUTPUT

data/ext/ruby_xnd/xnd/doc/xnd/index.rst

@@ -21,10 +21,12 @@ Operations like indexing and slicing return zero-copy typed views on the data.
 Importing PEP-3118 buffers is supported.
 
 
+
 .. toctree::
    :maxdepth: 1
 
-   types.rst
+   xnd.rst
+   array.rst
    align-pack.rst
    buffer-protocol.rst
    quickstart.rst

data/ext/ruby_xnd/xnd/doc/xnd/{types.rst → xnd.rst}

@@ -233,21 +233,6 @@ Here, type inference would deduce :c:macro:`int64`, so :c:macro:`uint8` needs
 to be passed explicitly.
 
 
-Performance
-~~~~~~~~~~~
-
-For large arrays, explicit types are significantly faster.  Type inference
-supports arbitrary nesting depth, is complex and still implemented in pure
-Python. Compare:
-
-.. doctest::
-
-   >>> lst = [1] * 1000000
-   >>> x = xnd(lst) # inference
-   >>>
-   >>> x = xnd(lst, type='1000000 * int64') # explicit
-
-
 All supported types
 -------------------
 
@@ -666,9 +651,9 @@ As a short example, here is a tuple that contains all primitive types:
    ...    (bool,
    ...     int8, int16, int32, int64,
    ...     uint8, uint16, uint32, uint64,
-   ...     float16, float32, float64,
-   ...     complex32, complex64, complex128)
+   ...     bfloat16, float16, float32, float64,
+   ...     bcomplex32, complex32, complex64, complex128)
    ... """
    >>> x = xnd.empty(s)
    >>> x.value
-   (False, 0, 0, 0, 0, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0j, 0j, 0j)
+   (False, 0, 0, 0, 0, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, 0j, 0j, 0j, 0j)

data/ext/ruby_xnd/xnd/libxnd/Makefile

@@ -0,0 +1,142 @@
+
+# ==============================================================================
+#                          Unix Makefile for libxnd
+# ==============================================================================
+
+
+LIBSTATIC = libxnd.a
+LIBNAME = libxnd.so
+LIBSONAME = libxnd.so.0
+LIBSHARED = libxnd.so.0.2.0dev3
+
+CC = gcc
+LD = g++
+AR = ar
+RANLIB = ranlib
+CUDA_CXX = 
+
+XND_INCLUDES = /home/sameer/.rvm/gems/ruby-2.4.1/gems/ndtypes-0.2.0dev6/ext/ruby_ndtypes/include
+
+CONFIGURE_CFLAGS =  -Wall -Wextra -std=c11 -pedantic  -O2 -g
+XND_CFLAGS = $(strip -I.. -I$(XND_INCLUDES) $(CONFIGURE_CFLAGS) $(CFLAGS))
+XND_CFLAGS_SHARED = $(XND_CFLAGS) -fPIC
+
+CONFIGURE_CXXFLAGS =  -Wall -Wextra -O2 -g
+XND_CXXFLAGS = $(strip -I.. -I$(XND_INCLUDES) $(CONFIGURE_CXXFLAGS) $(CXXFLAGS))
+XND_CXXFLAGS_SHARED = $(XND_CXXFLAGS) -fPIC
+
+CONFIGURE_LDFLAGS =  -shared -Wl,-soname,libxnd.so.0
+XND_LDFLAGS = $(strip $(CONFIGURE_LDFLAGS) $(LDFLAGS))
+
+CONFIGURE_CUDA_CXXFLAGS = 
+GM_CUDA_CXXFLAGS = $(strip $(CONFIGURE_CUDA_CXXFLAGS) $(CUDA_CXXFLAGS))
+
+
+default: $(LIBSTATIC) $(LIBSHARED)
+
+
+OBJS = bitmaps.o bounds.o copy.o equal.o shape.o split.o xnd.o
+
+SHARED_OBJS = .objs/bitmaps.o .objs/bounds.o .objs/copy.o .objs/equal.o .objs/shape.o .objs/split.o .objs/xnd.o
+
+ifdef CUDA_CXX
+OBJS += cuda_memory.o
+SHARED_OBJS += .objs/cuda_memory.o
+endif
+
+
+$(LIBSTATIC): Makefile $(OBJS)
+	$(AR) rc $(LIBSTATIC) $(OBJS)
+	$(RANLIB) $(LIBSTATIC)
+
+$(LIBSHARED): Makefile $(SHARED_OBJS)
+	$(LD) $(XND_LDFLAGS) -o $(LIBSHARED) $(SHARED_OBJS)
+	ln -sf $(LIBSHARED) $(LIBNAME)
+	ln -sf $(LIBSHARED) $(LIBSONAME)
+
+
+bitmaps.o:\
+Makefile bitmaps.c xnd.h
+	$(CC) $(XND_CFLAGS) -c bitmaps.c
+
+.objs/bitmaps.o:\
+Makefile bitmaps.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c bitmaps.c -o .objs/bitmaps.o
+
+bounds.o:\
+Makefile bounds.c xnd.h
+	$(CC) $(XND_CFLAGS) -c bounds.c
+
+.objs/bounds.o:\
+Makefile bounds.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c bounds.c -o .objs/bounds.o
+
+copy.o:\
+Makefile copy.c xnd.h
+	$(CC) $(XND_CFLAGS) -c copy.c
+
+.objs/copy.o:\
+Makefile copy.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c copy.c -o .objs/copy.o
+
+equal.o:\
+Makefile equal.c xnd.h
+	$(CC) $(XND_CFLAGS) -c equal.c
+
+.objs/equal.o:\
+Makefile equal.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c equal.c -o .objs/equal.o
+
+shape.o:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS) -c shape.c
+
+.objs/shape.o:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c shape.c -o .objs/shape.o
+
+split.o:\
+Makefile split.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS) -c split.c
+
+.objs/split.o:\
+Makefile split.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c split.c -o .objs/split.o
+
+xnd.o:\
+Makefile xnd.c xnd.h
+	$(CC) $(XND_CFLAGS) -c xnd.c
+
+.objs/xnd.o:\
+Makefile xnd.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c xnd.c -o .objs/xnd.o
+
+
+# Cuda
+cuda_memory.o:\
+Makefile cuda/cuda_memory.cu cuda/cuda_memory.h
+	$(CUDA_CXX) --compiler-options "$(XND_CXXFLAGS)" $(GM_CUDA_CXXFLAGS) -c cuda/cuda_memory.cu
+
+.objs/cuda_memory.o:\
+Makefile cuda/cuda_memory.cu cuda/cuda_memory.h
+	$(CUDA_CXX) --compiler-options "$(XND_CXXFLAGS_SHARED)" $(GM_CUDA_CXXFLAGS) -c cuda/cuda_memory.cu -o .objs/cuda_memory.o
+
+
+# Coverage
+coverage:\
+Makefile clean runtest
+	./tests/runtest
+	for file in *.c; do gcov -l "$$file" > /dev/null 2>&1; done
+
+FORCE:
+
+clean: FORCE
+	rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+	rm -f $(LIBSTATIC) $(LIBSHARED) $(LIBSONAME) $(LIBNAME)
+	cd .objs && rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+
+distclean: clean
+	rm -f Makefile
+
+
+

data/ext/ruby_xnd/xnd/libxnd/Makefile.in

@@ -13,23 +13,36 @@ CC = @CC@
 LD = @LD@
 AR = @AR@
 RANLIB = @RANLIB@
+CUDA_CXX = @CUDA_CXX@
 
 XND_INCLUDES = @CONFIGURE_INCLUDES@
 
 CONFIGURE_CFLAGS = @CONFIGURE_CFLAGS@
-XND_CFLAGS = $(strip -I$(XND_INCLUDES) $(CONFIGURE_CFLAGS) $(CFLAGS))
+XND_CFLAGS = $(strip -I.. -I$(XND_INCLUDES) $(CONFIGURE_CFLAGS) $(CFLAGS))
 XND_CFLAGS_SHARED = $(XND_CFLAGS) -fPIC
 
+CONFIGURE_CXXFLAGS = @CONFIGURE_CXXFLAGS@
+XND_CXXFLAGS = $(strip -I.. -I$(XND_INCLUDES) $(CONFIGURE_CXXFLAGS) $(CXXFLAGS))
+XND_CXXFLAGS_SHARED = $(XND_CXXFLAGS) -fPIC
+
 CONFIGURE_LDFLAGS = @CONFIGURE_LDFLAGS@
 XND_LDFLAGS = $(strip $(CONFIGURE_LDFLAGS) $(LDFLAGS))
 
+CONFIGURE_CUDA_CXXFLAGS = @CONFIGURE_CUDA_CXXFLAGS@
+GM_CUDA_CXXFLAGS = $(strip $(CONFIGURE_CUDA_CXXFLAGS) $(CUDA_CXXFLAGS))
+
 
 default: $(LIBSTATIC) $(LIBSHARED)
 
 
-OBJS = bitmaps.o copy.o equal.o split.o xnd.o
+OBJS = bitmaps.o bounds.o copy.o equal.o shape.o split.o xnd.o
+
+SHARED_OBJS = .objs/bitmaps.o .objs/bounds.o .objs/copy.o .objs/equal.o .objs/shape.o .objs/split.o .objs/xnd.o
 
-SHARED_OBJS = .objs/bitmaps.o .objs/copy.o .objs/equal.o .objs/split.o .objs/xnd.o
+ifdef CUDA_CXX
+OBJS += cuda_memory.o
+SHARED_OBJS += .objs/cuda_memory.o
+endif
 
 
 $(LIBSTATIC): Makefile $(OBJS)
@@ -41,6 +54,7 @@ $(LIBSHARED): Makefile $(SHARED_OBJS)
 	ln -sf $(LIBSHARED) $(LIBNAME)
 	ln -sf $(LIBSHARED) $(LIBSONAME)
 
+
 bitmaps.o:\
 Makefile bitmaps.c xnd.h
 	$(CC) $(XND_CFLAGS) -c bitmaps.c
@@ -49,6 +63,14 @@ Makefile bitmaps.c xnd.h
 Makefile bitmaps.c xnd.h
 	$(CC) $(XND_CFLAGS_SHARED) -c bitmaps.c -o .objs/bitmaps.o
 
+bounds.o:\
+Makefile bounds.c xnd.h
+	$(CC) $(XND_CFLAGS) -c bounds.c
+
+.objs/bounds.o:\
+Makefile bounds.c xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c bounds.c -o .objs/bounds.o
+
 copy.o:\
 Makefile copy.c xnd.h
 	$(CC) $(XND_CFLAGS) -c copy.c
@@ -65,6 +87,14 @@ Makefile equal.c xnd.h
 Makefile equal.c xnd.h
 	$(CC) $(XND_CFLAGS_SHARED) -c equal.c -o .objs/equal.o
 
+shape.o:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS) -c shape.c
+
+.objs/shape.o:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) $(XND_CFLAGS_SHARED) -c shape.c -o .objs/shape.o
+
 split.o:\
 Makefile split.c overflow.h xnd.h
 	$(CC) $(XND_CFLAGS) -c split.c
@@ -82,6 +112,16 @@ Makefile xnd.c xnd.h
 	$(CC) $(XND_CFLAGS_SHARED) -c xnd.c -o .objs/xnd.o
 
 
+# Cuda
+cuda_memory.o:\
+Makefile cuda/cuda_memory.cu cuda/cuda_memory.h
+	$(CUDA_CXX) --compiler-options "$(XND_CXXFLAGS)" $(GM_CUDA_CXXFLAGS) -c cuda/cuda_memory.cu
+
+.objs/cuda_memory.o:\
+Makefile cuda/cuda_memory.cu cuda/cuda_memory.h
+	$(CUDA_CXX) --compiler-options "$(XND_CXXFLAGS_SHARED)" $(GM_CUDA_CXXFLAGS) -c cuda/cuda_memory.cu -o .objs/cuda_memory.o
+
+
 # Coverage
 coverage:\
 Makefile clean runtest

data/ext/ruby_xnd/xnd/libxnd/Makefile.vc

@@ -19,7 +19,7 @@ LIBNDTYPESDIR = ..\ndtypes\libndtypes
 OPT = /MT /Ox /GS /EHsc
 OPT_SHARED = /DXND_EXPORT /MD /Ox /GS /EHsc /Fo.objs^\
 
-COMMON_CFLAGS = /nologo /W4 /wd4200 /wd4201 /wd4204
+COMMON_CFLAGS = -I.. /nologo /W4 /wd4200 /wd4201 /wd4204
 CFLAGS = $(COMMON_CFLAGS) $(OPT)
 CFLAGS_SHARED = $(COMMON_CFLAGS) $(OPT_SHARED)
 
@@ -31,9 +31,9 @@ default: $(LIBSTATIC) $(LIBSHARED)
 	copy /y $(LIBSHARED) ..\python\xnd
 
 
-OBJS = bitmaps.obj copy.obj equal.obj split.obj xnd.obj
+OBJS = bitmaps.obj bounds.obj copy.obj equal.obj shape.obj split.obj xnd.obj
 
-SHARED_OBJS = .objs\bitmaps.obj .objs\copy.obj .objs\equal.obj .objs\split.obj .objs\xnd.obj
+SHARED_OBJS = .objs\bitmaps.obj .objs\bounds.obj .objs\copy.obj .objs\equal.obj .objs\shape.obj .objs\split.obj .objs\xnd.obj
 
 
 $(LIBSTATIC):\
@@ -55,6 +55,14 @@ Makefile bitmaps.c xnd.h
 Makefile bitmaps.c xnd.h
 	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS_SHARED) -c bitmaps.c
 
+bounds.obj:\
+Makefile bounds.c xnd.h
+	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS) -c bounds.c
+
+.objs\bounds.obj:\
+Makefile bounds.c xnd.h
+	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS_SHARED) -c bounds.c
+
 copy.obj:\
 Makefile copy.c xnd.h
 	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS) -c copy.c
@@ -71,6 +79,14 @@ Makefile equal.c xnd.h
 Makefile equal.c xnd.h
 	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS_SHARED) -c equal.c
 
+shape.obj:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS) -c shape.c
+
+.objs\shape.obj:\
+Makefile shape.c overflow.h xnd.h
+	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS_SHARED) -c shape.c
+
 split.obj:\
 Makefile split.c overflow.h xnd.h
 	$(CC) "-I$(LIBNDTYPESINCLUDE)" $(CFLAGS) -c split.c

data/ext/ruby_xnd/xnd/libxnd/bitmaps.c

@@ -86,7 +86,13 @@ bitmap_init(xnd_bitmap_t *b, const ndt_t *t, int64_t nitems, ndt_context_t *ctx)
     assert(b->size == 0);
     assert(b->next == NULL);
 
-    if (t->ndim == 0 && ndt_is_optional(t)) {
+    if (ndt_is_optional(t)) {
+         if (t->ndim > 0) {
+             ndt_err_format(ctx, NDT_NotImplementedError,
+                 "optional dimensions are not implemented");
+             return -1;
+         }
+
          b->data = bits_new(nitems, ctx);
          if (b->data == NULL) {
              return -1;
@@ -108,8 +114,8 @@ bitmap_init(xnd_bitmap_t *b, const ndt_t *t, int64_t nitems, ndt_context_t *ctx)
         n = nitems;
 
         if (t->ndim == 1) {
-            int32_t noffsets = t->Concrete.VarDim.noffsets;
-            n = t->Concrete.VarDim.offsets[noffsets-1];
+            int32_t noffsets = t->Concrete.VarDim.offsets->n;
+            n = t->Concrete.VarDim.offsets->v[noffsets-1];
         }
 
         return bitmap_init(b, t->VarDim.type, n, ctx);
@@ -163,6 +169,30 @@ bitmap_init(xnd_bitmap_t *b, const ndt_t *t, int64_t nitems, ndt_context_t *ctx)
         return 0;
     }
 
+    case Union: {
+        shape = t->Union.ntags;
+
+        n = nitems * shape;
+        b->next = bitmap_array_new(n, ctx);
+        if (b->next == NULL) {
+            xnd_bitmap_clear(b);
+            return -1;
+        }
+        b->size = n;
+
+        for (i = 0; i < nitems; i++) {
+            for (k = 0; k < shape; k++) {
+                next = b->next + i*shape + k;
+                if (bitmap_init(next, t->Union.types[k], 1, ctx) < 0) {
+                    xnd_bitmap_clear(b);
+                    return -1;
+                }
+            }
+        }
+
+        return 0;
+    }
+
     case Ref: {
         b->next = bitmap_array_new(nitems, ctx);
         if (b->next == NULL) {
@@ -220,6 +250,12 @@ bitmap_init(xnd_bitmap_t *b, const ndt_t *t, int64_t nitems, ndt_context_t *ctx)
         return 0;
     }
 
+    case Array: {
+        ndt_err_format(ctx, NDT_NotImplementedError,
+            "the element type of flexible arrays cannot be optional");
+        return -1;
+    }
+
     default:
         return 0;
     }
@@ -272,6 +308,9 @@ xnd_bitmap_next(const xnd_t *x, int64_t i, ndt_context_t *ctx)
     case Record:
         shape = t->Record.shape;
         break;
+    case Union:
+        shape = t->Union.ntags;
+        break;
     case Ref: case Constr: case Nominal:
         shape = 1;
         break;