xnd 0.2.0dev5 → 0.2.0dev6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c72739d8baf63a7ea8c88c629cdcd95e66bf63b
-  data.tar.gz: af5fd4043cb9ef384045fa9336afd4b6ada916c3
+  metadata.gz: 536c884cecfd158e1e01e9aff7064f4d0e2e676c
+  data.tar.gz: 3021eac9e7c2432bd1a1442370eee8d606499377
 SHA512:
-  metadata.gz: 185d044acea2787a12fb235a8aa45e156db2cd90a7e7dfe7b6dc4eb26efc401c89a36df5db31c97a8db17b092deb2d4181e140dd2c6fa1630d36152762a6a127
-  data.tar.gz: 171bbee778e719d8038e662a2c55b37921426b2c6e3dafb284b4ec872dd0f445d59f3182d83beffb58dc3aa8e5b7f69e4c89f3177b4710ce847ca14fd5d6ea90
+  metadata.gz: f9c5d29e4dd7da6d5004f1dfbb2cbbadd79c096f7cf7b1e4c61f33eb1781c8af9e4e246caf67f53b106428a3544f18e72aa9ed0a7b54c7376f114c8b16fac272
+  data.tar.gz: '097f3df97bb4fa565f3d499329f6c8359759427b364e579689eee4fb8efc503036f49fa11ee6aa0c93cfe7ddff6080f6d2c8c06e7efc83cd08887495d79f11b1'

data/README.md

@@ -1,7 +1,12 @@
 # Introduction
 
+XND is a library for storing typed data defined by ndtypes. It is a wrapper
+over the libxnd C library.
+
 # Installation
 
+For direct installation, run: `gem install xnd --pre`.
+
 # Usage
 
 # Acknowledgments

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'
 require 'rake/extensiontask'
-require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
+require 'rake/testtask'
 require 'fileutils'
 require 'xnd/version.rb'
 
@@ -13,6 +13,12 @@ Rake::ExtensionTask.new(ext_name, gemspec) do |ext|
   ext.source_pattern = "**/*.{c,h}"
 end
 
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
 def run *cmd
   sh(cmd.join(" "))
 end
@@ -53,55 +59,19 @@ VALGRIND_MEMORYFILL_OPTIONS = [
     "--free-fill=66 ",
 ]
 
-GDB_OPTIONS = []
-
-namespace :spec do
-  # partial-loads-ok and undef-value-errors necessary to ignore
-  # spurious (and eminently ignorable) warnings from the ruby
-  # interpreter
+# partial-loads-ok and undef-value-errors necessary to ignore
+# spurious (and eminently ignorable) warnings from the ruby
+# interpreter
 
-  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR.to_s ]
-
-  desc "Run specs under GDB."
-  task :gdb => [ :compile ] do |task|
-          cmd = [ 'gdb' ] + GDB_OPTIONS
-    cmd += [ '--args' ]
-    cmd += RSPEC_CMD
-    run( *cmd )
-  end
-
-  desc "Run specs under cgdb."
-  task :cgdb => [ :compile ] do |task|
-    cmd = [ 'cgdb' ] + GDB_OPTIONS
-    cmd += [ '--args' ]
-    cmd += RSPEC_CMD
-    run( *cmd )
-  end
-
-  desc "Run specs under Valgrind."
-  task :valgrind => [ :compile ] do |task|
-    cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
-    cmd += RSPEC_CMD
-    run( *cmd )
-  end
-
-  desc "Run specs under Callgrind."
-  task :callgrind => [ :compile ] do |task|
-    cmd = [ 'valgrind' ] + CALLGRIND_OPTIONS
-    cmd += RSPEC_CMD
-    run( *cmd )
-  end
-end
-
-LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
-
-desc "Run leakcheck script."
-task :leakcheck => [ :compile ] do |task|
+desc "Run specs under Valgrind."
+task :valgrind => [ :compile ] do |task|
   cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
-  cmd += LEAKCHECK_CMD
+  cmd += [" rake test "]
   run( *cmd )
 end
 
+LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
+
 task :clobber do |task|
   [
     "ext/#{ext_name}/include",

data/ext/ruby_xnd/extconf.rb

@@ -14,7 +14,7 @@ end
 
 # libndtypes config
 
-ndtypes_version = ">= 0.2.0dev3"
+ndtypes_version = ">= 0.2.0dev5"
 ndtypes_spec = Gem::Specification.find_by_name("ndtypes", ndtypes_version)
 ndtypes_extdir = File.join(ndtypes_spec.gem_dir, 'ext', 'ruby_ndtypes')
 ndtypes_includedir = File.join(ndtypes_extdir, 'include')
@@ -52,6 +52,10 @@ headers = File.expand_path(File.join(File.dirname(__FILE__) + "/include/"))
 find_library("xnd", nil, binaries)
 find_header("xnd.h", headers)
 
+FileUtils.copy_file File.expand_path(File.join(File.dirname(__FILE__) +
+                                               "/ruby_xnd.h")),
+                    "#{headers}/ruby_xnd.h"
+
 dir_config("xnd", [headers], [binaries])
 
 $INSTALLFILES = [
@@ -62,7 +66,7 @@ $INSTALLFILES = [
 # for macOS
 append_ldflags("-Wl,-rpath #{binaries}")
 
-basenames = %w{float_pack_unpack gc_guard ruby_xnd}
+basenames = %w{util float_pack_unpack gc_guard ruby_xnd}
 $objs = basenames.map { |b| "#{b}.o"   }
 $srcs = basenames.map { |b| "#{b}.c" }
 

data/ext/ruby_xnd/float_pack_unpack.h

@@ -34,6 +34,14 @@
    Author: Sameer Deshmukh (@v0dro)
 */
 
+int rb_xnd_pack_float32(double num, unsigned char* ptr, int le);
+
+int rb_xnd_unpack_float32(float *x, unsigned char* ptr, int le);
+
+int rb_xnd_pack_float64(double num, unsigned char *ptr, int le);
+
+int rb_xnd_unpack_float64(double *x, unsigned char *ptr, int le);
+
 #ifdef XND_DEBUG
 void run_float_pack_unpack_tests(void);
 #endif

data/ext/ruby_xnd/ruby_xnd.c

@@ -40,7 +40,6 @@
 VALUE cRubyXND;
 VALUE cXND;
 static VALUE cRubyXND_MBlock;
-static VALUE cRubyXND_Ellipsis;
 static const rb_data_type_t MemoryBlockObject_type;
 static const rb_data_type_t XndObject_type;
 
@@ -72,7 +71,8 @@ obj_inspect(const char* msg, VALUE obj)
 static VALUE
 xnd_ellipsis(void)
 {
-  return rb_funcall(cRubyXND_Ellipsis, rb_intern("initialize"), 0, NULL);
+  return rb_funcall(rb_const_get_at(cXND, rb_intern("Ellipsis")),
+                    rb_intern("new"), 0, NULL);
 }
 
 /****************************************************************************/
@@ -213,13 +213,6 @@ _strncpy(char *dest, const void *src, size_t len, size_t size)
     memset(dest+len, '\0', size-len);
 }
 
-/* Return true if String is unicode. */
-static int
-string_is_unicode(VALUE str)
-{
-  
-}
-
 static int
 string_is_ascii(VALUE str)
 {
@@ -241,14 +234,6 @@ string_is_u8(VALUE str)
                );
 }
 
-/* Encode a string to enc. enc should be name of the constant in Encoding::*. */
-static VALUE
-string_encode(VALUE str, const char * enc)
-{
-  return rb_funcall(str, rb_intern("encode"), 1,
-                    rb_const_get(rb_cEncoding, rb_intern(enc)));
-}
-
 static int64_t
 u8_skip_trailing_zero(const uint8_t *ptr, int64_t codepoints)
 {
@@ -1013,6 +998,7 @@ XND_type(VALUE self)
 
   GET_XND(self, xnd_p);
 
+
   return xnd_p->type;
 }
 
@@ -1072,6 +1058,9 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
       seterr(&ctx);
       raise_error();
     }
+    if (shape > maxshape) {
+      shape = maxshape;
+    }
 
     array = array_new(shape);
 
@@ -1131,7 +1120,7 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
     hash = rb_hash_new();
 
     for (i = 0; i < shape; ++i) {
-      if (i == maxshape - i) {
+      if (i == maxshape - 1) {
         rb_hash_aset(hash, xnd_ellipsis(), xnd_ellipsis());
         break;
       }
@@ -1459,7 +1448,7 @@ convert_single(xnd_index_t *key, VALUE obj, size_t size)
       rb_raise(rb_eIndexError, "Cannot use Range on this type.");
     };
     
-    size_t begin, end, step;
+    long long begin, end, step;
 
     rb_range_unpack(obj, &begin, &end, &step, size);
     key->tag = Slice;
@@ -1536,11 +1525,10 @@ XND_array_aref(int argc, VALUE *argv, VALUE self)
   NDT_STATIC_CONTEXT(ctx);
   xnd_index_t indices[NDT_MAX_DIM];
   xnd_t x;
-  int len, state;
+  int len;
   uint8_t flags;
   XndObject *xnd_p;
   size_t size;
-  VALUE rb_size;
 
   if (argc == 0) {
     rb_raise(rb_eArgError, "expected atleast one argument for #[].");
@@ -1563,6 +1551,15 @@ XND_array_aref(int argc, VALUE *argv, VALUE self)
   return RubyXND_view_move_type(xnd_p, &x);
 }
 
+/* Compare between data of an XND object and Ruby object. */
+static VALUE
+convert_compare(VALUE self, VALUE other)
+{
+  VALUE vcmp = XND_value(self);
+
+  return rb_funcall(vcmp, rb_intern("=="), 1, other);
+}
+
 /* Implementation for #== method. 
 
    @param other Other Ruby object to compare with.
@@ -1576,7 +1573,7 @@ XND_eqeq(VALUE self, VALUE other)
   int r;
 
   if (!XND_CHECK_TYPE(other)) {
-    return Qfalse;
+    return convert_compare(self, other);
   }
 
   GET_XND(self, left_p);
@@ -1789,6 +1786,27 @@ XND_each(VALUE self)
   
 }
 
+/* Implement XND#short_value */
+static VALUE
+XND_short_value(VALUE self, VALUE maxshape)
+{
+  if (maxshape == Qnil) {
+    return XND_value(self);
+  }
+  else {
+    long max = NUM2LONG(maxshape);
+    XndObject *self_p;
+
+    GET_XND(self, self_p);
+
+    if (max < 0) {
+      rb_raise(rb_eArgError, "maxshape must be positive.");
+    }
+
+    return _XND_value(XND(self_p), max);
+  }
+}
+
 /*************************** Singleton methods ********************************/
 
 static VALUE
@@ -1910,11 +1928,26 @@ rb_xnd_get_type(void)
 
 void Init_ruby_xnd(void)
 {
+  NDT_STATIC_CONTEXT(ctx);
+  static int initialized = 0;
+
+  if (!initialized) {
+    if (xnd_init_float(&ctx) < 0) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    if (!ndt_exists()) {
+      rb_raise(rb_eLoadError, "NDT does not exist.");
+    }
+
+    initialized = 1;
+  }
+  
   /* init classes */
   cRubyXND = rb_define_class("RubyXND", rb_cObject);
   cXND = rb_define_class("XND", cRubyXND);
   cRubyXND_MBlock = rb_define_class_under(cRubyXND, "MBlock", rb_cObject);
-  cRubyXND_Ellipsis = rb_define_class_under(cRubyXND, "Ellipsis", rb_cObject);
   mRubyXND_GCGuard = rb_define_module_under(cRubyXND, "GCGuard");
 
   /* errors */
@@ -1934,6 +1967,7 @@ void Init_ruby_xnd(void)
   rb_define_method(cXND, "<=>", XND_spaceship, 1);
   rb_define_method(cXND, "strict_equal", XND_strict_equal, 1);
   rb_define_method(cXND, "size", XND_size, 0);
+  rb_define_method(cXND, "short_value", XND_short_value, 1);
 
   /* iterators */
   rb_define_method(cXND, "each", XND_each, 0);

data/ext/ruby_xnd/util.c

@@ -0,0 +1,165 @@
+/* BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Quansight and Sameer Deshmukh
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * 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.
+ *
+ * * 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 "ruby.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+
+void
+raise_error(void)
+{
+  VALUE exeception = rb_errinfo();
+
+  rb_set_errinfo(Qnil);
+  rb_exc_raise(exeception);
+}
+
+void
+set_error_info(VALUE err, const char * msg)
+{
+  rb_set_errinfo(rb_exc_new2(err, msg));
+}
+
+size_t
+safe_downcast(int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    if (size > INT32_MAX) {
+      rb_raise(rb_eSizeError,
+                "sizes should never exceed INT32_MAX on 32-bit platforms.");
+    }
+#endif
+    return (size_t)size;
+}
+
+bool
+check_invariants(const ndt_t *t)
+{
+#if SIZE_MAX < INT64_MAX
+    return safe_downcast(t->datasize) >= 0;
+#else
+    (void)t;
+    return 1;
+#endif
+}
+
+VALUE
+array_new(int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    size_t n = safe_downcast(size);
+    return n < 0 ? NULL : rb_ary_new2(n);
+#else
+    return rb_ary_new2(size);
+#endif
+}
+
+VALUE
+bytes_from_string_and_size(const char *str, int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    size_t n = safe_downcast(size);
+    return n < 0 ? NULL : rb_str_new(str, n);
+#else
+    return rb_str_new(str, size);
+#endif
+}
+
+long long
+mod(long long a, long long b)
+{
+    long long r = a % b;
+    return r < 0 ? r + b : r;
+}
+
+void
+rb_range_unpack(VALUE range, long long *begin, long long *end, long long *step, size_t size)
+{
+  /* FIXME: As of 27 Aug. 2018 Ruby trunk implements step as a property of
+     Range and XND will support it as and when it is available. Maybe for 
+     now we can implement a #step iterator in a separate method.
+  */
+  *step = 1;
+  VALUE rb_begin = rb_funcall(range, rb_intern("begin"), 0, NULL);
+  VALUE rb_end = rb_funcall(range, rb_intern("end"), 0, NULL);
+  int exclude_end = RTEST(rb_funcall(range, rb_intern("exclude_end?"), 0, NULL));
+
+  if (RB_TYPE_P(rb_begin, T_FLOAT)) {
+    double value = RFLOAT_VALUE(rb_begin);
+
+    if (isinf(value)) {
+      *begin = 0;  
+    }
+  }
+  else {
+    long long temp = NUM2LL(rb_begin);
+
+    if (temp < 0) {            /* if negative index map to positive. */
+      temp = mod(temp, (long long)size);
+    }
+
+    *begin = temp;
+  }
+
+  if (RB_TYPE_P(rb_end, T_FLOAT)) {
+    double value = RFLOAT_VALUE(rb_end);
+
+    if (isinf(value)) {
+      *end = INT64_MAX;
+      return;
+    }
+  }
+  else {
+    long long temp = NUM2LL(rb_end);
+
+    if (temp < 0) {              /* if negative index map to ppositive. */
+      temp = mod(temp, (long long)size);
+    }
+
+    *end = temp;
+  }
+
+  /* a[0..0] in Ruby returns the 0th index. 
+     a[0...0] in Ruby returns empty array like a[0:0] in Python.
+     libxnd does not include the last index by default.  
+     */
+  if (!exclude_end) {          
+    *end += 1;
+  }
+}
+
+int
+ndt_exists(void)
+{
+  return RTEST(rb_const_get(rb_cObject, rb_intern("NDT")));
+}