Exemplo n.º 1
0
void
na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape)
{
    size_t    i, n, c, s;
    VALUE     v;
    narray_t *na;
    int       flag = 0;

    n = RARRAY_LEN(ary);

    if (RTEST(self)) {
        GetNArray(self, na);
        flag = TEST_COLUMN_MAJOR(na);
    }
    if (flag) {
        c = n-1;
        s = -1;
    } else {
        c = 0;
        s = 1;
    }
    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)))) {
            rb_raise(rb_eArgError,"size must be non-negative");
        }
        shape[c] = NUM2SIZE(v);
        c += s;
    }
}
Exemplo n.º 2
0
// ------
static void
iter_nstruct_from_a(na_loop_t *const lp)
{
    long  i, len;
    VALUE ary;
    VALUE types, defs, def;
    VALUE elmt, velm, item;
    size_t ofs;
    narray_view_t *ne;

    types = RARRAY_PTR(lp->option)[0];
    defs = RARRAY_PTR(lp->option)[1];

    len = RARRAY_LEN(types);
    ary = lp->args[0].value;
    //rb_p(CLASS_OF(ary));rb_p(ary);

    for (i=0; i<len; i++) {
        def  = RARRAY_PTR(defs)[i];
        ofs  = NUM2SIZE(RARRAY_PTR(def)[2]);
        elmt = RARRAY_PTR(types)[i];
        GetNArrayView(elmt,ne);
        ne->offset = lp->iter[1].pos + ofs;
        item = RARRAY_PTR(ary)[i];
        //rb_p(ary);
        //rb_p(item);
        //rb_p(elmt);
        //abort();
        velm = rb_funcall(elmt, rb_intern("store"), 1, item);
    }
}
Exemplo n.º 3
0
static void
iter_nstruct_to_a(na_loop_t *const lp)
{
    long    i, len;
    VALUE   opt, types, defs, def;
    VALUE   elmt, velm, vary;
    size_t  ofs, pos;
    narray_view_t *ne;

    opt = lp->option;
    types = RARRAY_PTR(opt)[0];
    defs = RARRAY_PTR(opt)[1];
    pos = lp->iter[0].pos;

    len = RARRAY_LEN(types);
    vary = rb_ary_new2(len);

    for (i=0; i<len; i++) {
        def  = RARRAY_PTR(defs)[i];
        ofs  = NUM2SIZE(RARRAY_PTR(def)[2]);
        //ofs  = NUM2SIZE(RARRAY_PTR(ofsts)[i]);
        elmt = RARRAY_PTR(types)[i];
        GetNArrayView(elmt,ne);
        ne->offset = pos + ofs;
        if (ne->base.ndim==0) {
            velm = rb_funcall(elmt,rb_intern("extract"),0);
        } else {
            velm = rb_funcall(elmt,rb_intern("to_a"),0);
        }
        rb_ary_push(vary, velm);
    }
    rb_ary_push(lp->args[1].value, vary);
}
Exemplo n.º 4
0
static VALUE
nst_allocate(VALUE self)
{
    narray_t *na;
    char *ptr;
    VALUE velmsz;

    GetNArray(self,na);

    switch(NA_TYPE(na)) {
    case NARRAY_DATA_T:
        ptr = NA_DATA_PTR(na);
        if (na->size > 0 && ptr == NULL) {
            velmsz = rb_const_get(CLASS_OF(self), id_element_byte_size);
            ptr = xmalloc(NUM2SIZE(velmsz) * na->size);
            NA_DATA_PTR(na) = ptr;
        }
        break;
    case NARRAY_VIEW_T:
        rb_funcall(NA_VIEW_DATA(na), id_allocate, 0);
        break;
    case NARRAY_FILEMAP_T:
        //ptr = ((narray_filemap_t*)na)->ptr;
        // to be implemented
    default:
        rb_bug("invalid narray type : %d",NA_TYPE(na));
    }
    return self;
}
Exemplo n.º 5
0
/*
  Returns total byte size of NArray.
  @return [Integer] byte size.
 */
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;
}
Exemplo n.º 6
0
/*
  Returns a new 1-D array initialized from binary raw data in a string.
  @overload from_string(string,[shape])
  @param [String] string  Binary raw data.
  @param [Array] shape  array of integers representing array shape.
  @return [Numo::NArray] NArray containing binary data.
 */
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;
}
Exemplo n.º 7
0
static VALUE
rb_ca_ubrep_bind (int argc, VALUE *argv, VALUE self)
{
  CAUnboundRepeat *ca;
  ca_size_t rep_spec[CA_RANK_MAX];
  int i;

  Data_Get_Struct(self, CAUnboundRepeat, ca);

  if ( ca->rep_rank != argc ) {
    rb_raise(rb_eArgError, "invalid new_rank");
  }
  for (i=0; i<argc; i++) {
    if ( ca->rep_dim[i] == 0 ) {
      rep_spec[i] = NUM2SIZE(argv[i]);
    }
    else {
      rep_spec[i] = 0;
    }
  }

  return rb_ca_repeat_new(self, argc, rep_spec);
}
Exemplo n.º 8
0
static VALUE
//iter_struct_inspect(na_loop_t *const lp)
iter_struct_inspect(char *ptr, size_t pos, VALUE opt)
{
    VALUE   types, defs, def, name, elmt, vary, v, x;
    size_t  ofs;
    long    i, len;
    narray_view_t *ne;

    types = RARRAY_PTR(opt)[0];
    defs = RARRAY_PTR(opt)[1];

    len = RARRAY_LEN(types);
    vary = rb_ary_new2(len);

    for (i=0; i<len; i++) {
        def  = RARRAY_PTR(defs)[i];
        name = RARRAY_PTR(def)[0];
        ofs  = NUM2SIZE(RARRAY_PTR(def)[2]);
        elmt = RARRAY_PTR(types)[i];
        GetNArrayView(elmt,ne);
        ne->offset = pos + ofs;
        v = rb_str_concat(rb_sym_to_s(name), rb_str_new2(": "));
        x = rb_funcall(elmt, rb_intern("format_to_a"), 0);        // <-- fix me
        if (ne->base.ndim==0) {
            x = rb_funcall(x, rb_intern("first"), 0);
        }
        x = rb_funcall(x, rb_intern("to_s"), 0);
        v = rb_str_concat(v, x);
        rb_ary_push(vary, v);
    }
    v = rb_ary_join(vary, rb_str_new2(", "));
    v = rb_str_concat(rb_str_new2("["), v);
    v = rb_str_concat(v, rb_str_new2("]"));
    return v;
}
Exemplo n.º 9
0
void
nary_step_sequence( VALUE self, size_t *plen, double *pbeg, double *pstep )
{
    VALUE vbeg, vend, vstep, vlen;
    double dbeg, dend, dstep=1, dsize, err;
    size_t size, n;

    //vbeg = rb_ivar_get(self, id_beg);
    vbeg = rb_funcall(self, id_beg, 0);
    dbeg = NUM2DBL(vbeg);

    //vend = rb_ivar_get(self, id_end);
    vend = rb_funcall(self, id_end, 0);

    vlen = rb_ivar_get(self, id_len);
    vstep = rb_ivar_get(self, id_step);
    //vlen  = rb_funcall(self, id_len ,0);
    //vstep = rb_funcall(self, id_step,0);

    if (RTEST(vlen)) {
        size = NUM2SIZE(vlen);

        if (!RTEST(vstep)) {
            if (RTEST(vend)) {
                dend = NUM2DBL(vend);
                if (EXCL(self)) {
                    n = size;
                } else {
                    n = size-1;
                }
                if (n>0) {
                    dstep = (dend-dbeg)/n;
                } else {
                    dstep = 1;
                }
            } else {
                dstep = 1;
            }
        }
    } else {
        if (!RTEST(vstep)) {
            dstep = 1;
        } else {
            dstep = NUM2DBL(vstep);
        }
        if (RTEST(vend)) {
            dend = NUM2DBL(vend);
            err = (fabs(dbeg)+fabs(dend)+fabs(dend-dbeg))/fabs(dstep)*DBL_EPSILON;
            if (err>0.5) err=0.5;
            dsize = (dend-dbeg)/dstep;
            if (EXCL(self))
                dsize -= err;
            else
                dsize += err;
            dsize = floor(dsize) + 1;
            if (dsize<0) dsize=0;
            if (isinf(dsize) || isnan(dsize)) {
                rb_raise(rb_eArgError, "not finite size");
            }
            size = dsize;
        } else {
            rb_raise(rb_eArgError, "cannot determine length argument");
        }
    }

    if (plen) *plen = size;
    if (pbeg) *pbeg = dbeg;
    if (pstep) *pstep = dstep;
}
Exemplo n.º 10
0
void
nary_step_array_index(VALUE self, size_t ary_size,
                      size_t *plen, ssize_t *pbeg, ssize_t *pstep)
{
    size_t len;
    ssize_t beg=0, step=1;
    VALUE vbeg, vend, vstep, vlen;
    ssize_t end=ary_size;

    //vbeg = rb_ivar_get(self, id_beg);
    //vend = rb_ivar_get(self, id_end);
    vlen = rb_ivar_get(self, id_len);
    vstep = rb_ivar_get(self, id_step);
    vbeg = rb_funcall(self, id_beg, 0);
    vend = rb_funcall(self, id_end, 0);
    //vlen = rb_funcall(self, id_len, 0);
    //vstep = rb_funcall(self, id_step, 0);

    if (RTEST(vbeg)) {
        beg = NUM2SSIZE(vbeg);
        if (beg<0) {
            beg += ary_size;
        }
    }
    if (RTEST(vend)) {
        end = NUM2SSIZE(vend);
        if (end<0) {
            end += ary_size;
        }
    }

    //puts("pass 1");

    if (RTEST(vlen)) {
        len = NUM2SIZE(vlen);
        if (len>0) {
            if (RTEST(vstep)) {
                step = NUM2SSIZE(step);
                if (RTEST(vbeg)) {
                    if (RTEST(vend)) {
                        rb_raise( rb_eStandardError, "verbose Step object" );
                    } else {
                        end = beg + step*(len-1);
                    }
                } else {
                    if (RTEST(vend)) {
                        if (EXCL(self)) {
                            if (step>0) end--;
                            if (step<0) end++;
                        }
                        beg = end - step*(len-1);
                    } else {
                        beg = 0;
                        end = step*(len-1);
                    }
                }
            } else { // no step
                step = 1;
                if (RTEST(vbeg)) {
                    if (RTEST(vend)) {
                        if (EXCL(self)) {
                            if (beg<end) end--;
                            if (beg>end) end++;
                        }
                        if (len>1)
                            step = (end-beg)/(len-1);
                    } else {
                        end = beg + (len-1);
                    }
                } else {
                    if (RTEST(vend)) {
                        if (EXCL(self)) {
                            end--;
                        }
                        beg = end - (len-1);
                    } else {
                        beg = 0;
                        end = len-1;
                    }
                }
            }
        }
    } else { // no len
        if (RTEST(vstep)) {
            step = NUM2SSIZE(vstep);
        } else {
            step = 1;
        }
        if (step>0) {
            if (!RTEST(vbeg)) {
                beg = 0;
            }
            if (!RTEST(vend)) {
                end = ary_size-1;
            }
            else if (EXCL(self)) {
                end--;
            }
            if (beg<=end) {
                len = (end-beg)/step+1;
            } else {
                len = 0;
            }
        } else if (step<0) {
            if (!RTEST(vbeg)) {
                beg = ary_size-1;
            }
            if (!RTEST(vend)) {
                end = 0;
            }
            else if (EXCL(self)) {
                end++;
            }
            if (beg>=end) {
                len = (beg-end)/(-step)+1;
            } else {
                len = 0;
            }
        } else {
            rb_raise( rb_eStandardError, "step must be non-zero" );
        }
    }

    //puts("pass 2");

    if (beg<0 || beg>=(ssize_t)ary_size ||
        end<0 || end>=(ssize_t)ary_size) {
        rb_raise( rb_eRangeError,
                  "beg=%"SZF"d,end=%"SZF"d is out of array size (%"SZF"u)",
                  beg, end, ary_size );
    }
    if (plen) *plen = len;
    if (pbeg) *pbeg = beg;
    if (pstep) *pstep = step;
}
Exemplo n.º 11
0
size_t
na_dtype_elmsz(VALUE klass)
{
    return NUM2SIZE(rb_const_get(klass, id_contiguous_stride));
}
Exemplo n.º 12
0
size_t
na_get_elmsz(VALUE vna)
{
    return NUM2SIZE(rb_const_get(CLASS_OF(vna), id_contiguous_stride));
}
Exemplo n.º 13
0
VALUE
na_make_view_struct(VALUE self, VALUE dtype, VALUE offset)
{
    size_t i, n;
    int j, k, ndim;
    size_t *shape;
    size_t *idx1, *idx2;
    ssize_t stride;
    stridx_t *stridx;
    narray_t *na, *nt;
    narray_view_t *na1, *na2;
    VALUE klass;
    volatile VALUE view;

    GetNArray(self,na);

    // build from NArray::Struct
    if (rb_obj_is_kind_of(dtype,cNArray)) {
	GetNArray(dtype,nt);
        ndim = na->ndim + nt->ndim;
        shape = ALLOCA_N(size_t,ndim);
        // struct dimensions
        for (j=0; j<na->ndim; j++) {
            shape[j] = na->shape[j];
        }
        // member dimension
        for (j=na->ndim,k=0; j<ndim; j++,k++) {
            shape[j] = nt->shape[k];
        }
        klass = CLASS_OF(dtype);
        stridx = ALLOC_N(stridx_t, ndim);
        stride = na_dtype_elmsz(klass);
        for (j=ndim,k=nt->ndim; k; ) {
            SDX_SET_STRIDE(stridx[--j],stride);
            stride *= nt->shape[--k];
        }
    } else {
        ndim = na->ndim;
        shape = ALLOCA_N(size_t,ndim);
        for (j=0; j<ndim; j++) {
            shape[j] = na->shape[j];
        }
        klass = CLASS_OF(self);
        if (TYPE(dtype)==T_CLASS) {
            if (RTEST(rb_class_inherited_p(dtype,cNArray))) {
                klass = dtype;
            }
        }
        stridx = ALLOC_N(stridx_t, ndim);
    }

    view = na_s_allocate_view(klass);
    na_copy_flags(self, view);
    GetNArrayView(view, na2);
    na_setup_shape((narray_t*)na2, ndim, shape);
    na2->stridx = stridx;

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

    if (RTEST(offset)) {
        na2->offset += NUM2SIZE(offset);
    }

    return view;
}
Exemplo n.º 14
0
static VALUE
nstruct_add_type(VALUE type, int argc, VALUE *argv, VALUE nst)
{
    VALUE ofs, size;
    ID id;
    int i;
    VALUE name=Qnil;
    size_t *shape=NULL;
    int ndim=0;
    ssize_t stride;
    narray_view_t *nt;
    int j;

    for (i=0; i<argc; i++) {
        switch(TYPE(argv[i])) {
        case T_STRING:
        case T_SYMBOL:
            if (NIL_P(name)) {
                name = argv[i];
                break;
            }
            rb_raise(rb_eArgError,"multiple name in struct definition");
        case T_ARRAY:
            if (shape) {
                rb_raise(rb_eArgError,"multiple shape in struct definition");
            }
            ndim = RARRAY_LEN(argv[i]);
            if (ndim > NA_MAX_DIMENSION) {
                rb_raise(rb_eArgError,"too large number of dimensions");
            }
            if (ndim == 0) {
                rb_raise(rb_eArgError,"array is empty");
            }
            shape = ALLOCA_N(size_t, ndim);
            na_array_to_internal_shape(Qnil, argv[i], shape);
            break;
        }
    }

    id = rb_to_id(name);
    name = ID2SYM(id);
    if (rb_obj_is_kind_of(type,cNArray)) {
        narray_t *na;
        GetNArray(type,na);
        type = CLASS_OF(type);
        ndim = na->ndim;
        shape = na->shape;
    }
    type = rb_narray_view_new(type,ndim,shape);
    GetNArrayView(type,nt);

    nt->stridx = ALLOC_N(stridx_t,ndim);
    stride = na_dtype_elmsz(CLASS_OF(type));
    for (j=ndim; j--; ) {
        SDX_SET_STRIDE(nt->stridx[j], stride);
        stride *= shape[j];
    }

    ofs  = rb_iv_get(nst, "__offset__");
    nt->offset = NUM2SIZE(ofs);

    size = rb_funcall(type, rb_intern("byte_size"), 0);
    rb_iv_set(nst, "__offset__", rb_funcall(ofs,'+',1,size));
    rb_ary_push(rb_iv_get(nst,"__members__"),
                rb_ary_new3(4,name,type,ofs,size));  // <- field definition
    return Qnil;
}