ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/setup.py

@@ -42,6 +42,7 @@ from distutils.sysconfig import get_python_lib
 from glob import glob
 import platform
 import subprocess
+import argparse
 import shutil
 
 try:
@@ -81,6 +82,13 @@ Links
 * http://xnd.readthedocs.io/en/latest/
 """
 
+# Pre-parse and remove the '-j' argument from sys.argv.
+parser = argparse.ArgumentParser()
+parser.add_argument('-j', default=None)
+values, rest = parser.parse_known_args()
+PARALLEL = values.j
+sys.argv = sys.argv[:1] + rest
+
 
 if sys.platform == "darwin":
     LIBNAME = "libndtypes.dylib"
@@ -230,10 +238,11 @@ def ndtypes_ext():
             runtime_library_dirs = ["$ORIGIN"]
 
         if BUILD_ALL:
+            make = "make -j%d" % int(PARALLEL) if PARALLEL else "make"
             if WITH_VALGRIND:
-                os.system("./configure --with-valgrind && make")
+                os.system("./configure --with-valgrind && %s" % make)
             else:
-                os.system("./configure && make")
+                os.system("./configure && %s" % make)
 
     return Extension (
       "ndtypes._ndtypes",

data/ext/ruby_ndtypes/ruby_ndtypes.c

@@ -8,7 +8,6 @@
 /* ---------- Interal declarations ---------- */
 /* data_type_t variables. */
 static const rb_data_type_t NdtObject_type;
-static const rb_data_type_t ResourceBufferObject_type;
 
 /* Class declarations. */
 VALUE cNDTypes;
@@ -82,148 +81,14 @@ seterr(ndt_context_t *ctx)
   return exc;
 }
 
-/******************************************************************************/
-/************************* Resource Buffer Object *****************************/
-
-/* A ResourceBufferObject is passed around various NDT objects for storing 
- * internal state. It might or might not be duplicated across other NDT
- * objects.
- */
-typedef struct ResourceBufferObject {
-  ndt_meta_t *m;
-} ResourceBufferObject;
-
-#define GET_RBUF(obj, rbuf_p) do {                              \
-    TypedData_Get_Struct((obj), ResourceBufferObject,           \
-                         &ResourceBufferObject_type, (rbuf_p)); \
-} while (0)
-#define RBUF_NDT_M(rbuf_p) ((ndt_meta_t*)(rbuf_p->m))
-#define MAKE_RBUF(self, rbuf_p) TypedData_Make_Struct(self, ResourceBufferObject, \
-                                                      &ResourceBufferObject_type, rbuf_p)
-#define WRAP_RBUF(self, rbuf_p) TypedData_Wrap_Struct(self,             \
-                                                      &ResourceBufferObject_type, rbuf_p)
-
-/* GC free the ResourceBufferObject struct. */
-static void
-ResourceBufferObject_dfree(void * self)
-{
-  ResourceBufferObject * rbf = (ResourceBufferObject*)self;
-
-  ndt_meta_del(rbf->m);
-  rbf->m = NULL;
-  xfree(rbf);
-}
-
-/* Calculate the size of the object. */
-static size_t
-ResourceBufferObject_dsize(const void *self)
-{
-  return sizeof(ResourceBufferObject);           
-}
-
-static const rb_data_type_t ResourceBufferObject_type = {
-  .wrap_struct_name = "ResourceBufferObject",
-  .function = {
-    .dmark = 0,
-    .dfree = ResourceBufferObject_dfree,
-    .dsize = ResourceBufferObject_dsize,
-    .reserved = {0,0},
-  },
-  .parent = 0,
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-/* FIXME: change this to rbuf_alloc to reflect that its not called by Ruby alloc. */
-static VALUE
-rbuf_allocate(void)
-{
-  NDT_STATIC_CONTEXT(ctx);
-  ResourceBufferObject *self;
-
-  self = ALLOC(ResourceBufferObject);
-
-  self->m = ndt_meta_new(&ctx);
-  if (self->m == NULL) {
-    rb_raise(rb_eNoMemError, "cannot allocate rbuf object.");
-  }
-  
-  return WRAP_RBUF(cNDTypes_RBuf, self);
-}
-
-static int
-rbuf_init_from_offset_list(ResourceBufferObject *rbuf, VALUE list)
-{
-  ndt_meta_t * const m = rbuf->m;
-  VALUE lst;
-
-  Check_Type(list, T_ARRAY);
-
-  const int64_t n = RARRAY_LEN(list);
-  if (n < 1 || n > NDT_MAX_DIM) {
-    rb_raise(rb_eValueError, "number of offset lists must be in [1, %d].",
-             NDT_MAX_DIM);
-  }
-
-  m->ndims = 0;
-  for (int64_t i = n-1; i >= 0; i--) {
-    lst = rb_ary_entry(list, i);
-    if (!RB_TYPE_P(lst, T_ARRAY)) {
-      rb_raise(rb_eTypeError, "expected a list of offset lists.");
-    }
-
-    const int64_t noffsets = RARRAY_LEN(lst);
-    if (noffsets < 2 || noffsets > INT32_MAX) {
-      rb_raise(rb_eValueError, "length of a single offset must be in [2, INT32_MAX].");
-    }
-
-    int32_t * const offsets = ndt_alloc(noffsets, sizeof(int32_t));
-    if (offsets == NULL) {
-      rb_raise(rb_eNoMemError, "could not allocate offsets.");
-    }
-
-    for (int32_t k = 0; k < noffsets; k++) {
-      long long x = NUM2LL(rb_ary_entry(lst, k));
-      if (x == -1 || x < 0 || x > INT32_MAX) {
-        ndt_free(offsets);
-        rb_raise(rb_eValueError, "offset must be in [0, INT32_MAX].");
-      }
-
-      offsets[k] = (int32_t)x;
-    }
-
-    m->noffsets[m->ndims] = (int32_t)noffsets;
-    m->offsets[m->ndims] = offsets;
-    m->ndims++;
-  }
-
-  return 0;
-}
-
-static VALUE
-rbuf_from_offset_lists(VALUE list)
-{
-  VALUE rbuf;
-  ResourceBufferObject * rbuf_p;
-
-  rbuf = rbuf_allocate();
-  GET_RBUF(rbuf, rbuf_p);
-  rbuf_init_from_offset_list(rbuf_p, list);
-
-  return rbuf;
-}
-
-/******************************************************************************/
-
 /******************************************************************************/
 /************************* NDT struct object **********************************/
 
 typedef struct NdtObject {
-  VALUE rbuf;                  /* resource buffer */
-  ndt_t *ndt;                   /* type */
+  const ndt_t *ndt;                   /* type */
 } NdtObject;
 
 #define NDT(v) (((NdtObject *)v)->ndt)
-#define RBUF(v) (((NdtObject *)v)->rbuf)
 #define GET_NDT(obj, ndt_p) do {                        \
     TypedData_Get_Struct((obj), NdtObject,              \
                          &NdtObject_type, (ndt_p));     \
@@ -232,20 +97,6 @@ typedef struct NdtObject {
                                                     &NdtObject_type, ndt_p)
 #define WRAP_NDT(self, ndt_p) TypedData_Wrap_Struct(self, &NdtObject_type, ndt_p)
 #define NDT_CHECK_TYPE(obj) (CLASS_OF(obj) == cNDTypes)
-
-/* Get the metatdata of the ResourceBufferObject within this NDT Ruby object. */
-static ndt_meta_t *
-rbuf_ndt_meta(VALUE ndt)
-{
-  NdtObject *ndt_p;
-  ResourceBufferObject *rbuf_p;
-  
-  GET_NDT(ndt, ndt_p);
-  GET_RBUF(ndt_p->rbuf, rbuf_p);
-
-  return rbuf_p->m;
-}
-
 /* Allocate an NdtObject, initialize members and return wrapped as a Ruby object. */
 static VALUE
 NdtObject_alloc(void)
@@ -253,8 +104,6 @@ NdtObject_alloc(void)
   NdtObject *ndt_p;
 
   ndt_p = ZALLOC(NdtObject);
-
-  ndt_p->rbuf = 0;
   ndt_p->ndt = NULL;
 
   return WRAP_NDT(cNDTypes, ndt_p);
@@ -263,20 +112,13 @@ NdtObject_alloc(void)
 /* GC mark the NdtObject struct. */
 /* TODO: verify that there are no more object allocations happening inside ndt. */
 static void
-NdtObject_dmark(void * self)
-{
-  NdtObject * ndt = (NdtObject*)self;
-  
-  rb_gc_mark(ndt->rbuf);
-}
+NdtObject_dmark(void * self) {}
 
 /* GC free the NdtObject struct. */
 static void
 NdtObject_dfree(void * self)
 {
   NdtObject * ndt = (NdtObject*)self;
-  
-  rb_ndtypes_gc_guard_unregister(ndt);
   xfree(ndt);
 }
 
@@ -333,13 +175,81 @@ NDTYPES_BOOL_FUNC(ndt_is_complex)
 
 NDTYPES_BOOL_FUNC(ndt_is_c_contiguous)
 NDTYPES_BOOL_FUNC(ndt_is_f_contiguous)
+NDTYPES_BOOL_FUNC(ndt_is_var_contiguous)
+
+static int
+offsets_from_array(ndt_meta_t *m, VALUE array)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  VALUE temp;
+
+  Check_Type(array, T_ARRAY);
+
+  const int n = RARRAY_LEN(array);
+  if (n < 1 || n > NDT_MAX_DIM) {
+    rb_raise(rb_eValueError, "number of offsets arrays must be in [1, %d].", NDT_MAX_DIM);
+  }
+
+  m->ndims = 0;
+  for (int i = n-1; i >= 0; i--) {
+    temp = rb_ary_entry(array, i);
+    if (!RB_TYPE_P(temp, T_ARRAY)) {
+      rb_raise(rb_eValueError, "expected a list of offset lists.");
+    }
+
+    const int64_t noffsets = RARRAY_LEN(temp);
+    if (noffsets < 2 || noffsets > INT32_MAX) {
+      rb_raise(rb_eValueError, "length of a single offset list be in [2, INT32_MAX].");
+    }
+
+    int32_t * const offsets = ndt_alloc(noffsets, sizeof(int32_t));
+    if (offsets == NULL) {
+      rb_raise(rb_eNoMemError, "no memory to allocate offsets.");
+    }
+
+    for (int32_t k = 0; k < noffsets; k++) {
+      long long x = NUM2LL(rb_ary_entry(temp, k));
+
+      if (x < 0 || x > INT32_MAX) {
+        ndt_free(offsets);
+        rb_raise(rb_eValueError, "offset must be in [0, INT32_MAX].");        
+      }
+      offsets[k] = (int32_t)x;
+    }
+
+    m->offsets[m->ndims] = ndt_offsets_from_ptr(offsets, (int32_t)noffsets, &ctx);
+    if (m->offsets[m->ndims] == NULL) {
+      seterr(&ctx);
+      raise_error();
+    }
+    m->ndims++;
+  }
+
+  return 0;
+}
+
+static VALUE
+array_from_int64(int64_t x[NDT_MAX_DIM], int ndim)
+{
+  VALUE array;
+  int i;
+
+  array = rb_ary_new2(ndim);
+
+  for (i = 0; i < ndim; ++i) {
+    VALUE v = LL2NUM(x[i]);
+    rb_ary_store(array, i, v);
+  }
+
+  return array;
+}
 
 static VALUE
 NDTypes_from_object(VALUE self, VALUE type)
 {
   NDT_STATIC_CONTEXT(ctx);
   const char *cp;
-  NdtObject *ndt_p;
+  NdtObject *self_p;
 
   if (NDT_CHECK_TYPE(type)) {
     return rb_funcall(type, rb_intern("dup"), 0, NULL);
@@ -347,16 +257,10 @@ NDTypes_from_object(VALUE self, VALUE type)
 
   cp = StringValuePtr(type);
 
-  GET_NDT(self, ndt_p);
-  RBUF(ndt_p) = rbuf_allocate();
-  if (RBUF(ndt_p) == NULL) {
-    rb_raise(rb_eNoMemError, "problem in allocating RBUF object.");
-  }
-  
-  rb_ndtypes_gc_guard_register(ndt_p, RBUF(ndt_p));
+  GET_NDT(self, self_p);
 
-  NDT(ndt_p) = ndt_from_string_fill_meta(rbuf_ndt_meta(self), cp, &ctx);
-  if (NDT(ndt_p) == NULL) {
+  NDT(self_p) = ndt_from_string(cp, &ctx);
+  if (NDT(self_p) == NULL) {
     seterr(&ctx);
     raise_error();
   }
@@ -365,23 +269,33 @@ NDTypes_from_object(VALUE self, VALUE type)
 }
 
 static VALUE
-NDTypes_from_offsets_and_dtype(VALUE offsets, VALUE type)
+NDTypes_from_offsets_and_dtype(VALUE self, VALUE offsets, VALUE type)
 {
   NDT_STATIC_CONTEXT(ctx);
-  VALUE self;
   NdtObject *self_p;
+  ndt_meta_t m = {.ndims = 0, .offsets = {NULL}};
   const char *cp;
 
   Check_Type(type, T_STRING);
+  Check_Type(offsets, T_ARRAY);
 
   cp = StringValuePtr(type);
 
-  self = NdtObject_alloc();
   GET_NDT(self, self_p);
-  RBUF(self_p) = rbuf_from_offset_lists(offsets);
-  NDT(self_p) = ndt_from_metadata_and_dtype(rbuf_ndt_meta(self_p), cp, &ctx);
 
-  rb_ndtypes_gc_guard_register(self_p, RBUF(self_p));
+  if (offsets_from_array(&m, offsets) < 0) {
+    ndt_meta_clear(&m);
+    seterr(&ctx);
+    raise_error();
+  }
+
+  NDT(self_p) = ndt_from_metadata_and_dtype(&m, cp, &ctx);
+  ndt_meta_clear(&m);
+
+  if (NDT(self_p) == NULL) {
+    seterr(&ctx);
+    raise_error();
+  }
 
   return self;
 }
@@ -407,7 +321,7 @@ NDTypes_initialize(int argc, VALUE *argv, VALUE self)
     return NDTypes_from_object(self, type);
   }
 
-  return NDTypes_from_offsets_and_dtype(offsets, type);
+  return NDTypes_from_offsets_and_dtype(self, offsets, type);
 }
 
 /* String representation of the type. */
@@ -436,15 +350,15 @@ NDTypes_to_s(VALUE self)
 static VALUE
 NDTypes_serialize(VALUE self)
 {
-  NdtObject *ndt;
+  NdtObject *self_p;
   char *bytes;
   int64_t size;
   VALUE str;
   
   NDT_STATIC_CONTEXT(ctx);
-  GET_NDT(self, ndt);
+  GET_NDT(self, self_p);
 
-  size = ndt_serialize(&bytes, NDT(ndt), &ctx);
+  size = ndt_serialize(&bytes, NDT(self_p), &ctx);
   if (size < 0) {
     seterr(&ctx);
     raise_error();
@@ -467,7 +381,7 @@ NDTypes_ndim(VALUE self)
   const ndt_t *t = NDT(ndt_p);
 
   if (ndt_is_abstract(t)) {
-    rb_raise(rb_eTypeError, "abstract type has no ndim.");
+    rb_raise(rb_eNoMethodError, "abstract type has no ndim.");
   }
 
   return LL2NUM(t->ndim);
@@ -502,7 +416,7 @@ NDTypes_itemsize(VALUE self)
   const ndt_t *t = NDT(ndt_p);
 
   if (ndt_is_abstract(t)) {
-    rb_raise(rb_eTypeError, "abstract type has no datasize.");
+    rb_raise(rb_eNoMethodError, "abstract type has no datasize.");
   }
 
   switch (t->tag) {
@@ -531,7 +445,7 @@ NDTypes_align(VALUE self)
   const ndt_t *t = NDT(ndt_p);
 
   if (ndt_is_abstract(t)) {
-    rb_raise(rb_eTypeError, "abstract type has no datasize.");
+    rb_raise(rb_eNoMethodError, "abstract type has no datasize.");
   }
 
   return LL2NUM(t->align);
@@ -631,6 +545,7 @@ NDTypes_match(VALUE self, VALUE other)
   return INT2BOOL(res);
 }
 
+/* Implemented NDT#ast */
 static VALUE
 NDTypes_ast(VALUE self)
 {
@@ -675,47 +590,241 @@ NDTypes_pretty(VALUE self)
   return result;
 }
 
-/****************************************************************************/
-/*                                  Class methods                           */
-/****************************************************************************/
+/* NDT#shape */
+static VALUE
+NDTypes_shape(VALUE self)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  ndt_ndarray_t x;
+  NdtObject *self_p;
+
+  GET_NDT(self, self_p);
+
+  if (ndt_as_ndarray(&x, NDT(self_p), &ctx) < 0) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  return array_from_int64(x.shape, x.ndim);
+}
 
-/* Deserialize a byte string into an NDTypes object. */
 static VALUE
-NDTypes_s_deserialize(VALUE klass, VALUE str)
+NDTypes_strides(VALUE self)
 {
-  NdtObject *ndt_p;
-  ResourceBufferObject *rbuf_p;
-  VALUE ndt, rbuf;
-  char *cp;
-  int64_t len;
   NDT_STATIC_CONTEXT(ctx);
+  ndt_ndarray_t x;
+  NdtObject *self_p;
 
-  Check_Type(str, T_STRING);
+  GET_NDT(self, self_p);
 
-  cp = StringValuePtr(str);
-  if (cp == NULL) {
-    // raise
+  if (ndt_as_ndarray(&x, NDT(self_p), &ctx) < 0) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  return array_from_int64(x.strides, x.ndim);  
+}
+
+static int
+parse_apply_args(const ndt_t* types[NDT_MAX_ARGS], int *num_intypes, int *num_outtypes,
+                 int *num_args, VALUE input_types, VALUE out_types) {
+  size_t nin, nout;
+  if (RARRAY_LEN(input_types) == 0) {
+    rb_raise(rb_eArgError, "must specify more than 0 input types.");
+  }
+
+  nin  = RARRAY_LEN(input_types);
+  if (nin > NDT_MAX_ARGS) {
+    rb_raise(rb_eArgError, "maximum number of arguments cannot exceed %d, got %d.",
+             NDT_MAX_ARGS, nin);
+  }
+
+  for (int i = 0; i < nin; ++i) {
+    VALUE v = rb_ary_entry(input_types, i);
+    NdtObject *v_p;
+    
+    if (!NDT_CHECK_TYPE(v)) {
+      rb_raise(rb_eArgError, "every argument must be of type NDT.");
+    }
+
+    GET_NDT(v, v_p);
+    types[i] = NDT(v_p);
   }
-  len = RSTRING_LEN(str);
 
-  rbuf_p = ALLOC(ResourceBufferObject);
-  rbuf_p->m = ndt_meta_new(&ctx);
-  if (rbuf_p->m == NULL) {
-    /* TODO: cannot alloc meta data */
+  if (out_types == Qnil) {
+    nout = 0;
+  }
+  else {
+    if (NDT_CHECK_TYPE(out_types)) {
+      NdtObject *out_p;
+      nout = 1;
+      if (nin + nout > NDT_MAX_ARGS) {
+        rb_raise(rb_eTypeError, "max number of args is %d, got %d.", NDT_MAX_ARGS, nin+nout);
+      }
+      GET_NDT(out_types, out_p);
+      types[nin] = NDT(out_p);
+    }
+    else if (TYPE(out_types) == T_ARRAY) {
+      nout = RARRAY_LEN(out_types);
+      if (nout > NDT_MAX_ARGS || nin+nout > NDT_MAX_ARGS) {
+        rb_raise(rb_eTypeError, "max number of args is %d, got %d.", NDT_MAX_ARGS, nin+nout);
+      }
+
+      for (int i = 0; i < nout; ++i) {
+        NdtObject *v_p;
+        VALUE v = rb_ary_entry(out_types, i);
+        if (!NDT_CHECK_TYPE(v)) {
+          rb_raise(rb_eTypeError, "expected NDT arguments for all out types.");
+        }
+        GET_NDT(v, v_p);
+        types[nin+i] = NDT(v_p);
+      }
+    }
+    else {
+      rb_raise(rb_eTypeError, "'out' argument must be ndt or a tuple of ndt.");
+    }
   }
 
-  ndt_p = ALLOC(NdtObject);
-  NDT(ndt_p) = ndt_deserialize(RBUF_NDT_M(rbuf_p), cp, len, &ctx);
-  if (NDT(ndt_p) == NULL) {
-    /* TODO: raise error for cannot deserialize */
+  for (int i = 0; i < nin+nout; ++i) {
+    ndt_incref(types[i]);
   }
 
-  rbuf = WRAP_RBUF(cNDTypes_RBuf, rbuf_p);
-  RBUF(ndt_p) = rbuf;
-  rb_ndtypes_gc_guard_register(ndt_p, rbuf);
-  ndt = WRAP_NDT(cNDTypes, ndt_p);
+  *num_intypes = (int)nin;
+  *num_outtypes = (int)nout;
+  *num_args = (int)nin + (int)nout;
+
+  return 0;
+
+}
+
+static VALUE
+NDTypes_apply(VALUE self, VALUE input_types, VALUE out_types)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  const ndt_t *types[NDT_MAX_ARGS] = {NULL};
+  const int64_t li[NDT_MAX_ARGS] = {0};
+  ndt_apply_spec_t spec = ndt_apply_spec_empty;
+  VALUE res, flags, outer_dims, nin, nout, nargs, lst;
+  int ret;
+  int num_intypes, num_outtypes, num_args;
+  NdtObject *self_p;
+
+  Check_Type(input_types, T_ARRAY);
+
+  parse_apply_args(types, &num_intypes, &num_outtypes, &num_args, input_types, out_types);
+  GET_NDT(self, self_p);
+  const ndt_t * sig = NDT(self_p);
+  ret = ndt_typecheck(&spec, sig, types, li, num_intypes, num_outtypes, false,
+                      NULL, NULL, &ctx);
+  ndt_type_array_clear(types, num_args);
   
-  return ndt;
+  if (ret < 0) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  flags = rb_str_new2(ndt_apply_flags_as_string(&spec));
+  lst = rb_ary_new2(spec.nargs);
+
+  for (int i = 0; i < spec.nargs; ++i) {
+    VALUE x = NdtObject_alloc();
+    NdtObject *x_p;
+    GET_NDT(x, x_p);
+
+    NDT(x_p) = spec.types[i];
+    rb_ary_store(lst, i, x);
+  }
+
+  outer_dims = LL2NUM(spec.outer_dims);
+  nin = LL2NUM(spec.nin);
+  nout = LL2NUM(spec.nout);
+  nargs = LL2NUM(spec.nargs);
+
+  return rb_funcall(rb_const_get(cNDTypes, rb_intern("ApplySpec")), rb_intern("new"),
+                    6, flags, outer_dims, nin, nout, nargs, lst);
+}
+
+static const ndt_t *
+from_string(VALUE v)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  const char *cp;
+  const ndt_t *t;
+
+  Check_Type(v, T_STRING);
+
+  cp = RSTRING_PTR(v);
+  t = ndt_from_string(cp, &ctx);
+  if (t == NULL) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  return t;
+}
+
+/* Implement NDT#_at */
+static VALUE
+NDTypes_at(VALUE self, VALUE obj_n, VALUE dtype)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  int n = FIX2INT(obj_n);
+  VALUE res;
+  const ndt_t *t, *dt;
+  NdtObject *dtype_p, *self_p;
+
+  if (dtype == Qnil) {
+    dt = NULL;
+  }
+  else if (NDT_CHECK_TYPE(dtype)) {
+    GET_NDT(dtype, dtype_p);
+    dt = NDT(dtype_p);
+    ndt_incref(dt);
+  }
+  else if (TYPE(dtype) == T_STRING) {
+    dt = from_string(dtype);
+  }
+  else {
+    rb_raise(rb_eTypeError, "dtype argument must be 'ndt' or 'str'");
+  }
+
+  GET_NDT(self, self_p);
+  t = ndt_copy_contiguous_at(NDT(self_p), n, dt, &ctx);
+
+  if (dt != NULL) {
+    ndt_decref(dt);
+  }
+  if (t == NULL) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  res = rb_ndtypes_from_type(t);
+  ndt_decref(t);
+
+  return res;
+}
+
+/****************************************************************************/
+/*                                  Class methods                           */
+/****************************************************************************/
+
+/* Deserialize a byte string into an NDTypes object. */
+static VALUE
+NDTypes_s_deserialize(VALUE klass, VALUE str)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  VALUE self;
+  NdtObject *self_p;
+    
+  Check_Type(str, T_STRING);
+
+  self = NdtObject_alloc();
+  GET_NDT(self, self_p);
+
+  NDT(self_p) = ndt_deserialize(RSTRING_PTR(str), RSTRING_LEN(str), &ctx);
+  
+  return self;
 }
 
 /* Create a typedef */
@@ -730,22 +839,17 @@ NDTypes_s_typedef(VALUE klass, VALUE new_type, VALUE old_type)
   Check_Type(old_type, T_STRING);
 
   cname = StringValueCStr(new_type);
-  if (cname == NULL) {
-    
-  }
-
   ctype = StringValueCStr(old_type);
-  if (ctype == NULL) {
-    
-  }
 
   t = ndt_from_string(ctype, &ctx);
   if (t == NULL) {
-    
+    seterr(&ctx);
+    raise_error();
   }
 
   if (ndt_typedef(cname, t, NULL, &ctx) < 0) {
-    
+    seterr(&ctx);
+    raise_error();    
   }
 
   return Qnil;
@@ -757,7 +861,7 @@ NDTypes_s_instantiate(VALUE klass, VALUE name, VALUE type)
 {
   const char *cname;
   char *cp;
-  ndt_t *t, *tp;
+  const ndt_t *t;//, *tp;
   NdtObject *type_p;
   NDT_STATIC_CONTEXT(ctx);
 
@@ -777,29 +881,53 @@ NDTypes_s_instantiate(VALUE klass, VALUE name, VALUE type)
 
   GET_NDT(type, type_p);
 
-  tp = ndt_copy(NDT(type_p), &ctx);
-  if (tp == NULL) {
-    ndt_free(cp);
+  t = ndt_nominal(cp, NDT(type_p), false, &ctx);
+  if (t == NULL) {
     seterr(&ctx);
     raise_error();
   }
 
-  t = ndt_nominal(cp, tp, &ctx);
-  if (t == NULL) {
+  VALUE ret = rb_ndtypes_from_type(t);
+  ndt_decref(t);
+
+  return ret;
+}
+
+static VALUE
+NDTypes_s_from_format(VALUE klass, VALUE format)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  VALUE self;
+  NdtObject *self_p;
+  const char *cp;
+
+  Check_Type(format, T_STRING);
+
+  cp = StringValueCStr(format);
+  self = NdtObject_alloc();
+  
+  GET_NDT(self, self_p);
+  
+  NDT(self_p) = ndt_from_bpformat(cp, &ctx);
+  if (NDT(self_p) == NULL) {
     seterr(&ctx);
     raise_error();
   }
 
-  return rb_ndtypes_move_subtree(type, t);
+  return self;
 }
 
+
 /****************************************************************************/
 /*                                 Public C API                               */
 /****************************************************************************/
 
 /* Create NDT object from ndt_t type struct. */
+/* Increments the refcnt of the NDT so can be thought of as making
+ * a copy of the object.
+ */
 VALUE
-rb_ndtypes_from_type(ndt_t *type)
+rb_ndtypes_from_type(const ndt_t *type)
 {
   VALUE self;
   NdtObject *self_p;
@@ -807,6 +935,7 @@ rb_ndtypes_from_type(ndt_t *type)
   self = NdtObject_alloc();
   GET_NDT(self, self_p);
 
+  ndt_incref(type);
   NDT(self_p) = type;
 
   return self;
@@ -889,11 +1018,6 @@ rb_ndtypes_move_subtree(VALUE src, ndt_t *t)
     rb_raise(rb_eNoMemError, "could not allocate memory for ndt_copy().");
   }
 
-  GET_NDT(src, src_p);
-  RBUF(dest_p) = RBUF(src_p);
-
-  rb_ndtypes_gc_guard_register(dest_p, RBUF(dest_p));
-
   return dest;
 }
 
@@ -924,16 +1048,12 @@ rb_ndtypes_from_object(VALUE type)
 
   copy = NdtObject_alloc();
   GET_NDT(copy, copy_p);
+  NDT(copy_p) = ndt_from_string(cp, &ctx);
 
-  RBUF(copy_p) = rbuf_allocate();
-  NDT(copy_p) = ndt_from_string_fill_meta(
-                                          rbuf_ndt_meta(copy),
-                                          cp, &ctx);
   if (NDT(copy_p) == NULL) {
     seterr(&ctx);
     raise_error();
   }
-  rb_ndtypes_gc_guard_register(copy_p, RBUF(copy_p));
 
   return copy;
 }
@@ -974,6 +1094,10 @@ void Init_ruby_ndtypes(void)
   rb_define_method(cNDTypes, "match", NDTypes_match, 1);
   rb_define_method(cNDTypes, "ast", NDTypes_ast, 0);
   rb_define_method(cNDTypes, "pretty", NDTypes_pretty, 0);
+  rb_define_method(cNDTypes, "shape", NDTypes_shape, 0);
+  rb_define_method(cNDTypes, "strides", NDTypes_strides, 0);
+  rb_define_method(cNDTypes, "_apply", NDTypes_apply, 2);
+  rb_define_method(cNDTypes, "_at", NDTypes_at, 2);
 
   /* Boolean functions */
   rb_define_method(cNDTypes, "concrete?", NDTypes_ndt_is_concrete, 0);
@@ -986,6 +1110,7 @@ void Init_ruby_ndtypes(void)
   rb_define_method(cNDTypes, "complex?", NDTypes_ndt_is_complex, 0);
   rb_define_method(cNDTypes, "c_contiguous?", NDTypes_ndt_is_c_contiguous, 0);
   rb_define_method(cNDTypes, "f_contiguous?", NDTypes_ndt_is_f_contiguous, 0);
+  rb_define_method(cNDTypes, "var_contiguous?", NDTypes_ndt_is_var_contiguous, 0);
   rb_define_method(cNDTypes, "==", NDTypes_eqeq, 1);
   rb_define_method(cNDTypes, "!=", NDTypes_neq, 1);
 
@@ -993,11 +1118,9 @@ void Init_ruby_ndtypes(void)
   rb_define_singleton_method(cNDTypes, "deserialize", NDTypes_s_deserialize, 1);
   rb_define_singleton_method(cNDTypes, "typedef", NDTypes_s_typedef, 2);
   rb_define_singleton_method(cNDTypes, "instantiate", NDTypes_s_instantiate, 2);
+  rb_define_singleton_method(cNDTypes, "from_format", NDTypes_s_from_format, 1);
 
   /* Constants */
   rb_define_const(cNDTypes, "MAX_DIM", INT2NUM(NDT_MAX_DIM));
-
-  /* GC guard init */
-  rb_ndtypes_init_gc_guard();
 }