Class: Numo::NArray

Inherits:

Object

• Object
• Numo::NArray

Defined in:

ext/numo/narray/narray.c

Direct Known Subclasses

Bit

Defined Under Namespace

Classes: CastError, DimensionError, OperationError, ShapeError, Step

Constant Summary

VERSION =

rb_str_new2(NARRAY_VERSION)

Class Method Summary

• .[](elements) ⇒ NArray

  Generate NArray object.

• .array_type(ary) ⇒ Object
• .byte_size ⇒ Numeric

  Returns byte size of one element of NArray.

• .debug=(flag) ⇒ Object
• .eye(n) ⇒ Numo::NArray

  Returns a NArray with shape=(n,n) whose diagonal elements are 1, otherwise 0.

• .from_string(string, [shape]) ⇒ Numo::NArray

  Returns a new 1-D array initialized from binary raw data in a string.

• .ones(*args) ⇒ Object

  Returns a one-filled narray with shape.

• .profile ⇒ Object
• .profile=(val) ⇒ Object
• .step(*args) ⇒ Object
• .upcast(type2) ⇒ Object

  ———————————————————————-.

• .zeros(*args) ⇒ Object

  Returns a zero-filled narray with shape.

Instance Method Summary

• #==(other) ⇒ Boolean

  Equality of self and other in view of numerical array.

• #[]=(*args) ⇒ Object

  method: []=(idx1,idx2,…,idxN,val).

• #byte_size ⇒ Integer

  Returns total byte size of NArray.

• #byte_swapped? ⇒ Boolean (also: #network_order?)

  Return true if byte swapped.

• #cast_to(datatype) ⇒ Numo::NArray

  Cast self to another NArray datatype.

• #coerce(other) ⇒ Array

  Returns an array containing other and self, both are converted to upcasted type of NArray.

• #column_major? ⇒ Boolean

  Return true if column major.

• #debug_info ⇒ Object
• #diagonal([offset,axes]) ⇒ Numo::NArray

  Returns a diagonal view of NArray.

• #dot(other) ⇒ Object

  Returns dot product.

• #expand_dims(dim) ⇒ Numo::NArray

  Expand the shape of an array.

• #flatten ⇒ Object
• #host_order? ⇒ Boolean (also: #little_endian?, #vacs_order?)

  Return true if not byte swapped.

• #initialize(args) ⇒ Object constructor

  Constructs a narray using the given DataType and shape or sizes.

• #initialize_copy(other) ⇒ Numo::NArray

  Replaces the contents of self with the contents of other narray.

• #inplace ⇒ Numo::NArray

  Returns view of narray with inplace flagged.

• #inplace! ⇒ Numo::NArray

  Set inplace flag to self.

• #inplace? ⇒ Boolean

  Return true if inplace flagged.

• #ndim ⇒ Object (also: #rank)

  method: size() – returns the total number of typeents.

• #out_of_place! ⇒ Numo::NArray (also: #not_inplace!)

  Unset inplace flag to self.

• #reshape(*args) ⇒ Object

  private function for reshape.

• #reverse([dim0,dim1,..]) ⇒ Object

  Return reversed view along specified dimeinsion.

• #row_major? ⇒ Boolean

  Return true if row major.

• #shape ⇒ Object

  method: shape() – returns shape, array of the size of dimensions.

• #size ⇒ Object (also: #length, #total)

  method: size() – returns the total number of typeents.

• #slice(*args) ⇒ Object

  method: slice(idx1,idx2,…,idxN).

• #swap_byte ⇒ Object (also: #hton)
• #to_host ⇒ Object
• #to_network ⇒ Object
• #to_string ⇒ String

  Returns string containing the raw data bytes in NArray.

• #to_swapped ⇒ Object
• #to_vacs ⇒ Object
• #transpose(*args) ⇒ Object
• #view ⇒ Object

  Return view of NArray.

Constructor Details

#Numo::DataType.new(shape) ⇒ Object #Numo::DataType.new(size1, size2, ...) ⇒ Object

Constructs a narray using the given DataType and shape or sizes.

# File 'ext/numo/narray/narray.c', line 322

static VALUE
na_initialize(VALUE self, VALUE args)
{
    VALUE v;
    size_t *shape=NULL;
    int ndim;

    if (RARRAY_LEN(args) == 1) {
        v = RARRAY_AREF(args,0);
        if (TYPE(v) != T_ARRAY) {
            v = 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);
    na_setup(self, ndim, shape);

    return self;
}

Class Method Details

.[](elements) ⇒ NArray

Generate NArray object. NArray datatype is automatically selected.

Parameters:

• elements (Numeric, Array)

Returns:

• (NArray)

# File 'ext/numo/narray/array.c', line 393

static VALUE
nary_s_bracket(VALUE klass, VALUE ary)
{
    VALUE dtype=Qnil;

    if (TYPE(ary)!=T_ARRAY) {
        rb_bug("Argument is not array");
    }

    dtype = na_ary_composition_dtype(ary);

    if (RTEST(rb_obj_is_kind_of(dtype,rb_cClass))) {
        if (RTEST(rb_funcall(dtype,rb_intern("<="),1,cNArray))) {
            return rb_funcall(dtype,rb_intern("cast"),1,ary);
        }
    }
    rb_raise(nary_eCastError, "cannot convert to NArray");
    return Qnil;
}

.array_type(ary) ⇒ Object

# File 'ext/numo/narray/array.c', line 379

static VALUE
na_s_array_type(VALUE mod, VALUE ary)
{
    return na_ary_composition_dtype(ary);
}

.byte_size ⇒ Numeric

Returns byte size of one element of NArray.

Returns:

• (Numeric) —

  byte size.

# File 'ext/numo/narray/narray.c', line 1052

static VALUE
nary_s_byte_size(VALUE type)
{
    return rb_const_get(type, rb_intern(ELEMENT_BYTE_SIZE));
}

.debug=(flag) ⇒ Object

# File 'ext/numo/narray/narray.c', line 1378

VALUE na_debug_set(VALUE mod, VALUE flag)
{
    na_debug_flag = RTEST(flag);
    return Qnil;
}

.eye(n) ⇒ Numo::NArray

Returns a NArray with shape=(n,n) whose diagonal elements are 1, otherwise 0.

Examples:

a = Numo::DFloat.eye(3)
=> Numo::DFloat#shape=[3,3]
[[1, 0, 0],
 [0, 1, 0],
 [0, 0, 1]]

Parameters:

• n (Integer) —

  Size of NArray. Creates 2-D NArray with shape=(n,n)

Returns:

• (Numo::NArray) —

  created NArray.

# File 'ext/numo/narray/narray.c', line 452

static VALUE
na_s_eye(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj;
    VALUE tmp[2];

    if (argc==0) {
        rb_raise(rb_eArgError,"No argument");
    }
    else if (argc==1) {
        tmp[0] = tmp[1] = argv[0];
        argv = tmp;
        argc = 2;
    }
    obj = rb_class_new_instance(argc, argv, klass);
    return rb_funcall(obj, rb_intern("eye"), 0);
}

.from_string(string, [shape]) ⇒ Numo::NArray

Returns a new 1-D array initialized from binary raw data in a string.

Parameters:

• string (String) —

  Binary raw data.

• shape (Array) —

  array of integers representing array shape.

Returns:

• (Numo::NArray) —

  NArray containing binary data.

# File 'ext/numo/narray/narray.c', line 1066

static VALUE
nary_s_from_string(int argc, VALUE *argv, VALUE type)
{
    size_t len, str_len, elmsz;
    size_t *shape;
    char *ptr;
    int i, nd, narg;
    VALUE vstr,vshape,vna;

    narg = rb_scan_args(argc,argv,"11",&vstr,&vshape);
    str_len = RSTRING_LEN(vstr);
    elmsz = na_dtype_elmsz(type);
    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);
        }
        shape = ALLOCA_N(size_t,nd);
        len = 1;
        for (i=0; i<nd; ++i) {
            len *= shape[i] = NUM2SIZE(RARRAY_AREF(vshape,i));
        }
        if (len*elmsz != str_len) {
            rb_raise(rb_eArgError, "size mismatch");
        }
    } else {
        nd = 1;
        shape = ALLOCA_N(size_t,nd);
        shape[0] = len = str_len / elmsz;
        if (len == 0) {
            rb_raise(rb_eArgError, "string is empty or too short");
        }
    }

    vna = rb_narray_new(type, nd, shape);
    ptr = na_get_pointer_for_write(vna);

    memcpy(ptr, RSTRING_PTR(vstr), elmsz*len);

    return vna;
}

.ones(shape) ⇒ Object .ones(size1, size2, ...) ⇒ Object

Returns a one-filled narray with shape. This singleton method is valid not for NArray class itself but for typed NArray subclasses, e.g., DFloat, Int64.

Examples:

a = Numo::DFloat.ones(3,5)
=> Numo::DFloat#shape=[3,5]
[[1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1]]

# File 'ext/numo/narray/narray.c', line 431

static VALUE
na_s_ones(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj;
    obj = rb_class_new_instance(argc, argv, klass);
    return rb_funcall(obj, rb_intern("fill"), 1, INT2FIX(1));
}

.profile ⇒ Object

# File 'ext/numo/narray/narray.c', line 1386

VALUE na_profile(VALUE mod)
{
    return rb_float_new(na_profile_value);
}

.profile=(val) ⇒ Object

# File 'ext/numo/narray/narray.c', line 1391

VALUE na_profile_set(VALUE mod, VALUE val)
{
    na_profile_value = NUM2DBL(val);
    return val;
}

.step(*args) ⇒ Object

# File 'ext/numo/narray/step.c', line 454

static VALUE
nary_s_step( int argc, VALUE *argv, VALUE mod )
{
    VALUE self = rb_obj_alloc(na_cStep);
    step_initialize(argc, argv, self);
    return self;
}

.upcast(type2) ⇒ Object

---

# File 'ext/numo/narray/narray.c', line 989

VALUE
numo_na_upcast(VALUE type1, VALUE type2)
{
    VALUE upcast_hash;
    VALUE result_type;

    if (type1==type2) {
        return type1;
    }
    upcast_hash = rb_const_get(type1, rb_intern("UPCAST"));
    result_type = rb_hash_aref(upcast_hash, type2);
    if (NIL_P(result_type)) {
        if (TYPE(type2)==T_CLASS) {
            if (RTEST(rb_class_inherited_p(type2,cNArray))) {
                upcast_hash = rb_const_get(type2, rb_intern("UPCAST"));
                result_type = rb_hash_aref(upcast_hash, type1);
            }
        }
    }
    return result_type;
}

.zeros(shape) ⇒ Object .zeros(size1, size2, ...) ⇒ Object

Returns a zero-filled narray with shape. This singleton method is valid not for NArray class itself but for typed NArray subclasses, e.g., DFloat, Int64.

Examples:

a = Numo::DFloat.zeros(3,5)
=> Numo::DFloat#shape=[3,5]
[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

# File 'ext/numo/narray/narray.c', line 407

static VALUE
na_s_zeros(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj;
    obj = rb_class_new_instance(argc, argv, klass);
    return rb_funcall(obj, rb_intern("fill"), 1, INT2FIX(0));
}

Instance Method Details

#==(other) ⇒ Boolean

Equality of self and other in view of numerical array. i.e., both arrays have same shape and corresponding elements are equal.

Parameters:

• other (Object)

Returns:

• (Boolean) —

  true if self and other is equal.

# File 'ext/numo/narray/narray.c', line 1405

VALUE
na_equal(VALUE self, volatile VALUE other)
{
    volatile VALUE vbool;
    narray_t *na1, *na2;
    int i;

    GetNArray(self,na1);

    if (!rb_obj_is_kind_of(other,cNArray)) {
        other = rb_funcall(CLASS_OF(self), rb_intern("cast"), 1, other);
    }

    GetNArray(other,na2);
    if (na1->ndim != na2->ndim) {
        return Qfalse;
    }
    for (i=0; i<na1->ndim; i++) {
        if (na1->shape[i] != na2->shape[i]) {
            return Qfalse;
        }
    }
    vbool = rb_funcall(self, rb_intern("eq"), 1, other);
    return (rb_funcall(vbool, rb_intern("count_false"), 0)==INT2FIX(0)) ? Qtrue : Qfalse;
}

#[]=(*args) ⇒ Object

method: []=(idx1,idx2,…,idxN,val)

# File 'ext/numo/narray/index.c', line 669

static VALUE
na_aset(int argc, VALUE *argv, VALUE self)
{
    VALUE a;
    argc--;

    if (argc==0)
        na_store(self, argv[argc]);
    else {
        a = na_aref_main(argc, argv, self, 0);
        na_store(a, argv[argc]);
    }
    return argv[argc];
}

#byte_size ⇒ Integer

Returns total byte size of NArray.

Returns:

• (Integer) —

  byte size.

# File 'ext/numo/narray/narray.c', line 1035

static VALUE
nary_byte_size(VALUE self)
{
    VALUE velmsz; //klass,
    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;
}

#byte_swapped? ⇒ Boolean Also known as: network_order?

Return true if byte swapped.

Returns:

• (Boolean)

# File 'ext/numo/narray/narray.c', line 1307

VALUE na_byte_swapped_p( VALUE self )
{
    if (TEST_BYTE_SWAPPED(self))
      return Qtrue;
    return Qfalse;
}

#cast_to(datatype) ⇒ Numo::NArray

Cast self to another NArray datatype.

Parameters:

• datatype (Class) —

  NArray datatype.

Returns:

• (Numo::NArray)

# File 'ext/numo/narray/narray.c', line 1140

static VALUE
nary_cast_to(VALUE obj, VALUE type)
{
    return rb_funcall(type, rb_intern("cast"), 1, obj);
}

#coerce(other) ⇒ Array

Returns an array containing other and self, both are converted to upcasted type of NArray. Note that NArray has distinct UPCAST mechanism. Coerce is used for operation between non-NArray and NArray.

Parameters:

• other (Object) —

  numeric object.

Returns:

• (Array) —

  NArray-casted [other,self]

# File 'ext/numo/narray/narray.c', line 1020

static VALUE
nary_coerce(VALUE x, VALUE y)
{
    VALUE type;

    type = numo_na_upcast(CLASS_OF(x), CLASS_OF(y));
    y = rb_funcall(type,rb_intern("cast"),1,y);
    return rb_assoc_new(y , x);
}

#column_major? ⇒ Boolean

Return true if column major.

Returns:

• (Boolean)

# File 'ext/numo/narray/narray.c', line 1284

VALUE na_column_major_p( VALUE self )
{
    if (TEST_COLUMN_MAJOR(self))
  return Qtrue;
    else
  return Qfalse;
}

#debug_info ⇒ Object

# File 'ext/numo/narray/narray.c', line 111

VALUE
rb_narray_debug_info(VALUE self)
{
    int i;
    narray_t *na;
    GetNArray(self,na);

    printf("%s:\n",rb_class2name(CLASS_OF(self)));
    printf("  id     = 0x%"SZF"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);
    printf("  ndim   = %d\n", na->ndim);
    printf("  shape  = 0x%"SZF"x\n", (size_t)na->shape);
    if (na->shape) {
        printf("  shape  = [");
        for (i=0;i<na->ndim;i++)
            printf(" %"SZF"d", na->shape[i]);
        printf(" ]\n");
    }

    switch(na->type) {
    case NARRAY_DATA_T:
    case NARRAY_FILEMAP_T:
        rb_narray_debug_info_nadata(self);
        break;
    case NARRAY_VIEW_T:
        rb_narray_debug_info_naview(self);
        break;
    }
    return Qnil;
}

#diagonal([offset,axes]) ⇒ Numo::NArray

Returns a diagonal view of NArray

Examples:

a = Numo::DFloat.new(4,5).seq
=> Numo::DFloat#shape=[4,5]
[[0, 1, 2, 3, 4],
 [5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14],
 [15, 16, 17, 18, 19]]
b = a.diagonal(1)
=> Numo::DFloat(view)#shape=[4]
[1, 7, 13, 19]
b.store(0)
a
=> Numo::DFloat#shape=[4,5]
[[0, 0, 2, 3, 4],
 [5, 6, 0, 8, 9],
 [10, 11, 12, 0, 14],
 [15, 16, 17, 18, 0]]
b.store([1,2,3,4])
a
=> Numo::DFloat#shape=[4,5]
[[0, 1, 2, 3, 4],
 [5, 6, 2, 8, 9],
 [10, 11, 12, 3, 14],
 [15, 16, 17, 18, 4]]

Parameters:

• offset (Integer) —

  Diagonal offset from the main diagonal. The default is 0. k>0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal.

• axes (Array) —

  Array of axes to be used as the 2-d sub-arrays from which the diagonals should be taken. Defaults to last-two axes ([-2,-1]).

Returns:

• (Numo::NArray) —

  diagonal view of NArray.

# File 'ext/numo/narray/data.c', line 555

VALUE
na_diagonal(int argc, VALUE *argv, VALUE self)
{
    int  i, k, nd;
    size_t  j;
    size_t *idx0, *idx1, *diag_idx;
    size_t *shape;
    size_t  diag_size;
    ssize_t stride, stride0, stride1;
    narray_t *na;
    narray_view_t *na1, *na2;
    VALUE view;
    VALUE vofs=0, vaxes=0;
    ssize_t kofs;
    size_t k0, k1;
    int ax[2];

    // check arguments
    if (argc>2) {
        rb_raise(rb_eArgError,"too many arguments (%d for 0..2)",argc);
    }

    for (i=0; i<argc; i++) {
        switch(TYPE(argv[i])) {
        case T_FIXNUM:
            if (vofs) {
                rb_raise(rb_eArgError,"offset is given twice");
            }
            vofs = argv[i];
            break;
        case T_ARRAY:
            if (vaxes) {
                rb_raise(rb_eArgError,"axes-array is given twice");
            }
            vaxes = argv[i];
            break;
        }
    }

    if (vofs) {
        kofs = NUM2SSIZE(vofs);
    } else {
        kofs = 0;
    }

    GetNArray(self,na);
    nd = na->ndim;
    if (nd < 2) {
        rb_raise(nary_eDimensionError,"less than 2-d array");
    }

    if (vaxes) {
        if (RARRAY_LEN(vaxes) != 2) {
            rb_raise(rb_eArgError,"axes must be 2-element array");
        }
        ax[0] = NUM2INT(RARRAY_AREF(vaxes,0));
        ax[1] = NUM2INT(RARRAY_AREF(vaxes,1));
        if (ax[0]<-nd || ax[0]>=nd || ax[1]<-nd || ax[1]>=nd) {
            rb_raise(rb_eArgError,"axis out of range:[%d,%d]",ax[0],ax[1]);
        }
        if (ax[0]<0) {ax[0] += nd;}
        if (ax[1]<0) {ax[1] += nd;}
        if (ax[0]==ax[1]) {
            rb_raise(rb_eArgError,"same axes:[%d,%d]",ax[0],ax[1]);
        }
    } else {
        ax[0] = nd-2;
        ax[1] = nd-1;
    }

    // Diagonal offset from the main diagonal.
    if (kofs >= 0) {
        k0 = 0;
        k1 = kofs;
        if (k1 >= na->shape[ax[1]]) {
            rb_raise(rb_eArgError,"invalid diagonal offset(%ld) for "
                     "last dimension size(%ld)",kofs,na->shape[ax[1]]);
        }
    } else {
        k0 = -kofs;
        k1 = 0;
        if (k0 >= na->shape[ax[0]]) {
            rb_raise(rb_eArgError,"invalid diagonal offset(=%ld) for "
                     "last-1 dimension size(%ld)",kofs,na->shape[ax[0]]);
        }
    }

    diag_size = MIN(na->shape[ax[0]]-k0,na->shape[ax[1]]-k1);

    // new shape
    shape = ALLOCA_N(size_t,nd-1);
    for (i=k=0; i<nd; i++) {
        if (i != ax[0] && i != ax[1]) {
            shape[k++] = na->shape[i];
        }
    }
    shape[k] = diag_size;

    // new object
    view = na_s_allocate_view(CLASS_OF(self));
    na_copy_flags(self, view);
    GetNArrayView(view, na2);

    // new stride
    na_setup_shape((narray_t*)na2, nd-1, shape);
    na2->stridx = ALLOC_N(stridx_t, nd-1);

    switch(na->type) {
    case NARRAY_DATA_T:
    case NARRAY_FILEMAP_T:
        na2->offset = 0;
        na2->data = self;
        stride = stride0 = stride1 = na_get_elmsz(self);
        for (i=nd,k=nd-2; i--; ) {
            if (i==ax[1]) {
                stride1 = stride;
                if (kofs > 0) {
                    na2->offset = kofs*stride;
                }
            } else if (i==ax[0]) {
                stride0 = stride;
                if (kofs < 0) {
                    na2->offset = (-kofs)*stride;
                }
            } else {
                SDX_SET_STRIDE(na2->stridx[--k],stride);
            }
            stride *= na->shape[i];
        }
        SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
        break;

    case NARRAY_VIEW_T:
        GetNArrayView(self, na1);
        na2->data = na1->data;
        na2->offset = na1->offset;
        for (i=k=0; i<nd; i++) {
            if (i != ax[0] && i != ax[1]) {
                if (SDX_IS_INDEX(na1->stridx[i])) {
                    idx0 = SDX_GET_INDEX(na1->stridx[i]);
                    idx1 = ALLOC_N(size_t, na->shape[i]);
                    for (j=0; j<na->shape[i]; j++) {
                        idx1[j] = idx0[j];
                    }
                    SDX_SET_INDEX(na2->stridx[k],idx1);
                } else {
                    na2->stridx[k] = na1->stridx[i];
                }
                k++;
            }
        }
        if (SDX_IS_INDEX(na1->stridx[ax[0]])) {
            idx0 = SDX_GET_INDEX(na1->stridx[ax[0]]);
            diag_idx = ALLOC_N(size_t, diag_size);
            if (SDX_IS_INDEX(na1->stridx[ax[1]])) {
                idx1 = SDX_GET_INDEX(na1->stridx[ax[1]]);
                for (j=0; j<diag_size; j++) {
                    diag_idx[j] = idx0[j+k0] + idx1[j+k1];
                }
            } else {
                stride1 = SDX_GET_STRIDE(na1->stridx[ax[1]]);
                for (j=0; j<diag_size; j++) {
                    diag_idx[j] = idx0[j+k0] + stride1*(j+k1);
                }
            }
            SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
        } else {
            stride0 = SDX_GET_STRIDE(na1->stridx[ax[0]]);
            if (SDX_IS_INDEX(na1->stridx[ax[1]])) {
                idx1 = SDX_GET_INDEX(na1->stridx[ax[1]]);
                diag_idx = ALLOC_N(size_t, diag_size);
                for (j=0; j<diag_size; j++) {
                    diag_idx[j] = stride0*(j+k0) + idx1[j+k1];
                }
                SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
            } else {
                stride1 = SDX_GET_STRIDE(na1->stridx[ax[1]]);
                na2->offset += stride0*k0 + stride1*k1;
                SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
            }
        }
        break;
    }
    return view;
}

#dot(other) ⇒ Object

Returns dot product.

# File 'ext/numo/narray/data.c', line 842

static VALUE
numo_na_dot(VALUE self, VALUE other)
{
    VALUE test, sym_mulsum;
    volatile VALUE a1=self, a2=other;
    ID id_mulsum;
    narray_t *na1, *na2;

    id_mulsum = rb_intern("mulsum");
    sym_mulsum = ID2SYM(id_mulsum);
    test = rb_funcall(a1, rb_intern("respond_to?"), 1, sym_mulsum);
    if (!RTEST(test)) {
        rb_raise(rb_eNoMethodError,"requires mulsum method for dot method");
    }
    GetNArray(a1,na1);
    GetNArray(a2,na2);
    if (na2->ndim > 1) {
        // insert new axis [ ..., last-1-dim, newaxis*other.ndim, last-dim ]
        a1 = na_new_dimension_for_dot(a1, na1->ndim-1, na2->ndim-1, 0);
        // insert & transpose [ newaxis*self.ndim, ..., last-dim, last-1-dim ]
        a2 = na_new_dimension_for_dot(a2, 0, na1->ndim-1, 1);
    }
    return rb_funcall(a1,rb_intern("mulsum"),2,a2,INT2FIX(-1));
}

#expand_dims(dim) ⇒ Numo::NArray

Expand the shape of an array. Insert a new axis with size=1 at a given dimension.

Parameters:

• dim (Integer) —

  dimension at which new axis is inserted.

Returns:

• (Numo::NArray) —

  result narray view.

# File 'ext/numo/narray/narray.c', line 849

VALUE
na_expand_dims(VALUE self, VALUE vdim)
{
    int  i, j, nd, dim;
    size_t *shape, *na_shape;
    stridx_t *stridx, *na_stridx;
    narray_t *na;
    narray_view_t *na2;
    VALUE view;

    GetNArray(self,na);
    nd = na->ndim;

    dim = NUM2INT(vdim);
    if (dim < -nd-1 || dim > nd) {
        rb_raise(nary_eDimensionError,"invalid axis (%d for %dD NArray)",
                 dim,nd);
    }
    if (dim < 0) {
        dim += nd+1;
    }

    view = na_make_view(self);
    GetNArrayView(view, na2);

    shape = ALLOC_N(size_t,nd+1);
    stridx = ALLOC_N(stridx_t,nd+1);
    na_shape = na2->base.shape;
    na_stridx = na2->stridx;

    for (i=j=0; i<=nd; i++) {
        if (i==dim) {
            shape[i] = 1;
            SDX_SET_STRIDE(stridx[i],0);
        } else {
            shape[i] = na_shape[j];
            stridx[i] = na_stridx[j];
            j++;
        }
    }

    na2->stridx = stridx;
    xfree(na_stridx);
    na2->base.shape = shape;
    xfree(na_shape);
    na2->base.ndim++;
    return view;
}

#flatten ⇒ Object

# File 'ext/numo/narray/data.c', line 431

VALUE
na_flatten(VALUE self)
{
    return na_flatten_dim(self,0);
}

#host_order? ⇒ Boolean Also known as: little_endian?, vacs_order?

Return true if not byte swapped.

Returns:

• (Boolean)

# File 'ext/numo/narray/narray.c', line 1317

VALUE na_host_order_p( VALUE self )
{
    if (TEST_BYTE_SWAPPED(self))
      return Qfalse;
    return Qtrue;
}

#initialize_copy(other) ⇒ Numo::NArray

Replaces the contents of self with the contents of other narray. Used in dup and clone method.

Parameters:

• other (Numo::NArray)

Returns:

• (Numo::NArray) —

  self

# File 'ext/numo/narray/narray.c', line 379

static VALUE
na_initialize_copy(VALUE self, VALUE orig)
{
    narray_t *na;
    GetNArray(orig,na);

    na_setup(self,NA_NDIM(na),NA_SHAPE(na));
    na_store(self,orig);
    na_copy_flags(orig,self);
    return self;
}

#inplace ⇒ Numo::NArray

Returns view of narray with inplace flagged.

Returns:

• (Numo::NArray) —

  view of narray with inplace flag.

# File 'ext/numo/narray/narray.c', line 1329

VALUE na_inplace( VALUE self )
{
    VALUE view = self;
    //view = na_clone(self);
    SET_INPLACE(view);
    return view;
}

#inplace! ⇒ Numo::NArray

Set inplace flag to self.

Returns:

• (Numo::NArray) —

  self

# File 'ext/numo/narray/narray.c', line 1341

VALUE na_inplace_bang( VALUE self )
{
    SET_INPLACE(self);
    return self;
}

#inplace? ⇒ Boolean

Return true if inplace flagged.

Returns:

• (Boolean)

# File 'ext/numo/narray/narray.c', line 1358

VALUE na_inplace_p( VALUE self )
{
    if (TEST_INPLACE(self))
        return Qtrue;
    else
        return Qfalse;
}

#ndim ⇒ Object Also known as: rank

method: size() – returns the total number of typeents

# File 'ext/numo/narray/narray.c', line 663

static VALUE
na_ndim(VALUE self)
{
    narray_t *na;
    GetNArray(self,na);
    return INT2NUM(na->ndim);
}

#out_of_place! ⇒ Numo::NArray Also known as: not_inplace!

Unset inplace flag to self.

Returns:

• (Numo::NArray) —

  self

# File 'ext/numo/narray/narray.c', line 1370

VALUE na_out_of_place_bang( VALUE self )
{
    UNSET_INPLACE(self);
    return self;
}

#reshape(*args) ⇒ Object

private function for reshape

# File 'ext/numo/narray/data.c', line 265

static VALUE
na_reshape(int argc, VALUE *argv, VALUE self)
{
    int    i, unfixed=-1;
    size_t total=1;
    size_t *shape; //, *shape_save;
    narray_t *na;
    VALUE    copy;

    if (argc == 0) {
        rb_raise(rb_eRuntimeError, "No argrument");
    }
    GetNArray(self,na);
    if (NA_SIZE(na) == 0) {
        rb_raise(rb_eRuntimeError, "cannot reshape empty array");
    }

    /* get shape from argument */
    shape = ALLOCA_N(size_t,argc);
    for (i=0; i<argc; ++i) {
        switch(TYPE(argv[i])) {
        case T_FIXNUM:
            total *= shape[i] = NUM2INT(argv[i]);
            break;
        case T_NIL:
        case T_TRUE:
            unfixed = i;
            break;
        default:
            rb_raise(rb_eArgError,"illegal type");
        }
    }

    if (unfixed>=0) {
        if (NA_SIZE(na) % total != 0)
            rb_raise(rb_eArgError, "Total size size must be divisor");
        shape[unfixed] = NA_SIZE(na) / total;
    }
    else if (total !=  NA_SIZE(na)) {
        rb_raise(rb_eArgError, "Total size must be same");
    }

    copy = na_copy(self);
    GetNArray(copy,na);
    //shape_save = NA_SHAPE(na);
    na_setup_shape(na,argc,shape);
    //if (NA_SHAPE(na) != shape_save) {
    //    xfree(shape_save);
    //}
    return copy;
}

#reverse([dim0,dim1,..]) ⇒ Object

Return reversed view along specified dimeinsion

# File 'ext/numo/narray/narray.c', line 906

VALUE
nary_reverse(int argc, VALUE *argv, VALUE self)
{
    int i, nd;
    size_t  j, n;
    size_t  offset;
    size_t *idx1, *idx2;
    ssize_t stride;
    ssize_t sign;
    narray_t *na;
    narray_view_t *na1, *na2;
    VALUE view;
    VALUE reduce;

    reduce = na_reduce_dimension(argc, argv, 1, &self);

    GetNArray(self,na);
    nd = na->ndim;

    view = na_s_allocate_view(CLASS_OF(self));

    na_copy_flags(self, view);
    GetNArrayView(view, na2);

    na_setup_shape((narray_t*)na2, nd, na->shape);
    na2->stridx = ALLOC_N(stridx_t,nd);

    switch(na->type) {
    case NARRAY_DATA_T:
    case NARRAY_FILEMAP_T:
        stride = na_get_elmsz(self);
        offset = 0;
        for (i=nd; i--;) {
            if (na_test_reduce(reduce,i)) {
                offset += (na->shape[i]-1)*stride;
                sign = -1;
            } else {
                sign = 1;
            }
            SDX_SET_STRIDE(na2->stridx[i],stride*sign);
            stride *= na->shape[i];
        }
        na2->offset = offset;
        na2->data = self;
        break;
    case NARRAY_VIEW_T:
        GetNArrayView(self, na1);
        offset = na1->offset;
        for (i=0; i<nd; i++) {
            n = na1->base.shape[i];
            if (SDX_IS_INDEX(na1->stridx[i])) {
                idx1 = SDX_GET_INDEX(na1->stridx[i]);
                idx2 = ALLOC_N(size_t,n);
                if (na_test_reduce(reduce,i)) {
                    for (j=0; j<n; j++) {
                        idx2[n-1-j] = idx1[j];
                    }
                } else {
                    for (j=0; j<n; j++) {
                        idx2[j] = idx1[j];
                    }
                }
                SDX_SET_INDEX(na2->stridx[i],idx2);
            } else {
                stride = SDX_GET_STRIDE(na1->stridx[i]);
                if (na_test_reduce(reduce,i)) {
                    offset += (n-1)*stride;
                    SDX_SET_STRIDE(na2->stridx[i],-stride);
                } else {
                    na2->stridx[i] = na1->stridx[i];
                }
            }
        }
        na2->offset = offset;
        na2->data = na1->data;
        break;
    }

    return view;
}

#row_major? ⇒ Boolean

Return true if row major.

Returns:

• (Boolean)

# File 'ext/numo/narray/narray.c', line 1295

VALUE na_row_major_p( VALUE self )
{
    if (TEST_ROW_MAJOR(self))
  return Qtrue;
    else
  return Qfalse;
}

#shape ⇒ Object

method: shape() – returns shape, array of the size of dimensions

# File 'ext/numo/narray/narray.c', line 673

static VALUE
 na_shape(VALUE self)
{
    volatile VALUE v;
    narray_t *na;
    size_t i, n, c, s;

    GetNArray(self,na);
    n = NA_NDIM(na);
    if (TEST_COLUMN_MAJOR(na)) {
        c = n-1;
        s = -1;
    } else {
        c = 0;
        s = 1;
    }
    v = rb_ary_new2(n);
    for (i=0; i<n; i++) {
        rb_ary_push(v, SIZE2NUM(na->shape[c]));
        c += s;
    }
    return v;
}

#size ⇒ Object Also known as: length, total

method: size() – returns the total number of typeents

# File 'ext/numo/narray/narray.c', line 653

static VALUE
na_size(VALUE self)
{
    narray_t *na;
    GetNArray(self,na);
    return SIZE2NUM(na->size);
}

#slice(*args) ⇒ Object

method: slice(idx1,idx2,…,idxN)

# File 'ext/numo/narray/index.c', line 660

static VALUE na_slice(int argc, VALUE *argv, VALUE self)
{
    return na_aref_main(argc, argv, self, 1);
}

#swap_byte ⇒ Object Also known as: hton

# File 'ext/numo/narray/data.c', line 110

static VALUE
nary_swap_byte(VALUE self)
{
    VALUE v;
    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
    ndfunc_t ndf = { iter_swap_byte, FULL_LOOP|NDF_ACCEPT_BYTESWAP,
                     1, 1, ain, aout };

    v = na_ndloop(&ndf, 1, self);
    if (self!=v) {
        na_copy_flags(self, v);
    }
    REVERSE_BYTE_SWAPPED(v);
    return v;
}

#to_host ⇒ Object

# File 'ext/numo/narray/data.c', line 146

static VALUE
nary_to_host(VALUE self)
{
    if (TEST_HOST_ORDER(self)) {
        return self;
    }
    return rb_funcall(self, rb_intern("swap_byte"), 0);
}

#to_network ⇒ Object

# File 'ext/numo/narray/data.c', line 128

static VALUE
nary_to_network(VALUE self)
{
    if (TEST_NETWORK_ORDER(self)) {
        return self;
    }
    return rb_funcall(self, rb_intern("swap_byte"), 0);
}

#to_string ⇒ String

Returns string containing the raw data bytes in NArray.

Returns:

• (String) —

  String object containing binary raw data.

# File 'ext/numo/narray/narray.c', line 1113

static VALUE
nary_to_string(VALUE self)
{
    size_t len, esz;
    char *ptr;
    VALUE str;
    narray_t *na;

    GetNArray(self,na);
    if (na->type == NARRAY_VIEW_T) {
        self = na_copy(self);
    }
    esz = na_get_elmsz(self);
    len = na->size * esz;
    ptr = na_get_pointer_for_read(self);
    str = rb_usascii_str_new(ptr,len);
    RB_GC_GUARD(self);
    return str;
}

#to_swapped ⇒ Object

# File 'ext/numo/narray/data.c', line 155

static VALUE
nary_to_swapped(VALUE self)
{
    if (TEST_BYTE_SWAPPED(self)) {
        return self;
    }
    return rb_funcall(self, rb_intern("swap_byte"), 0);
}

#to_vacs ⇒ Object

# File 'ext/numo/narray/data.c', line 137

static VALUE
nary_to_vacs(VALUE self)
{
    if (TEST_VACS_ORDER(self)) {
        return self;
    }
    return rb_funcall(self, rb_intern("swap_byte"), 0);
}

#transpose(*args) ⇒ Object

# File 'ext/numo/narray/data.c', line 198

VALUE
na_transpose(int argc, VALUE *argv, VALUE self)
{
    int ndim, *map, tmp;
    int row_major;
    int i, j, c, r;
    size_t len;
    ssize_t beg, step;
    volatile VALUE v, view;
    narray_t *na1;

    GetNArray(self,na1);
    ndim = na1->ndim;
    row_major = TEST_COLUMN_MAJOR( self );

    map = ALLOCA_N(int,ndim);
    for (i=0;i<ndim;i++) {
  map[i] = i;
    }
    if (argc==0) {
  SWAP(map[ndim-1], map[ndim-2], tmp);
  goto new_object;
    }
    if (argc==2) {
  if (TYPE(argv[0])==T_FIXNUM && TYPE(argv[1])==T_FIXNUM) {
      i = FIX2INT(argv[0]);
      j = FIX2INT(argv[1]);
      if (row_major) {
    i = ndim-1-i;
    j = ndim-1-j;
      }
      SWAP( map[i], map[j], tmp );
      goto new_object;
  }
    }
    for (i=argc,c=ndim-1; i;) {
  v = argv[--i];
  if (TYPE(v)==T_FIXNUM) {
      beg = FIX2INT(v);
      len = 1;
      step = 0;
  } else if (rb_obj_is_kind_of(v,rb_cRange) || rb_obj_is_kind_of(v,na_cStep)) {
            // write me
      nary_step_array_index(v, ndim, &len, &beg, &step);
            //printf("len=%d beg=%d step=%d\n",len,beg,step);
  }
  for (j=len; j; ) {
      r = beg + step*(--j);
      if (row_major) {
    r = ndim-1-r;
            }
      if ( c < 0 ) {
    rb_raise(rb_eArgError, "too many dims");
            }
      map[c--] = r;
      //printf("r=%d\n",r);
  }
    }

 new_object:
    view = na_transpose_map(self,map);
    return view;
}

#view ⇒ Object

Return view of NArray

# File 'ext/numo/narray/narray.c', line 782

VALUE
na_make_view(VALUE self)
{
    int i, nd;
    size_t  j;
    size_t *idx1, *idx2;
    ssize_t stride;
    narray_t *na;
    narray_view_t *na1, *na2;
    volatile VALUE view;

    GetNArray(self,na);
    nd = na->ndim;

    view = na_s_allocate_view(CLASS_OF(self));

    na_copy_flags(self, view);
    GetNArrayView(view, na2);

    na_setup_shape((narray_t*)na2, nd, na->shape);
    na2->stridx = ALLOC_N(stridx_t,nd);

    switch(na->type) {
    case NARRAY_DATA_T:
    case NARRAY_FILEMAP_T:
        stride = na_get_elmsz(self);
        for (i=nd; i--;) {
            SDX_SET_STRIDE(na2->stridx[i],stride);
            stride *= na->shape[i];
        }
        na2->offset = 0;
        na2->data = self;
        break;
    case NARRAY_VIEW_T:
        GetNArrayView(self, na1);
        for (i=0; i<nd; i++) {
            if (SDX_IS_INDEX(na1->stridx[i])) {
                idx1 = SDX_GET_INDEX(na1->stridx[i]);
                idx2 = ALLOC_N(size_t,na1->base.shape[i]);
                for (j=0; j<na1->base.shape[i]; j++) {
                    idx2[j] = idx1[j];
                }
                SDX_SET_INDEX(na2->stridx[i],idx2);
            } else {
                na2->stridx[i] = na1->stridx[i];
            }
        }
        na2->offset = na1->offset;
        na2->data = na1->data;
        break;
    }

    return view;
}