numo-narray 0.9.0.1-x64-mingw32 → 0.9.0.3-x64-mingw32

data/ext/numo/narray/math.c

@@ -1,7 +1,7 @@
 /*
   math.c
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2011 by Masahiro TANAKA
+    (C) Copyright 1999-2016 by Masahiro TANAKA
 
   This program is free software.
   You can distribute/modify this program
@@ -13,6 +13,7 @@
 
 VALUE numo_mNMath;
 EXTERN VALUE numo_mDFloatMath, numo_mDComplexMath;
+EXTERN VALUE numo_mSFloatMath, numo_mSComplexMath;
 static ID id_send;
 
 VALUE
@@ -130,8 +131,12 @@ Init_nary_math()
     rb_hash_aset(hCast, numo_cDFloat,   numo_mDFloatMath);
     rb_hash_aset(hCast, numo_cDFloat,   numo_mDFloatMath);
     rb_hash_aset(hCast, numo_cDComplex, numo_mDComplexMath);
+    rb_hash_aset(hCast, numo_cSFloat,   numo_mSFloatMath);
+    rb_hash_aset(hCast, numo_cSComplex, numo_mSComplexMath);
+#ifdef HAVE_RB_CFIXNUM
     rb_hash_aset(hCast, rb_cFixnum,  rb_mMath);
     rb_hash_aset(hCast, rb_cBignum,  rb_mMath);
+#endif
     rb_hash_aset(hCast, rb_cInteger, rb_mMath);
     rb_hash_aset(hCast, rb_cFloat,   rb_mMath);
     rb_hash_aset(hCast, rb_cComplex, numo_mDComplexMath);

data/ext/numo/narray/narray.c

@@ -11,7 +11,6 @@
 #define NARRAY_C
 #include <ruby.h>
 #include "numo/narray.h"
-#include "extconf.h"
 #include <assert.h>
 
 /* global variables within this module */
@@ -40,6 +39,9 @@ VALUE na_cStep;
 VALUE rb_cComplex;
 #endif
 
+int numo_na_inspect_rows=20;
+int numo_na_inspect_cols=80;
+
 void Init_nary_data();
 void Init_nary_step();
 void Init_nary_index();
@@ -116,7 +118,7 @@ rb_narray_debug_info(VALUE self)
     GetNArray(self,na);
 
     printf("%s:\n",rb_class2name(CLASS_OF(self)));
-    printf("  id     = 0x%"SZF"x\n", self);
+    printf("  id     = 0x%"PRI_VALUE_PREFIX"x\n", self);
     printf("  type   = %d\n", na->type);
     printf("  flag   = [%d,%d]\n", na->flag[0], na->flag[1]);
     printf("  size   = %"SZF"d\n", na->size);
@@ -226,6 +228,7 @@ void
 na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape)
 {
     size_t    i, n, c, s;
+    ssize_t   x;
     VALUE     v;
     narray_t *na;
     int       flag = 0;
@@ -245,13 +248,11 @@ na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape)
     }
     for (i=0; i<n; i++) {
         v = RARRAY_AREF(ary,i);
-        if (!FIXNUM_P(v) && !rb_obj_is_kind_of(v, rb_cInteger)) {
-            rb_raise(rb_eTypeError, "array size must be Integer");
-        }
-        if (RTEST(rb_funcall(v, rb_intern("<"), 1, INT2FIX(0)))) {
+        x = NUM2SSIZET(v);
+        if (x < 0) {
             rb_raise(rb_eArgError,"size must be non-negative");
         }
-        shape[c] = NUM2SIZE(v);
+        shape[c] = x;
         c += s;
     }
 }
@@ -334,13 +335,13 @@ na_initialize(VALUE self, VALUE args)
     } else {
         v = args;
     }
-        ndim = RARRAY_LEN(v);
-        if (ndim > NA_MAX_DIMENSION) {
-            rb_raise(rb_eArgError,"ndim=%d exceeds maximum dimension",ndim);
-        }
-        shape = ALLOCA_N(size_t, ndim);
-        // setup size_t shape[] from VALUE shape argument
-        na_array_to_internal_shape(self, v, shape);
+    ndim = RARRAY_LEN(v);
+    if (ndim > NA_MAX_DIMENSION) {
+        rb_raise(rb_eArgError,"ndim=%d exceeds maximum dimension",ndim);
+    }
+    shape = ALLOCA_N(size_t, ndim);
+    // setup size_t shape[] from VALUE shape argument
+    na_array_to_internal_shape(self, v, shape);
     na_setup(self, ndim, shape);
 
     return self;
@@ -405,7 +406,7 @@ na_initialize_copy(VALUE self, VALUE orig)
  *     [0, 0, 0, 0, 0]]
  */
 static VALUE
-na_s_zeros(int argc, const VALUE *argv, VALUE klass)
+na_s_zeros(int argc, VALUE *argv, VALUE klass)
 {
     VALUE obj;
     obj = rb_class_new_instance(argc, argv, klass);
@@ -429,7 +430,7 @@ na_s_zeros(int argc, const VALUE *argv, VALUE klass)
  *     [1, 1, 1, 1, 1]]
  */
 static VALUE
-na_s_ones(int argc, const VALUE *argv, VALUE klass)
+na_s_ones(int argc, VALUE *argv, VALUE klass)
 {
     VALUE obj;
     obj = rb_class_new_instance(argc, argv, klass);
@@ -437,6 +438,89 @@ na_s_ones(int argc, const VALUE *argv, VALUE klass)
 }
 
 
+/*
+  Returns an array of N linearly spaced points between x1 and x2.
+  This singleton method is valid not for NArray class itself
+  but for typed NArray subclasses, e.g., DFloat, Int64.
+
+  @overload linspace(x1, x2, [n])
+  @param [Numeric] x1   The start value
+  @param [Numeric] x2   The end value
+  @param [Integer] n    The number of elements. (default is 100).
+  @return [Numo::NArray]  result array.
+
+  @example
+    a = Numo::DFloat.linspace(-5,5,7)
+    => Numo::DFloat#shape=[7]
+    [-5, -3.33333, -1.66667, 0, 1.66667, 3.33333, 5]
+ */
+static VALUE
+na_s_linspace(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE obj, vx1, vx2, vstep, vsize;
+    double n;
+    int narg;
+
+    narg = rb_scan_args(argc,argv,"21",&vx1,&vx2,&vsize);
+    if (narg==3) {
+        n = NUM2DBL(vsize);
+    } else {
+        n = 100;
+        vsize = INT2FIX(100);
+    }
+
+    obj = rb_funcall(vx2, '-', 1, vx1);
+    vstep = rb_funcall(obj, '/', 1, DBL2NUM(n-1));
+
+    obj = rb_class_new_instance(1, &vsize, klass);
+    return rb_funcall(obj, rb_intern("seq"), 2, vx1, vstep);
+}
+
+/*
+  Returns an array of N logarithmically spaced points between 10^a and 10^b.
+  This singleton method is valid not for NArray having +logseq+ method,
+  i.e., DFloat, SFloat, DComplex, and SComplex.
+
+  @overload logspace(a, b, [n, base])
+  @param [Numeric] a  The start value
+  @param [Numeric] b  The end value
+  @param [Integer] n  The number of elements. (default is 50)
+  @param [Numeric] base  The base of log space. (default is 10)
+  @return [Numo::NArray]  result array.
+
+  @example
+    Numo::DFloat.logspace(4,0,5,2)
+    => Numo::DFloat#shape=[5]
+       [16, 8, 4, 2, 1]
+    Numo::DComplex.logspace(0,1i*Math::PI,5,Math::E)
+    => Numo::DComplex#shape=[5]
+       [1+4.44659e-323i, 0.707107+0.707107i, 6.12323e-17+1i, -0.707107+0.707107i, ...]
+ */
+static VALUE
+na_s_logspace(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE obj, vx1, vx2, vstep, vsize, vbase;
+    double n;
+
+    rb_scan_args(argc,argv,"22",&vx1,&vx2,&vsize,&vbase);
+    if (vsize == Qnil) {
+        vsize = INT2FIX(50);
+        n = 50;
+    } else {
+        n = NUM2DBL(vsize);
+    }
+    if (vbase == Qnil) {
+        vbase = DBL2NUM(10);
+    }
+
+    obj = rb_funcall(vx2, '-', 1, vx1);
+    vstep = rb_funcall(obj, '/', 1, DBL2NUM(n-1));
+
+    obj = rb_class_new_instance(1, &vsize, klass);
+    return rb_funcall(obj, rb_intern("logseq"), 3, vx1, vstep, vbase);
+}
+
+
 /*
   Returns a NArray with shape=(n,n) whose diagonal elements are 1, otherwise 0.
   @overload  eye(n)
@@ -450,7 +534,7 @@ na_s_ones(int argc, const VALUE *argv, VALUE klass)
      [0, 0, 1]]
 */
 static VALUE
-na_s_eye(int argc, const VALUE *argv, VALUE klass)
+na_s_eye(int argc, VALUE *argv, VALUE klass)
 {
     VALUE obj;
     VALUE tmp[2];
@@ -468,82 +552,89 @@ na_s_eye(int argc, const VALUE *argv, VALUE klass)
 }
 
 
-char *
-na_get_pointer(VALUE self)
-{
-    narray_t *na;
-    GetNArray(self,na);
 
-    switch(NA_TYPE(na)) {
-    case NARRAY_DATA_T:
-        return NA_DATA_PTR(na);
-    case NARRAY_FILEMAP_T:
-        return ((narray_filemap_t*)na)->ptr;
-    case NARRAY_VIEW_T:
-        return na_get_pointer(NA_VIEW_DATA(na));
-        //puts("pass NARRAY_VIEW_T in na_get_pointer_for_write");
-        //ptr += ((narray_view_t*)na)->offset;
-        //ptr += NA_VIEW_OFFSET(na);
-        break;
-    default:
-        rb_raise(rb_eRuntimeError,"invalid NA_TYPE");
-    }
-    return NULL;
-}
+#define READ 1
+#define WRITE 2
 
-char *
-na_get_pointer_for_write(VALUE self)
+static char *
+na_get_pointer_for_rw(VALUE self, int flag)
 {
     char *ptr;
+    VALUE obj;
     narray_t *na;
-    GetNArray(self,na);
 
-    if (OBJ_FROZEN(self)) {
+    if ((flag & WRITE) && OBJ_FROZEN(self)) {
         rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
     }
 
-    if (NA_TYPE(na) == NARRAY_DATA_T) {
+    GetNArray(self,na);
+
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
         ptr = NA_DATA_PTR(na);
-        if (na->size > 0 && ptr == NULL) {
-            rb_funcall(self, id_allocate, 0);
-            ptr = NA_DATA_PTR(na);
-        }
-    } else {
-        ptr = na_get_pointer(self);
         if (NA_SIZE(na) > 0 && ptr == NULL) {
-            rb_raise(rb_eRuntimeError,"cannot write to unallocated NArray");
+            if (flag & READ) {
+                rb_raise(rb_eRuntimeError,"cannot read unallocated NArray");
+            }
+            if (flag & WRITE) {
+                rb_funcall(self, id_allocate, 0);
+                ptr = NA_DATA_PTR(na);
+            }
+        }
+        return ptr;
+    case NARRAY_VIEW_T:
+        obj = NA_VIEW_DATA(na);
+        if ((flag & WRITE) && OBJ_FROZEN(obj)) {
+            rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
         }
-    }
 
-    //NA_SET_LOCK(na);
+        if (flag & WRITE) {
+            if (OBJ_FROZEN(obj)) {
+                rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
+            }
+        }
+        GetNArray(obj,na);
+        switch(NA_TYPE(na)) {
+        case NARRAY_DATA_T:
+            ptr = NA_DATA_PTR(na);
+            if (flag & (READ|WRITE)) {
+                if (NA_SIZE(na) > 0 && ptr == NULL) {
+                    rb_raise(rb_eRuntimeError,"cannot read/write unallocated NArray");
+                }
+            }
+            return ptr;
+        default:
+            rb_raise(rb_eRuntimeError,"invalid NA_TYPE of view: %d",NA_TYPE(na));
+        }
+    default:
+        rb_raise(rb_eRuntimeError,"invalid NA_TYPE: %d",NA_TYPE(na));
+    }
 
-    return ptr;
+    return NULL;
 }
 
 char *
 na_get_pointer_for_read(VALUE self)
 {
-    char  *ptr;
-    narray_t *na;
-    GetNArray(self,na);
-
-    //if (NA_TEST_LOCK(na)) {
-    //    rb_raise(rb_eRuntimeError, "cannot read locked NArray.");
-    //}
-
-    if (NA_TYPE(na) == NARRAY_DATA_T) {
-        ptr = NA_DATA_PTR(na);
-    } else {
-        ptr = na_get_pointer(self);
-    }
+    return na_get_pointer_for_rw(self, READ);
+}
 
-    if (NA_SIZE(na) > 0 && ptr == NULL) {
-        rb_raise(rb_eRuntimeError,"cannot read unallocated NArray");
-    }
+char *
+na_get_pointer_for_write(VALUE self)
+{
+    return na_get_pointer_for_rw(self, WRITE);
+}
 
-    //NA_SET_LOCK(na);
+char *
+na_get_pointer_for_read_write(VALUE self)
+{
+    return na_get_pointer_for_rw(self, READ|WRITE);
+}
 
-    return ptr;
+char *
+na_get_pointer(VALUE self)
+{
+    return na_get_pointer_for_rw(self, 0);
 }
 
 
@@ -636,7 +727,7 @@ na_get_stride(VALUE v)
 
     if (!stridx) {
         stridx = ALLOC_N(stridx_t, na->ndim);
-        st = NUM2SIZE(rb_const_get(CLASS_OF(v), id_contiguous_stride));
+        st = NUM2SIZET(rb_const_get(CLASS_OF(v), id_contiguous_stride));
         //printf("step_unit=%ld, CLASS_OF(v)=%lx\n",st, CLASS_OF(v));
         for (i=na->ndim; i>0;) {
             SDX_SET_STRIDE(stridx[--i],st);
@@ -655,7 +746,7 @@ na_size(VALUE self)
 {
     narray_t *na;
     GetNArray(self,na);
-    return SIZE2NUM(na->size);
+    return SIZET2NUM(na->size);
 }
 
 
@@ -669,6 +760,22 @@ na_ndim(VALUE self)
 }
 
 
+/*
+  Returns true if self.size == 0.
+  @overload empty?
+*/
+static VALUE
+na_empty_p(VALUE self)
+{
+    narray_t *na;
+    GetNArray(self,na);
+    if (NA_SIZE(na)==0) {
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+
 /* method: shape() -- returns shape, array of the size of dimensions */
 static VALUE
  na_shape(VALUE self)
@@ -688,7 +795,7 @@ static VALUE
     }
     v = rb_ary_new2(n);
     for (i=0; i<n; i++) {
-        rb_ary_push(v, SIZE2NUM(na->shape[c]));
+        rb_ary_push(v, SIZET2NUM(na->shape[c]));
         c += s;
     }
     return v;
@@ -698,13 +805,13 @@ static VALUE
 size_t
 na_get_elmsz(VALUE vna)
 {
-    return NUM2SIZE(rb_const_get(CLASS_OF(vna), id_contiguous_stride));
+    return NUM2SIZET(rb_const_get(CLASS_OF(vna), id_contiguous_stride));
 }
 
 size_t
 na_dtype_elmsz(VALUE klass)
 {
-    return NUM2SIZE(rb_const_get(klass, id_contiguous_stride));
+    return NUM2SIZET(rb_const_get(klass, id_contiguous_stride));
 }
 
 size_t
@@ -890,7 +997,9 @@ na_expand_dims(VALUE self, VALUE vdim)
     na2->stridx = stridx;
     xfree(na_stridx);
     na2->base.shape = shape;
-    xfree(na_shape);
+    if (na_shape != &(na2->base.size)) {
+        xfree(na_shape);
+    }
     na2->base.ndim++;
     return view;
 }
@@ -1035,14 +1144,15 @@ nary_coerce(VALUE x, VALUE y)
 static VALUE
 nary_byte_size(VALUE self)
 {
-    VALUE velmsz; //klass,
+    VALUE velmsz;
     narray_t *na;
-    size_t sz;
 
     GetNArray(self,na);
     velmsz = rb_const_get(CLASS_OF(self), rb_intern(ELEMENT_BYTE_SIZE));
-    sz = SIZE2NUM(NUM2SIZE(velmsz) * na->size);
-    return sz;
+    if (FIXNUM_P(velmsz)) {
+        return SIZET2NUM(NUM2SIZET(velmsz) * na->size);
+    }
+    return SIZET2NUM(ceil(NUM2DBL(velmsz) * na->size));
 }
 
 /*
@@ -1066,41 +1176,65 @@ nary_s_byte_size(VALUE type)
 static VALUE
 nary_s_from_string(int argc, VALUE *argv, VALUE type)
 {
-    size_t len, str_len, elmsz;
+    size_t len, str_len, byte_size;
     size_t *shape;
     char *ptr;
-    int i, nd, narg;
-    VALUE vstr,vshape,vna;
+    int   i, nd, narg;
+    VALUE vstr, vshape, vna;
+    VALUE velmsz;
 
     narg = rb_scan_args(argc,argv,"11",&vstr,&vshape);
     str_len = RSTRING_LEN(vstr);
-    elmsz = na_dtype_elmsz(type);
+    velmsz = rb_const_get(type, rb_intern(ELEMENT_BYTE_SIZE));
     if (narg==2) {
-        nd = RARRAY_LEN(vshape);
-        if (nd == 0 || nd > NA_MAX_DIMENSION) {
-            rb_raise(nary_eDimensionError,"too long or empty shape (%d)", nd);
+        switch(TYPE(vshape)) {
+        case T_FIXNUM:
+            nd = 1;
+            len = NUM2SIZET(vshape);
+            shape = &len;
+            break;
+        case T_ARRAY:
+            nd = RARRAY_LEN(vshape);
+            if (nd == 0 || nd > NA_MAX_DIMENSION) {
+                rb_raise(nary_eDimensionError,"too long or empty shape (%d)", nd);
+            }
+            shape = ALLOCA_N(size_t,nd);
+            len = 1;
+            for (i=0; i<nd; ++i) {
+                len *= shape[i] = NUM2SIZET(RARRAY_AREF(vshape,i));
+            }
+            break;
+        default:
+            rb_raise(rb_eArgError,"second argument must be size or shape");
         }
-        shape = ALLOCA_N(size_t,nd);
-        len = 1;
-        for (i=0; i<nd; ++i) {
-            len *= shape[i] = NUM2SIZE(RARRAY_AREF(vshape,i));
+        if (FIXNUM_P(velmsz)) {
+            byte_size = len * NUM2SIZET(velmsz);
+        } else {
+            byte_size = ceil(len * NUM2DBL(velmsz));
         }
-        if (len*elmsz != str_len) {
-            rb_raise(rb_eArgError, "size mismatch");
+        if (byte_size > str_len) {
+            rb_raise(rb_eArgError, "specified size is too large");
         }
     } else {
         nd = 1;
-        shape = ALLOCA_N(size_t,nd);
-        shape[0] = len = str_len / elmsz;
+        if (FIXNUM_P(velmsz)) {
+            len = str_len / NUM2SIZET(velmsz);
+            byte_size = len * NUM2SIZET(velmsz);
+        } else {
+            len = floor(str_len / NUM2DBL(velmsz));
+            byte_size = str_len;
+        }
         if (len == 0) {
             rb_raise(rb_eArgError, "string is empty or too short");
         }
+        shape = ALLOCA_N(size_t,nd);
+        shape[0] = len;
     }
 
     vna = rb_narray_new(type, nd, shape);
     ptr = na_get_pointer_for_write(vna);
 
-    memcpy(ptr, RSTRING_PTR(vstr), elmsz*len);
+    memcpy(ptr, RSTRING_PTR(vstr), byte_size);
 
     return vna;
 }
@@ -1113,17 +1247,16 @@ nary_s_from_string(int argc, VALUE *argv, VALUE type)
 static VALUE
 nary_to_string(VALUE self)
 {
-    size_t len, esz;
+    size_t len;
     char *ptr;
     VALUE str;
     narray_t *na;
 
     GetNArray(self,na);
     if (na->type == NARRAY_VIEW_T) {
-        self = na_copy(self);
+        self = rb_funcall(self,rb_intern("copy"),0);
     }
-    esz = na_get_elmsz(self);
-    len = na->size * esz;
+    len = NUM2SIZET(nary_byte_size(self));
     ptr = na_get_pointer_for_read(self);
     str = rb_usascii_str_new(ptr,len);
     RB_GC_GUARD(self);
@@ -1236,14 +1369,14 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv)
                     m |= ((size_t)1) << r;
                     continue;
                 } else {
-                    reduce = SIZE2NUM(m);
+                    reduce = SIZET2NUM(m);
                 }
             }
             v = rb_funcall( INT2FIX(1), rb_intern("<<"), 1, INT2FIX(r) );
             reduce = rb_funcall( reduce, rb_intern("|"), 1, v );
         }
     }
-    if (reduce==Qnil) reduce = SIZE2NUM(m);
+    if (reduce==Qnil) reduce = SIZET2NUM(m);
     return reduce;
 }
 
@@ -1395,6 +1528,67 @@ VALUE na_profile_set(VALUE mod, VALUE val)
 }
 
 
+/*
+  Returns the number of rows used for NArray#inspect
+  @overload inspect_rows
+  @return [Integer or nil]  the number of rows.
+*/
+static VALUE na_inspect_rows(VALUE mod)
+{
+    if (numo_na_inspect_rows > 0) {
+        return INT2NUM(numo_na_inspect_rows);
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+  Set the number of rows used for NArray#inspect
+  @overload inspect_rows=(rows)
+  @param [Integer or nil] rows  the number of rows
+  @return [nil]
+*/
+static VALUE na_inspect_rows_set(VALUE mod, VALUE num)
+{
+    if (RTEST(num)) {
+        numo_na_inspect_rows = NUM2INT(num);
+    } else {
+        numo_na_inspect_rows = 0;
+    }
+    return Qnil;
+}
+
+/*
+  Returns the number of cols used for NArray#inspect
+  @overload inspect_cols
+  @return [Integer or nil]  the number of cols.
+*/
+static VALUE na_inspect_cols(VALUE mod)
+{
+    if (numo_na_inspect_cols > 0) {
+        return INT2NUM(numo_na_inspect_cols);
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+  Set the number of cols used for NArray#inspect
+  @overload inspect_cols=(cols)
+  @param [Integer or nil] cols  the number of cols
+  @return [nil]
+*/
+static VALUE na_inspect_cols_set(VALUE mod, VALUE num)
+{
+    if (RTEST(num)) {
+        numo_na_inspect_cols = NUM2INT(num);
+    } else {
+        numo_na_inspect_cols = 0;
+    }
+    return Qnil;
+}
+
+
 /*
   Equality of self and other in view of numerical array.
   i.e., both arrays have same shape and corresponding elements are equal.
@@ -1444,6 +1638,8 @@ Init_narray()
     rb_cComplex = rb_const_get(rb_cObject, rb_intern("Complex"));
 #endif
 
+    rb_define_const(cNArray, "VERSION", rb_str_new2(NARRAY_VERSION));
+
     nary_eCastError = rb_define_class_under(cNArray, "CastError", rb_eStandardError);
     nary_eShapeError = rb_define_class_under(cNArray, "ShapeError", rb_eStandardError);
     nary_eOperationError = rb_define_class_under(cNArray, "OperationError", rb_eStandardError);
@@ -1453,6 +1649,11 @@ Init_narray()
     rb_define_singleton_method(cNArray, "profile", na_profile, 0);
     rb_define_singleton_method(cNArray, "profile=", na_profile_set, 1);
 
+    rb_define_singleton_method(cNArray, "inspect_rows", na_inspect_rows, 0);
+    rb_define_singleton_method(cNArray, "inspect_rows=", na_inspect_rows_set, 1);
+    rb_define_singleton_method(cNArray, "inspect_cols", na_inspect_cols, 0);
+    rb_define_singleton_method(cNArray, "inspect_cols=", na_inspect_cols_set, 1);
+
     /* Ruby allocation framework  */
     rb_define_alloc_func(cNArray, na_s_allocate);
     rb_define_method(cNArray, "initialize", na_initialize, -2);
@@ -1460,6 +1661,8 @@ Init_narray()
 
     rb_define_singleton_method(cNArray, "zeros", na_s_zeros, -1);
     rb_define_singleton_method(cNArray, "ones", na_s_ones, -1);
+    rb_define_singleton_method(cNArray, "linspace", na_s_linspace, -1);
+    rb_define_singleton_method(cNArray, "logspace", na_s_logspace, -1);
     rb_define_singleton_method(cNArray, "eye", na_s_eye, -1);
 
     rb_define_method(cNArray, "size", na_size, 0);
@@ -1468,6 +1671,7 @@ Init_narray()
     rb_define_method(cNArray, "shape", na_shape, 0);
     rb_define_method(cNArray, "ndim", na_ndim,0);
     rb_define_alias (cNArray, "rank","ndim");
+    rb_define_method(cNArray, "empty?", na_empty_p, 0);
 
     rb_define_method(cNArray, "debug_info", rb_narray_debug_info, 0);