ndtypes 0.2.0dev4

data/ext/ruby_ndtypes/ruby_ndtypes.h

@@ -0,0 +1,37 @@
+/* File containing headers for Ruby ndtypes wrapper. 
+ *
+ * Author: Sameer Deshmukh (@v0dro)
+*/
+
+#ifndef RUBY_NDTYPES_H
+#define RUBY_NDTYPES_H
+
+#if defined(__cplusplus)
+extern "C" {
+} /* satisfy cc-mode */
+#endif
+
+#include "ruby.h"
+#include "ndtypes.h"
+
+/* Public interface for ndtypes. */
+typedef struct NdtObject NdtObject;
+extern VALUE cNDTypes;
+
+int rb_ndtypes_check_type(VALUE obj);
+NdtObject * rb_ndtypes_get_ndt_object(VALUE obj);
+VALUE rb_ndtypes_make_ndt_object(NdtObject *ndt_p);
+VALUE rb_ndtypes_wrap_ndt_object(void);
+const ndt_t * rb_ndtypes_const_ndt(VALUE ndt);
+VALUE rb_ndtypes_move_subtree(VALUE src, ndt_t *t);
+VALUE rb_ndtypes_from_object(VALUE type);
+VALUE rb_ndtypes_set_error(ndt_context_t *ctx);
+VALUE rb_ndtypes_from_type(ndt_t *type);
+
+#define INT2BOOL(t) (t ? Qtrue : Qfalse)
+
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+
+#endif  /* RUBY_NDTYPES_H */

data/ext/ruby_ndtypes/ruby_ndtypes_internal.h

@@ -0,0 +1,28 @@
+/* Various internal macros and function definitions. Not exposed to other Ruby C extensions. */
+/* Author: Sameer Deshmukh (@v0dro) */
+
+#ifndef RUBY_NDTYPES_INTERNAL_H
+#define RUBY_NDTYPES_INTERNAL_H
+
+#include "ruby.h"
+#include "ndtypes.h"
+#include "ruby_ndtypes.h"
+
+extern VALUE mNDTypes_GCGuard;
+
+/* typedefs */
+typedef struct NdtObject NdtObject;
+typedef struct ResourceBufferObject ResourceBufferObject;
+
+/* macros */
+#if SIZEOF_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LONG2NUM((long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#else
+# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
+#endif
+
+#endif  /* RUBY_NDTYPES_INTERNAL_H */

data/lib/ndtypes.rb

@@ -0,0 +1,45 @@
+require 'ndtypes/errors'
+
+begin
+  require "ruby_ndtypes.so"
+rescue LoadError
+  require 'ruby_ndtypes/ruby_ndtypes.so'
+end
+
+class NDTypes
+  # It so happens that over riding the .new method in a super class also
+  # tampers with the default .new method for class that inherit from the
+  # super class (Index in this case). Thus we first alias the original
+  # new method (from Object) to __new__ when the Index class is evaluated,
+  # and then we use an inherited hook such that the old new method (from
+  # Object) is once again the default .new for the subclass.
+  # Refer http://blog.sidu.in/2007/12/rubys-new-as-factory.html
+  class << self
+    alias :__new__ :new
+
+    def inherited subclass
+      class << subclass
+        alias :new :__new__
+      end
+    end
+  end
+  
+  def dup
+    str = self.serialize
+    NDT.deserialize str
+  end
+
+  # We over-ride the .new method so that even sending an NDTypes object can
+  # will allow the .new method to act as copy constructor and simply return
+  # copy of the argument.
+  def self.new *args, &block
+    type = args.first
+
+    return type.dup if type.is_a?(NDTypes)
+
+    allocate.tap { |i| i.send :initialize, *args, &block }
+  end
+end
+
+NDT = NDTypes
+

data/lib/ndtypes/errors.rb

@@ -0,0 +1,2 @@
+# Error thrown for passing wrong value.
+class ValueError < RuntimeError; end

data/lib/ndtypes/version.rb

@@ -0,0 +1,6 @@
+class NDTypes
+  # VERSION number should be the version of libxnd this is built against.
+  VERSION = "0.2.0dev4"
+  # git commit of the version.
+  COMMIT = "7c4cda117f7081d66c8a23bb604b78c01aea1b77"
+end

data/ndtypes.gemspec

@@ -0,0 +1,47 @@
+# coding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'ndtypes/version.rb'
+
+def get_files
+  files = []
+  ['ext', 'lib', 'spec'].each do |folder|
+    files.concat Dir.glob "#{folder}/**/*"
+  end
+
+  files.concat(
+    ["CONTRIBUTING.md", "Gemfile", "History.md", "ndtypes.gemspec",
+     "README.md", "Rakefile"
+    ])
+  
+  files
+end
+files = get_files
+
+NDTypes::DESCRIPTION = <<MSG
+NDtypes is library for defining memory shapes using a easy and friendly interface.
+ 
+It is a wrapper over the libndtypes C library.
+MSG
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ndtypes'
+  spec.version       = NDTypes::VERSION
+  spec.authors       = ['Sameer Deshmukh']
+  spec.email         = ['sameer.deshmukh93@gmail.com']
+  spec.summary       = %q{Ruby wrapper over libndtypes. A library for typing memory blocks.}
+  spec.description   = NDTypes::DESCRIPTION
+  spec.homepage      = "https://github.com/plures/ndtypes"
+  spec.license       = 'BSD-3-Clause'
+
+  spec.files         = files
+  spec.extensions    =  "ext/ruby_ndtypes/extconf.rb"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'rspec', '~> 3.8'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+end

data/spec/gc_table_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "global GC guard table" do
+  it "stores NDT objects as key and corresponding rbuf object as value" do
+    ndt = NDTypes.new("3 * int64")
+
+    gc_table = NDTypes::GCGuard.instance_variable_get(:@__gc_guard_table)
+    expect(gc_table.keys.size).to eq(1)
+  end
+end

data/spec/ndtypes_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+
+describe NDTypes do  
+  context "::MAX_DIM" do
+    it "returns the maximum dimension possible" do
+      expect(NDTypes::MAX_DIM > 0).to eq(true)
+    end
+  end
+
+  context ".typedef" do
+    it "creates a typedef for an official type" do
+      NDTypes.typedef "node", "int32"
+
+      t = NDTypes.new "4 * node"
+      u = NDTypes.deserialize t.serialize
+
+      expect(t).to eq(u)
+    end
+  end
+
+  context ".instantiate" do
+    context "Typedef" do
+      it "instantiates NDTypes object from typedef and type" do
+        NDT.typedef "node", "int32"
+        NDT.typedef "cost", "int32"
+        NDT.typedef "graph", "var * var * (node, cost)"
+
+        t = NDT.new "var(offsets=[0,2]) * var(offsets=[0,3,10]) * (node, cost)"
+        u = NDT.instantiate "graph", t
+        expect(u.concrete?).to eq(true)
+
+        t = NDT.new "var(offsets=[0,2]) * var(offsets=[0,2,3]) * var(offsets=[0,1,2,3]) * (node, cost)"
+        expect {
+          NDT.instantiate("graph", t)
+        }.to raise_error(ValueError)
+      end      
+    end
+  end
+  
+  context ".new" do
+    it "creates a basic shaped memory block" do
+      o = NDTypes.new("3 * uint64")
+
+      expect_serialize o
+    end
+
+    context "tests roundtrip" do
+      [
+        "2 * 3 * float64",
+        "2 * 3 * {a : uint8, b : complex64}",
+      ].each do |s|
+        it "type: #{s}" do
+          t = NDT.new s
+
+          expect(t.to_s).to eq(s)
+        end
+      end
+    end
+
+    context "from NDT" do
+      [
+        "2 * 3 * {a : 10 * bytes, b : 20 * string}",
+        "var(offsets=[0,2]) * var(offsets=[0,3,10]) * complex128"
+      ].each do |s|
+        it "type: #{s}" do
+          t = NDT.new s
+          u = NDT.new t
+
+          expect(u).to eq(t)
+        end
+      end
+
+      it "test with offset" do
+        t = NDT.new "{x: complex128, y: float64}", [[0, 2], [0, 3, 5]]
+        u = NDT.new t
+
+        expect(u).to eq(t)
+      end
+    end
+
+    context "raises errors" do
+      [
+        "", "xyz", "var() * int64"
+      ].each do |t|
+        it "type #{t} raises ValueError" do
+          expect { NDT.new(t) }.to raise_error(ValueError)
+        end
+      end
+
+      it "raises TypeError" do
+        expect { NDT.new(nil) }.to raise_error(TypeError)
+      end
+    end
+
+    context "FixedString" do
+      it "checks predicates" do
+        t = NDT.new "fixed_string(380, 'utf16')"
+
+        expect_serialize t
+
+        expect(t.abstract?).to eq(false)
+        expect(t.complex?).to eq(false)
+        expect(t.concrete?).to eq(true)
+        expect(t.float?).to eq(false)
+        expect(t.optional?).to eq(false)
+        expect(t.scalar?).to eq(true)
+        expect(t.signed?).to eq(false)
+        expect(t.unsigned?).to eq(false)
+
+        expect(t.c_contiguous?).to eq(true)
+        expect(t.f_contiguous?).to eq(true)
+      end
+
+      it "checks fixed string common fields" do
+        [
+          ['ascii', 1],
+          ['utf8', 1],
+          ['utf16', 2],
+          ['utf32', 4]
+        ].each do |encoding, codepoint_size|
+          t = NDT.new "fixed_string(20, '#{encoding}')"
+          
+          expect_serialize t
+          expect(t.ndim).to eq(0)
+
+          if RUBY_PLATFORM != "i686-linux"
+            expect(t.itemsize).to eq(20 * codepoint_size)
+            expect(t.align).to eq(codepoint_size)
+          end
+
+          # raises tests.
+        end
+      end
+    end
+  end
+
+  context "#match" do
+    it "needs to contiguity requirements" do
+      p = NDT.new("... * 2 * 3 * float32")
+      c = NDT.new("2 * 3 * float32")
+
+      expect(p.match(c)).to eq(true)
+    end
+
+    context "C-contiguity required for inner dimensions" do
+      before do
+        @p = NDT.new "... * C[2 * 3 * float32]"
+      end
+
+      it "with C input" do
+        c = NDT.new "2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with inner dimensionss C-contiguous" do
+        c = NDT.new "4 * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with inner dimensions C-contiguous" do
+        c = NDT.new "fixed(shape=4, step=-6) * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with F input" do
+        c = NDT.new "!2 * 3 * float32"
+        expect(@p.match(c)).to eq(false)
+      end
+    end
+
+    context "F-contiguity required for inner dimensions" do
+      before do
+        @p = NDT.new "... * F[2 * 3 * float32]"        
+      end
+
+      it "with F input" do
+        c = NDT.new "fixed(shape=10, step=6) * fixed(shape=2, step=1) * fixed(shape=3, step=2) * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with C input" do
+        c = NDT.new "2 * 3 * float32"
+        expect(@p.match(c))
+      end
+    end
+
+    context "C-contiguity required for all dimensions after broadcast" do
+      before do
+        @p = NDT.new "C[... * 2 * 3 * float32]"
+      end
+
+      it "with C input" do
+        c = NDT.new "2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with all dimensions C-contiguous" do
+        c = NDT.new "4 * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with inner dimensions C-contiguous" do
+        c = NDT.new "fixed(shape=4, step=-6) * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(false)
+      end
+
+      it "with F input" do
+        c = NDT.new "!2 * 3 * float32"
+        expect(@p.match(c)).to eq(false)
+      end
+    end
+
+    context "F-contiguity required for all dimensions after broadcast." do
+      before do
+        @p = NDT.new "F[... * 2 * 3 * float32]"
+      end
+
+      it "with C input" do
+        c = NDT.new "2 * 3 * float32"
+        expect(@p.match(c)).to eq(false)
+
+        c = NDT.new "4 * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(false)
+      end
+
+      it "with F input" do
+        c = NDT.new "!2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with all dimensions F-contiguous" do
+        c = NDT.new "!4 * 2 * 3 * float32"
+        expect(@p.match(c)).to eq(true)
+      end
+
+      it "with inner dimensions C-contiguous" do
+        c = NDT.new "fixed(shape=10, step=6) * fixed(shape=2, step=1) * fixed(shape=3, step=2) * float32"
+        expect(@p.match(c)).to eq(false)
+      end
+    end
+  end
+
+  context "#serialize" do
+    it "serializes the given shape" do
+      s = NDTypes.new "3 * char"
+      s.serialize
+    end
+  end
+
+  context "#to_s" do
+    it "converts to string using ndt_as_string" do
+      t = NDTypes.new "5 * int64"
+
+      expect(t.to_s).to eq("5 * int64")
+    end
+  end
+
+  context "#hidden_dtype" do
+    it "has hidden type" do
+      
+    end
+  end
+
+  context ".deserialize" do
+    it "deserializes the NDT object" do 
+      s = NDTypes.new "3 * char"
+      t = s.serialize
+      u = NDTypes.deserialize t
+      
+      expect(s).to eq(u)
+    end
+  end
+
+  context "#dup" do
+    DTYPE_TEST_CASES.each do |dtype, mem|
+      it "dtype: #{dtype}" do
+        t = NDT.new dtype
+        u = t.dup
+
+        expect(t).to eq(u)
+        expect(t.ast).to eq(u.ast)        
+      end
+    end
+
+    skip "tests GC -- figure how to do this." do
+      
+    end
+  end
+end