xnd 0.2.0dev6 → 0.2.0dev7

data/ext/ruby_xnd/lib/libxnd.so

@@ -0,0 +1 @@
+ext/ruby_xnd/lib/libxnd.so.0.2.0dev3

data/ext/ruby_xnd/lib/libxnd.so.0

@@ -0,0 +1 @@
+ext/ruby_xnd/lib/libxnd.so.0.2.0dev3

data/ext/ruby_xnd/ruby_xnd.c

@@ -37,6 +37,10 @@
 #include "ruby_xnd_internal.h"
 #include "xnd.h"
 
+#define XND_CHECK_NUMERIC(obj) Check_Type(obj, T_FIXNUM); \
+  Check_Type(obj, T_BIGNUM); Check_Type(obj, T_RATIONAL); \
+  Check_Type(obj, T_RATIONAL);
+
 VALUE cRubyXND;
 VALUE cXND;
 static VALUE cRubyXND_MBlock;
@@ -47,6 +51,8 @@ static VALUE rb_eValueError;
 
 VALUE mRubyXND_GCGuard;
 
+static VALUE seterr(ndt_context_t *ctx);
+
 /****************************************************************************/
 /*                               Error handling                             */
 /****************************************************************************/
@@ -108,6 +114,7 @@ MemoryBlockObject_dfree(void *self)
 {
   MemoryBlockObject *mblock = (MemoryBlockObject*)self;
 
+  rb_xnd_gc_guard_unregister_mblock_type(mblock);
   xnd_del(mblock->xnd);
   mblock->xnd = NULL;
   xfree(mblock);
@@ -159,19 +166,21 @@ mblock_allocate(void)
 
 /* Create empty mblock with no data. */
 static VALUE
-mblock_empty(VALUE type)
+mblock_empty(VALUE type, uint32_t flags)
 {
   NDT_STATIC_CONTEXT(ctx);
   MemoryBlockObject *mblock_p;
+  const ndt_t * ndt_p;
   
   if (!rb_ndtypes_check_type(type)) {
     rb_raise(rb_eArgError, "require NDT object to create mblock in mblock_empty.");
   }
 
   mblock_p = mblock_alloc();
-  mblock_p->xnd = xnd_empty_from_type(
-                                      rb_ndtypes_const_ndt(type),
-                                      XND_OWN_EMBEDDED, &ctx);
+  ndt_p = rb_ndtypes_const_ndt(type);
+  //  ndt_incref(ndt_p);
+  
+  mblock_p->xnd = xnd_empty_from_type(ndt_p, XND_OWN_EMBEDDED|flags, &ctx);
   if (mblock_p->xnd == NULL) {
     rb_raise(rb_eValueError, "cannot create mblock object from given type.");
   }
@@ -299,6 +308,42 @@ get_uint(VALUE data, uint64_t max)
   return x;
 }
 
+static int
+union_tag_and_value_from_tuple(uint8_t *tag, VALUE *value, const ndt_t *t,
+                               VALUE tuple)
+{
+  VALUE name;
+  int64_t i;
+  char *sname;
+  
+  assert(t->tag == Union);
+
+  if (RARRAY_LEN(tuple) != 2) {
+    rb_raise(rb_eValueError,
+             "unions are represented by a tuple (tag, value), where tag is a string.");
+  }
+
+  name = rb_ary_entry(tuple, 0);
+
+  Check_Type(name, T_STRING);
+
+  for (i = 0; i < t->Union.ntags; ++i) {
+    sname = RSTRING_PTR(name);
+    if (strcmp(sname, t->Union.tags[i]) == 0) {
+      break;
+    }
+  }
+
+  if (i == t->Union.ntags) {
+    rb_raise(rb_eValueError, "%s is not a valid tag name.", sname);
+  }
+
+  *tag = (uint8_t)i;
+  *value = rb_ary_entry(tuple, 1);
+
+  return 0;
+}
+
 /* Initialize an mblock object with data. */
 static int
 mblock_init(xnd_t * const x, VALUE data)
@@ -430,6 +475,26 @@ mblock_init(xnd_t * const x, VALUE data)
     return 0;
   }
 
+  case Union : {
+    VALUE tmp;
+    uint8_t tag;
+
+    if (union_tag_and_value_from_tuple(&tag, &tmp, t, data) < 0) {
+      return -1;
+    }
+
+    xnd_clear(x, XND_OWN_EMBEDDED);
+    XND_UNION_TAG(x->ptr) = tag;
+
+    xnd_t next = xnd_union_next(x, &ctx);
+    if (next.ptr == NULL) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    return mblock_init(&next, tmp);
+  }
+
   case Ref: {
     xnd_t next = xnd_ref_next(x, &ctx);
     if (next.ptr == NULL) {
@@ -831,13 +896,13 @@ mblock_init(xnd_t * const x, VALUE data)
  * @param data - Data as a Ruby object.
  */
 static VALUE
-mblock_from_typed_value(VALUE type, VALUE data)
+mblock_from_typed_value(VALUE type, VALUE data, int32_t flags)
 {
   VALUE mblock;
   MemoryBlockObject *mblock_p;
 
-  mblock = mblock_empty(type);
-  GET_MBLOCK(mblock, mblock_p); 
+  mblock = mblock_empty(type, flags);
+  GET_MBLOCK(mblock, mblock_p);
   mblock_init(&mblock_p->xnd->master, data);
 
   return mblock;
@@ -854,6 +919,11 @@ typedef struct XndObject {
 } XndObject;
 
 #define XND(xnd_p) (&(((XndObject *)xnd_p)->xnd))
+#define TYPE_OWNER(xnd_p) ((((XndObject *)xnd_p)->type))
+#define XND_TYPE(xnd_p) (((XndObject *)xnd_p)->xnd.type)
+#define XND_INDEX(xnd_p) (((XndObject *)xnd_p)->xnd.index)
+#define XND_PTR(xnd_p) (((XndObject *)xnd_p)->xnd.ptr)
+
 #define XND_CHECK_TYPE(xnd) (CLASS_OF(xnd) == cXND)
 #define GET_XND(obj, xnd_p) do {                        \
     TypedData_Get_Struct((obj), XndObject,              \
@@ -900,7 +970,8 @@ XndObject_dfree(void *self)
 {
   XndObject *xnd = (XndObject*)self;
 
-  rb_xnd_gc_guard_unregister(xnd);
+  rb_xnd_gc_guard_unregister_xnd_mblock(xnd);
+  rb_xnd_gc_guard_unregister_xnd_type(xnd);
   xfree(xnd);
 }
 
@@ -954,18 +1025,57 @@ RubyXND_allocate(VALUE klass)
   return WRAP_XND(klass, xnd);
 }
 
+static uint32_t
+device_flags(VALUE array)
+{
+  VALUE device, no;
+
+  Check_Type(array, T_ARRAY);
+  if (RARRAY_LEN(array) != 2) {
+    rb_raise(rb_eTypeError, "device argument must be of the form (device_name, device_no).");
+  }
+
+  device = rb_ary_entry(array, 0);
+  Check_Type(device, T_STRING);
+  if (RTEST(rb_funcall(device, rb_intern("=="), 1, rb_str_new_literal("cuda")))) {
+    rb_raise(rb_eValueError, "currently only 'cuda' is supported as a device name.");
+  }
+    
+  no = rb_ary_entry(array, 1);
+  Check_Type(no, T_FIXNUM);
+  if (FIX2NUM(no) != -1) {
+    rb_raise(rb_eValueError, "currently only 'cuda:managed' is supported as a device.");
+  }
+
+  return XND_CUDA_MANAGED;
+}
+
 /* Initialize a RubyXND object. */
 static VALUE
-RubyXND_initialize(VALUE self, VALUE type, VALUE data)
+RubyXND_initialize(VALUE self, VALUE type, VALUE data, VALUE device)
 {
   VALUE mblock;
+  MemoryBlockObject *mblock_p;
   XndObject *xnd_p;
+  uint32_t flags = 0;
 
-  mblock = mblock_from_typed_value(type, data);
-  GET_XND(self, xnd_p);
+  if (device != Qnil) {
+    flags = device_flags(device);
+    if (flags == UINT32_MAX) {
+      rb_raise(rb_eValueError, "device ID cannot be handled.");
+    }
+  }
 
+  mblock = mblock_from_typed_value(type, data, flags);
+  GET_MBLOCK(mblock, mblock_p);
+  
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
+    
+  GET_XND(self, xnd_p);
   XND_from_mblock(xnd_p, mblock);
-  rb_xnd_gc_guard_register(xnd_p, mblock);
+  
+  rb_xnd_gc_guard_register_xnd_mblock(xnd_p, mblock);
+  rb_xnd_gc_guard_register_xnd_type(xnd_p, type);
 
 #ifdef XND_DEBUG
   assert(XND(xnd_p)->type);
@@ -990,6 +1100,16 @@ XND_get_size(VALUE xnd)
 
 /*************************** object properties ********************************/
 
+static VALUE
+XND_dtype(VALUE self)
+{
+  XndObject *self_p;
+  GET_XND(self, self_p);
+  const ndt_t *dtype = ndt_dtype(XND_TYPE(self_p));
+  
+  return rb_ndtypes_from_type(dtype);
+}
+
 /* Return the ndtypes object of this xnd object. */
 static VALUE
 XND_type(VALUE self)
@@ -998,7 +1118,6 @@ XND_type(VALUE self)
 
   GET_XND(self, xnd_p);
 
-
   return xnd_p->type;
 }
 
@@ -1077,6 +1196,25 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
 
     return array;
   }
+
+  case VarDimElem: {
+    int64_t start, step, shape;
+
+    shape = ndt_var_indices(&start, &step, t, x->index, &ctx);
+    if (shape < 0) {
+      seterr(&ctx);
+      raise_error();      
+    }
+
+    const int64_t i = adjust_index(t->VarDimElem.index, shape, &ctx);
+    if (i < 0) {
+      seterr(&ctx);
+      raise_error();      
+    }
+
+    const xnd_t next = xnd_var_dim_next(x, start, step, i);
+    return _XND_value(&next, maxshape);
+  }
     
   case Tuple: {
     VALUE tuple, v;
@@ -1138,6 +1276,27 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
     return hash;
   }
 
+  case Union: {
+    VALUE array, tag, v;
+
+    array = rb_ary_new2(2);
+    const uint8_t i = XND_UNION_TAG(x->ptr);
+    tag = rb_str_new2(t->Union.tags[i]);
+
+    rb_ary_store(array, 0, tag);
+
+    const xnd_t next = xnd_union_next(x, &ctx);
+    if (next.ptr == NULL) {
+      seterr(&ctx);
+      raise_error();
+    }
+    v = _XND_value(&next, maxshape);
+
+    rb_ary_store(array, 1, v);
+
+    return array;
+  }
+
   case Ref: {
     xnd_t next = xnd_ref_next(x, &ctx);
     if (next.ptr == NULL) {
@@ -1309,8 +1468,8 @@ _XND_value(const xnd_t * const x, const int64_t maxshape)
   }
 
   case String: {
-    const char *s = XND_POINTER_DATA(x->ptr);
-    size_t size = s ? strlen(s) : 0;
+    const char *s = XND_STRING_DATA(x->ptr);
+    size_t size = strlen(s);
 
     return rb_utf8_str_new(s, size);
   }
@@ -1403,9 +1562,12 @@ static VALUE
 RubyXND_view_move_type(XndObject *src_p, xnd_t *x)
 {
   XndObject *view_p;
+  MemoryBlockObject* mblock_p;
   VALUE type, view;
 
-  type = rb_ndtypes_move_subtree(src_p->type, (ndt_t *)x->type);
+  type = rb_ndtypes_from_type(x->type);
+  ndt_decref(x->type);
+  
   view = XndObject_alloc();
   GET_XND(view, view_p);
 
@@ -1413,7 +1575,11 @@ RubyXND_view_move_type(XndObject *src_p, xnd_t *x)
   view_p->type = type;
   view_p->xnd = *x;
 
-  rb_xnd_gc_guard_register(view_p, view_p->mblock);
+  GET_MBLOCK(view_p->mblock, mblock_p);
+  
+  rb_xnd_gc_guard_register_xnd_type(view_p, type);
+  rb_xnd_gc_guard_register_xnd_mblock(view_p, view_p->mblock);
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
 
   return view;
 }
@@ -1598,6 +1764,34 @@ XND_spaceship(VALUE self, VALUE other)
   return Qnil;
 }
 
+static VALUE
+XND_lt(VALUE self, VALUE other)
+{
+  rb_raise(rb_eNotImpError, "< not implemented yet.");
+  return Qnil;
+}
+
+static VALUE
+XND_lteq(VALUE self, VALUE other)
+{
+  rb_raise(rb_eNotImpError, "<= not implemented yet.");
+  return Qnil;
+}
+
+static VALUE
+XND_gt(VALUE self, VALUE other)
+{
+  rb_raise(rb_eNotImpError, "> not implemented yet.");
+  return Qnil;
+}
+
+static VALUE
+XND_gteq(VALUE self, VALUE other)
+{
+  rb_raise(rb_eNotImpError, ">= not implemented yet.");
+  return Qnil;
+}
+
 /* XND#strict_equal */
 static VALUE
 XND_strict_equal(VALUE self, VALUE other)
@@ -1662,6 +1856,26 @@ _XND_size(const xnd_t *x)
     return safe_downcast(shape);
   }
 
+  case VarDimElem: {
+    NDT_STATIC_CONTEXT(ctx);
+    int64_t start, step, shape;
+
+    shape = ndt_var_indices(&start, &step, t, x->index, &ctx);
+    if (shape < 0) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    const int64_t i = adjust_index(t->VarDimElem.index, shape, &ctx);
+    if (i < 0) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    const xnd_t next = xnd_var_dim_next(x, start, step, i);
+    return _XND_size(&next);
+  }
+
   case Tuple: {
     return safe_downcast(t->Tuple.shape);
   }
@@ -1670,6 +1884,16 @@ _XND_size(const xnd_t *x)
     return safe_downcast(t->Record.shape);
   }
 
+  case Union: {
+    const xnd_t next = xnd_union_next(x, &ctx);
+    if (next.ptr == NULL) {
+      seterr(&ctx);
+      raise_error();
+    }
+
+    return _XND_size(&next);
+  }
+
   case Ref: {
     const xnd_t next = xnd_ref_next(x, &ctx);
     if (next.ptr == NULL) {
@@ -1743,19 +1967,11 @@ XND_array_store(int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eIndexError, "wrong kind of key in []=");
   }
 
-  if (flags & KEY_SLICE) {
-    x = xnd_multikey(&self_p->xnd, indices, len, &ctx);
-    free_type = 1;
-  }
-  else {
-    x = xnd_subtree(&self_p->xnd, indices, len, &ctx);
-  }
-
+  x = xnd_subscript(&self_p->xnd, indices, len, &ctx);
   if (x.ptr == NULL) {
     seterr(&ctx);
     raise_error();
   }
-
   value = argv[argc-1];
 
   if (XND_CHECK_TYPE(value)) {
@@ -1771,10 +1987,7 @@ XND_array_store(int argc, VALUE *argv, VALUE self)
   else {
     ret = mblock_init(&x, value);
   }
-
-  if (free_type) {
-    ndt_del((ndt_t *)x.type);
-  }
+  ndt_decref(x.type);
 
   return value;
 }
@@ -1807,22 +2020,299 @@ XND_short_value(VALUE self, VALUE maxshape)
   }
 }
 
+/* Implementation of XND#_transpose */
+static VALUE
+XND_transpose(VALUE self, VALUE permute) {
+  NDT_STATIC_CONTEXT(ctx);
+  int p[NDT_MAX_ARGS];
+  const ndt_t *t;
+  xnd_t x;
+  XndObject *self_p;
+
+  GET_XND(self, self_p);
+
+  if (permute != Qnil) {
+    Check_Type(permute, T_ARRAY);
+    const size_t len = RARRAY_LEN(permute);
+
+    if (len > NDT_MAX_ARGS) {
+      rb_raise(rb_eValueError, "permutation list is too long.");
+    }
+
+    for (int i = 0; i < len; i++) {
+      VALUE v_obj = rb_ary_entry(permute, i);
+      Check_Type(v_obj, T_FIXNUM);
+      int v = FIX2INT(v_obj);
+      
+      if (v < 0 || v > INT_MAX) {
+        rb_raise(rb_eValueError, "permutation index is out of bounds.");
+      }
+      p[i] = (int)v;
+    }
+    
+    t = ndt_transpose(XND_TYPE(self_p), p, (int)len, &ctx);
+  }
+  else {
+    t = ndt_transpose(XND_TYPE(self_p), NULL, 0, &ctx);
+  }
+
+  if (t == NULL) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  x = *XND(self_p);
+  x.type = t;
+
+  return RubyXND_view_move_type(self_p, &x);
+}
+
+/* XND#_reshape */
+static VALUE
+XND_reshape(VALUE self, VALUE obj_shape, VALUE order)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  int64_t shape[NDT_MAX_DIM];
+  XndObject *self_p;
+  char ord = 'C';
+  size_t n;
+
+  if (order != Qnil) {
+    const char *c = RSTRING_PTR(order);
+    if (strlen(c) != 1) {
+      rb_raise(rb_eValueError, "'order' argument must be a 'C', 'F' or 'A'.");
+    }
+    ord = c[0];
+  }
+
+  Check_Type(obj_shape, T_ARRAY);
+
+  n = RARRAY_LEN(obj_shape);
+  if (n > NDT_MAX_DIM) {
+    rb_raise(rb_eValueError, "too many dimensions.");
+  }
+
+  for (int i = 0; i < n; ++i) {
+    shape[i] = FIX2INT(rb_ary_entry(obj_shape, i));
+    if (shape[i] < 0) {
+      rb_raise(rb_eValueError, "negative dimension size.");
+    }
+  }
+
+  GET_XND(self, self_p);
+  xnd_t view = xnd_reshape(XND(self_p), shape, (int)n, ord, &ctx);
+  if (xnd_err_occurred(&view)) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  return RubyXND_view_move_type(self_p, &view);  
+}
+
+/* XND#copy_contiguous */
+static VALUE
+XND_copy_contiguous(int argc, VALUE *argv, VALUE self)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  XndObject *self_p, *dest_p;
+  NdtObject *dtype_p;
+  VALUE dtype;
+  VALUE dest;
+  const ndt_t *t;
+  MemoryBlockObject *self_mblock_p;
+
+  if (argc == 1) {
+    dtype = argv[0];
+  }
+  else if (argc == 0) {
+    dtype = Qnil;
+  }
+  else {
+    rb_raise(rb_eArgError, "copy_contiguous can accept only one arg for dtype.");
+  }
+
+  GET_XND(self, self_p);
+
+  if (dtype != Qnil) {
+    if (!rb_ndtypes_check_type(dtype)) {
+      rb_raise(rb_eTypeError, "dtype must be of type ndtypes.");
+    }
+    t = ndt_copy_contiguous_dtype(XND_TYPE(self_p),
+                                  rb_ndtypes_const_ndt(dtype),
+                                  XND_INDEX(self_p), &ctx);
+  }
+  else {
+    t = ndt_copy_contiguous(XND_TYPE(self_p), XND_INDEX(self_p), &ctx);
+  }
+
+  if (t == NULL) {
+    seterr(&ctx);
+  }
+
+  dest = rb_xnd_empty_from_type(t, 0);
+  ndt_decref(t);
+
+  GET_XND(dest, dest_p);
+  GET_MBLOCK(self_p->mblock, self_mblock_p);
+
+  if (xnd_copy(XND(dest_p), XND(self_p), self_mblock_p->xnd->flags, &ctx) < 0) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  return dest;
+}
+
+static VALUE
+XND_serialize(VALUE self)
+{
+  NDT_STATIC_CONTEXT(ctx);
+  bool overflow = false;
+  const xnd_t *x;
+  const ndt_t* t;
+  VALUE result;
+  char *cp, *s;
+  int64_t tlen, size;
+  XndObject *self_p;
+
+  GET_XND(self, self_p);
+  x = XND(self_p);
+  t = XND_TYPE(self_p);
+
+  if (!ndt_is_pointer_free(t)) {
+    rb_raise(rb_eNotImpError, "serializing memory blocks with pointers is not implemented.");
+  }
+
+  if (ndt_is_optional(t) || ndt_subtree_is_optional(t)) {
+    rb_raise(rb_eNotImpError, "serializing bitmaps is not implemented.");
+  }
+
+  if (!ndt_is_c_contiguous(t) && !ndt_is_f_contiguous(t) &&
+      !ndt_is_var_contiguous(t)) {
+    rb_raise(rb_eNotImpError, "serializing non-contiguos memory blocks is not implemented.");
+  }
+
+  tlen = ndt_serialize(&s, t, &ctx);
+  if (tlen < 0) {
+    seterr(&ctx);
+    raise_error();
+  }
+
+  size = ADDi64(t->datasize, tlen, &overflow);
+  size = ADDi64(size, 8, &overflow);
+  if (overflow) {
+    ndt_free(s);
+    /* FIXME: maybe create a new OverflowError for this. */
+    rb_raise(rb_eTypeError, "too large to serialize.");
+  }
+
+  result = rb_str_new(NULL, size);
+  cp = RSTRING_PTR(result);
+
+  char *ptr = x->ptr;
+  if (t->ndim != 0) {
+    ptr = x->ptr + x->index * t->Concrete.FixedDim.itemsize;
+  }
+
+  memcpy(cp, ptr, t->datasize); cp += t->datasize;
+  memcpy(cp, s, tlen); cp += tlen;
+  memcpy(cp, &t->datasize, 8);
+  ndt_free(s);
+
+  return result;
+}
+  
+
 /*************************** Singleton methods ********************************/
 
+
+/* Implement XND.deserialize */
 static VALUE
-XND_s_empty(VALUE klass, VALUE type)
+XND_s_deserialize(VALUE klass, VALUE v)
 {
+  NDT_STATIC_CONTEXT(ctx);
+  VALUE mblock, self;
+  bool overflow = false;
+  int64_t mblock_size;
+  MemoryBlockObject *mblock_p;
   XndObject *self_p;
-  VALUE self, mblock;
+
+  Check_Type(v, T_STRING);
+
+  const int64_t size = RSTRING_LEN(v);
+  if (size < 8) {
+    goto invalid_format;
+  }
+
+  const char *s = RSTRING_PTR(v);
+  memcpy(&mblock_size, s+size-8, 8);
+  if (mblock_size < 0) {
+    goto invalid_format;
+  }
+
+  const int64_t tmp = ADDi64(mblock_size, 8, &overflow);
+  const int64_t tlen = size - tmp;
+  if (overflow || tlen < 0) {
+    goto invalid_format;
+  }
+
+  const ndt_t *t = ndt_deserialize(s+mblock_size, tlen, &ctx);
+  if (t == NULL) {
+    seterr(&ctx);
+  }
+
+  if (t->datasize != mblock_size) {
+    goto invalid_format;
+  }
+
+  VALUE type = rb_ndtypes_from_type(t);
+  ndt_decref(t);
+
+  mblock = mblock_empty(type, XND_OWN_EMBEDDED);
+  GET_MBLOCK(mblock, mblock_p);
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
+  
+  memcpy(mblock_p->xnd->master.ptr, s, mblock_size);
 
   self = XndObject_alloc();
   GET_XND(self, self_p);
+  XND_from_mblock(self_p, mblock);
+    
+  rb_xnd_gc_guard_register_xnd_mblock(self_p, mblock);
+  rb_xnd_gc_guard_register_xnd_type(self_p, type);
+
+  return self;
   
-  type = rb_ndtypes_from_object(type);
-  mblock = mblock_empty(type);
+ invalid_format:
+  rb_raise(rb_eValueError, "invalid format for xnd deserialization.");
+}
+
+static VALUE
+RubyXND_s_empty(VALUE klass, VALUE origin_type, VALUE device)
+{
+  XndObject *self_p;
+  MemoryBlockObject *mblock_p;
+  VALUE self, mblock;
+  VALUE type;
+  VALUE mblock_type, xnd_type;
+  uint32_t flags = 0;
+
+  self = XndObject_alloc();
+  GET_XND(self, self_p);
 
+  if (device != Qnil) {
+    flags = device_flags(device);
+  }
+    
+  type = rb_ndtypes_from_object(origin_type);
+  mblock = mblock_empty(type, flags);
+  
   XND_from_mblock(self_p, mblock);
-  rb_xnd_gc_guard_register(self_p, mblock);
+  GET_MBLOCK(mblock, mblock_p);
+  
+  rb_xnd_gc_guard_register_xnd_mblock(self_p, mblock);
+  rb_xnd_gc_guard_register_xnd_type(self_p, type);
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
 
   return self;
 }
@@ -1842,9 +2332,7 @@ rb_xnd_hash_size(VALUE hash)
 */
 int
 rb_xnd_get_complex_values(VALUE comp, double *real, double *imag)
-{
-  Check_Type(comp, T_COMPLEX);
-  
+{  
   *real = NUM2DBL(rb_funcall(comp, rb_intern("real"), 0, NULL));
   *imag = NUM2DBL(rb_funcall(comp, rb_intern("imag"), 0, NULL));
 
@@ -1873,36 +2361,45 @@ rb_xnd_const_xnd(VALUE xnd)
 VALUE
 rb_xnd_from_xnd(xnd_t *x)
 {
-  VALUE mblock, xnd;
+  VALUE mblock, xnd, type;
   XndObject *xnd_p;
+  MemoryBlockObject *mblock_p;
   
   mblock = mblock_from_xnd(x);
   xnd = XndObject_alloc();
   GET_XND(xnd, xnd_p);
+  GET_MBLOCK(mblock, mblock_p);
+  type = mblock_p->type;
   
   XND_from_mblock(xnd_p, mblock);
-  rb_xnd_gc_guard_register(xnd_p, mblock);
+  
+  rb_xnd_gc_guard_register_xnd_mblock(xnd_p, mblock);
+  rb_xnd_gc_guard_register_xnd_type(xnd_p, type);
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
 
   return xnd;
 }
 
 /* Create an XND object of type ndt_t */
 VALUE
-rb_xnd_empty_from_type(ndt_t *t)
+rb_xnd_empty_from_type(const ndt_t *t, uint32_t flags)
 {
   MemoryBlockObject *mblock_p;
   XndObject *xnd_p;
   VALUE type, mblock, xnd;
 
   type = rb_ndtypes_from_type(t);
-  mblock = mblock_empty(type);
+  mblock = mblock_empty(type, flags);
   xnd = XndObject_alloc();
 
   GET_XND(xnd, xnd_p);
-  rb_xnd_gc_guard_register(xnd_p, mblock);
 
   XND_from_mblock(xnd_p, mblock);
 
+  rb_xnd_gc_guard_register_xnd_mblock(xnd_p, mblock);
+  rb_xnd_gc_guard_register_xnd_type(xnd_p, type);
+  rb_xnd_gc_guard_register_mblock_type(mblock_p, type);
+
   return xnd;
 }
 
@@ -1955,16 +2452,31 @@ void Init_ruby_xnd(void)
   
   /* initializers */
   rb_define_alloc_func(cRubyXND, RubyXND_allocate);
-  rb_define_method(cRubyXND, "initialize", RubyXND_initialize, 2);
+  rb_define_method(cRubyXND, "initialize", RubyXND_initialize, 3);
+
+  /* singleton methods */
+  rb_define_singleton_method(cRubyXND, "empty", RubyXND_s_empty, 2);
+  rb_define_singleton_method(cXND, "deserialize", XND_s_deserialize, 1);
   
   /* instance methods */
   rb_define_method(cXND, "type", XND_type, 0);
+  rb_define_method(cXND, "dtype", XND_dtype, 0);
   rb_define_method(cXND, "value", XND_value, 0);
   rb_define_method(cXND, "[]", XND_array_aref, -1);
   rb_define_method(cXND, "[]=", XND_array_store, -1);
   rb_define_method(cXND, "==", XND_eqeq, 1);
+  rb_define_method(cXND, "serialize", XND_serialize, 0);
+  rb_define_method(cXND, "copy_contiguous", XND_copy_contiguous, -1);
+  rb_define_method(cXND, "_transpose", XND_transpose, 1);
+  rb_define_method(cXND, "_reshape", XND_reshape, 2);
+  
   //  rb_define_method(cXND, "!=", XND_neq, 1);
   rb_define_method(cXND, "<=>", XND_spaceship, 1);
+  rb_define_method(cXND, "<", XND_lt, 1);
+  rb_define_method(cXND, "<=", XND_lteq, 1);
+  rb_define_method(cXND, ">", XND_gt, 1);
+  rb_define_method(cXND, ">=", XND_gteq, 1);
+  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);
@@ -1972,9 +2484,6 @@ void Init_ruby_xnd(void)
   /* iterators */
   rb_define_method(cXND, "each", XND_each, 0);
 
-  /* singleton methods */
-  rb_define_singleton_method(cXND, "empty", XND_s_empty, 1);
-
   /* GC guard */
   rb_xnd_init_gc_guard();