自学教程：C++ GetNArray函数代码示例

/*  Equality of self and other in view of numerical array.  i.e., both arrays have same shape and corresponding elements are equal.  @overload == other  @param [Object] other  @return [Boolean] true if self and other is equal.*/VALUEna_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;}

/* @overload initialize( inputs, targets ) * Creates a new dataset from example data. * @param [NArray<sfloat>] inputs the input examples that a nn_model will process * @param [NArray<sfloat>] targets known outputs that can be used to train or assess a nn_model * @return [RuNeNe::DataSet] new dataset */VALUE dataset_class_initialize( VALUE self, VALUE rv_inputs, VALUE rv_targets ) {  volatile VALUE val_inputs;  volatile VALUE val_targets;  struct NARRAY *na_inputs;  struct NARRAY *na_targets;  DataSet *dataset = get_dataset_struct( self );  val_inputs = na_cast_object( rv_inputs, NA_SFLOAT );  GetNArray( val_inputs, na_inputs );  val_targets = na_cast_object( rv_targets, NA_SFLOAT );  GetNArray( val_targets, na_targets );  if ( na_inputs->rank < 2 ) {    rb_raise( rb_eArgError, "Inputs rank should be at least 2, but got %d", na_inputs->rank );  }  if ( na_targets->rank < 2 ) {    rb_raise( rb_eArgError, "Targets rank should be at least 2, but got %d", na_targets->rank );  }  if ( na_inputs->shape[ na_inputs->rank - 1 ] != na_targets->shape[ na_targets->rank - 1 ] ) {    rb_raise( rb_eArgError, "Number of input items %d not same as target items %d",        na_inputs->shape[ na_inputs->rank - 1 ], na_targets->shape[ na_targets->rank - 1 ] );  }  dataset__init_from_narray( dataset, val_inputs, val_targets );  return self;}

/* @overload run( input ) * Runs nn_model forward and generates a result * @param [NArray<sfloat>] input single input vector * @return [NArray<sfloat>] output of nn_model */VALUE nn_model_rbobject__run( VALUE self, VALUE rv_input ) {  NNModel *nn_model = get_nn_model_struct( self );  int out_shape[1] = { nn_model->num_outputs };  struct NARRAY *na_input;  volatile VALUE val_input = na_cast_object(rv_input, NA_SFLOAT);  GetNArray( val_input, na_input );  // Shouldn't happen, but we don't want a segfault  if ( nn_model->num_layers < 1 ) {    return Qnil;  }  if ( na_input->total != nn_model->num_inputs ) {    rb_raise( rb_eArgError, "Input array must be size %d, but it was size %d", nn_model->num_inputs, na_input->total );  }  struct NARRAY *na_output;  volatile VALUE val_output = na_make_object( NA_SFLOAT, 1, out_shape, cNArray );  GetNArray( val_output, na_output );  nn_model__run( nn_model, (float*) na_input->ptr );  memcpy( (float*) na_output->ptr, nn_model->activations[nn_model->num_layers-1], nn_model->num_outputs * sizeof(float) );  return val_output;}

static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya){  rb_gsl_spline *sp = NULL;  gsl_spline *p = NULL;  gsl_vector *xa = NULL, *ya = NULL;  size_t i, size;  int flagx = 0, flagy = 0;  double *ptr1 = NULL, *ptr2 = NULL;#ifdef HAVE_NARRAY_H  struct NARRAY *nax = NULL, *nay = NULL;#endif  Data_Get_Struct(obj, rb_gsl_spline, sp);  p = sp->s;  if (TYPE(xxa) == T_ARRAY) {    size = RARRAY_LEN(xxa);    xa = gsl_vector_alloc(size);    for (i = 0; i < size; i++) gsl_vector_set(xa, i, NUM2DBL(rb_ary_entry(xxa, i)));    ptr1 = xa->data;    flagx = 1;  } else if (VECTOR_P(xxa)) {    Data_Get_Struct(xxa, gsl_vector, xa);    size = xa->size;    ptr1 = xa->data;#ifdef HAVE_NARRAY_H  } else if (NA_IsNArray(xxa)) {      GetNArray(xxa, nax);      size = nax->total;      ptr1 = (double *) nax->ptr;#endif  } else {    rb_raise(rb_eTypeError, "not a vector");  }  if (TYPE(yya) == T_ARRAY) {    ya = gsl_vector_alloc(size);    for (i = 0; i < size; i++) gsl_vector_set(ya, i, NUM2DBL(rb_ary_entry(yya, i)));    ptr2 = ya->data;    flagy = 1;#ifdef HAVE_NARRAY_H  } else if (NA_IsNArray(yya)) {      GetNArray(yya, nay);      ptr2 = (double *) nay->ptr;#endif  } else if (VECTOR_P(yya)) {    Data_Get_Struct(yya, gsl_vector, ya);    ptr2 = ya->data;  } else {    rb_raise(rb_eTypeError, "not a vector");  }  gsl_spline_init(p, ptr1, ptr2, size);  if (flagx == 1) gsl_vector_free(xa);  if (flagy == 1) gsl_vector_free(ya);  return obj;}

voidna_copy_flags(VALUE src, VALUE dst){    narray_t *na1, *na2;    GetNArray(src,na1);    GetNArray(dst,na2);    na2->flag[0] = na1->flag[0];    na2->flag[1] = na1->flag[1];    RBASIC(dst)->flags |= (RBASIC(src)->flags) &        (FL_USER1|FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6|FL_USER7);}

void mbgd_layer__deep_copy( MBGDLayer *mbgd_layer_copy, MBGDLayer *mbgd_layer_orig ) {    struct NARRAY *narr;    GradientDescent_SGD * gd_sgd;    GradientDescent_NAG * gd_nag;    GradientDescent_RMSProp * gd_rmsprop;    mbgd_layer_copy->num_inputs = mbgd_layer_orig->num_inputs;    mbgd_layer_copy->num_outputs = mbgd_layer_orig->num_outputs;    mbgd_layer_copy->learning_rate = mbgd_layer_orig->learning_rate;    mbgd_layer_copy->gradient_descent_type = mbgd_layer_orig->gradient_descent_type;    switch ( mbgd_layer_copy->gradient_descent_type ) {    case GD_TYPE_SGD:        Data_Get_Struct( mbgd_layer_orig->gradient_descent, GradientDescent_SGD, gd_sgd );        mbgd_layer_copy->gradient_descent = Data_Wrap_Struct( RuNeNe_GradientDescent_SGD,                                            gd_sgd__gc_mark, gd_sgd__destroy, gd_sgd__clone( gd_sgd ) );        break;    case GD_TYPE_NAG:        Data_Get_Struct( mbgd_layer_orig->gradient_descent, GradientDescent_NAG, gd_nag );        mbgd_layer_copy->gradient_descent = Data_Wrap_Struct( RuNeNe_GradientDescent_NAG,                                            gd_nag__gc_mark, gd_nag__destroy, gd_nag__clone( gd_nag ) );        break;    case GD_TYPE_RMSPROP:        Data_Get_Struct( mbgd_layer_orig->gradient_descent, GradientDescent_RMSProp, gd_rmsprop );        mbgd_layer_copy->gradient_descent = Data_Wrap_Struct( RuNeNe_GradientDescent_RMSProp,                                            gd_rmsprop__gc_mark, gd_rmsprop__destroy, gd_rmsprop__clone( gd_rmsprop ) );        break;    }    mbgd_layer_copy->max_norm = mbgd_layer_orig->max_norm;    mbgd_layer_copy->weight_decay = mbgd_layer_orig->weight_decay;    mbgd_layer_copy->narr_de_dz = na_clone( mbgd_layer_orig->narr_de_dz );    GetNArray( mbgd_layer_copy->narr_de_dz, narr );    mbgd_layer_copy->de_dz = (float *) narr->ptr;    mbgd_layer_copy->narr_de_da = na_clone( mbgd_layer_orig->narr_de_da );    GetNArray( mbgd_layer_copy->narr_de_da, narr );    mbgd_layer_copy->de_da = (float *) narr->ptr;    mbgd_layer_copy->narr_de_dw = na_clone( mbgd_layer_orig->narr_de_dw );    GetNArray( mbgd_layer_copy->narr_de_dw, narr );    mbgd_layer_copy->de_dw = (float *) narr->ptr;    return;}

//// NArray#load_from_shmemutex(shmemutex,timeout=-1)//VALUE rb_NArray_load_from_shmemutex(int argc,VALUE *argv,VALUE self){    VALUE shm,timeout;    struct NARRAY *n_na;    ShMemutex *ptr;    long to=-1;    size_t sz;    if(rb_scan_args(argc,argv,"11",&shm,&timeout)==2)        to=NUM2LONG(timeout);    if(rb_obj_is_kind_of(shm,                         rb_const_get(rb_cObject,                                      rb_intern("ShMemutex")))!=Qtrue)        rb_raise(rb_eTypeError,"1st. argument must be ShMemutex object.");    Data_Get_Struct(shm,ShMemutex,ptr);        GetNArray(self,n_na);    sz=n_na->total*na_sizeof[n_na->type];    if(!sz)        rb_raise(rb_eTypeError,"NArray size is too small");    ptr->read(n_na->ptr,sz,to);    return self;}

//// ShMemutex::write(src,timeout=-1)//VALUE rb_ShMemutex_write(int argc,VALUE *argv,VALUE self){    VALUE src,timeout;    struct NARRAY *n_na;    ShMemutex *ptr;    long to=-1;    void *buf;    size_t sz;    if(rb_scan_args(argc,argv,"11",&src,&timeout)==2)        to=NUM2LONG(timeout);    Data_Get_Struct(self,ShMemutex,ptr);    if(IsNArray(src)){        GetNArray(src,n_na);        sz=n_na->total*na_sizeof[n_na->type];        buf=(void *)n_na->ptr;    }    else{        StringValue(src);        sz=RSTRING(src)->len+1;        buf=RSTRING(src)->ptr;    }    if((!sz)||(!buf))        return INT2FIX(0);        return INT2NUM(ptr->write(buf,sz,to));}

/* @overload init_weights( mult = 1.0 ) * Initialises weights in all layers. * @param [Float] mult optional size factor * @return [RuNeNe::NNModel] self */VALUE nn_model_rbobject__init_weights( int argc, VALUE* argv, VALUE self ) {  NNModel *nn_model = get_nn_model_struct( self );  VALUE rv_mult;  Layer_FF *layer_ff;  float m = 1.0;  int i, j, t;  struct NARRAY *narr;  rb_scan_args( argc, argv, "01", &rv_mult );  if ( ! NIL_P( rv_mult ) ) {    m = NUM2FLT( rv_mult );  }  for ( i = 0; i < nn_model->num_layers; i++ ) {    // TODO: This only works for Layer_FF layers, we need a more flexible system    Data_Get_Struct( nn_model->layers[i], Layer_FF, layer_ff );    layer_ff__init_weights( layer_ff );    if ( m != 0 ) {      GetNArray( layer_ff->narr_weights, narr );      t = narr->total;      for ( j = 0; j < t; j++ ) {        layer_ff->weights[j] *= m;      }    }  }  return self;}

static intna_get_result_dimension_for_slice(VALUE self, int argc, VALUE *argv){    int i;    int count_new=0;    int count_rest=0;    narray_t *na;    VALUE a;    GetNArray(self,na);    if (na->size == 0) {        rb_raise(nary_eShapeError, "cannot get element of empty array");    }    for (i=0; i<argc; i++) {        a = argv[i];        switch(TYPE(a)) {        case T_FALSE:        case T_SYMBOL:            if (a==sym_rest || a==sym_tilde || a==Qfalse) {                argv[i] = Qfalse;                count_rest++;            } else if (a==sym_new || a==sym_minus) {                argv[i] = sym_new;                count_new++;            }        }    }    return check_index_count(argc, na->ndim, count_new, count_rest);}

VALUErb_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;}

voidna_setup(VALUE self, int ndim, size_t *shape){    narray_t *na;    GetNArray(self,na);    na_setup_shape(na, ndim, shape);}

static VALUEnary_struct_cast_array(VALUE klass, VALUE rary){    volatile VALUE vnc, nary;    narray_t *na;    na_compose_t *nc;    VALUE opt;    ndfunc_arg_in_t ain[3] = {{rb_cArray,0},{Qnil,0},{sym_option}};    ndfunc_t ndf = { iter_nstruct_from_a, NO_LOOP, 3, 0, ain, 0 };    //fprintf(stderr,"rary:");rb_p(rary);    //fprintf(stderr,"class_of(rary):");rb_p(CLASS_OF(rary));    vnc = na_ary_composition_for_struct(klass, rary);    Data_Get_Struct(vnc, na_compose_t, nc);    nary = rb_narray_new(klass, nc->ndim, nc->shape);    GetNArray(nary,na);    //fprintf(stderr,"na->size=%lu/n",na->size);    //fprintf(stderr,"na->ndim=%d/n",na->ndim);    if (na->size>0) {        opt = nst_create_member_views(nary);        rb_funcall(nary, rb_intern("allocate"), 0);        na_ndloop_cast_rarray_to_narray2(&ndf, rary, nary, opt);    }    return nary;}

static VALUEnst_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), rb_intern("element_byte_size"));            ptr = xmalloc(NUM2SIZET(velmsz) * na->size);            NA_DATA_PTR(na) = ptr;        }        break;    case NARRAY_VIEW_T:        rb_funcall(NA_VIEW_DATA(na), rb_intern("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;}

static size_tcheck_array_1d(VALUE item, size_t size) {    narray_t *na;    size_t i, len;    if (TYPE(item) == T_ARRAY) {        len = RARRAY_LEN(item);        if (size != len) {            return 0;        }        for (i=0; i<len; i++) {            if (!check_array(RARRAY_AREF(item,i))) {                return 0;            }        }        return 1;    }    if (RTEST(rb_obj_is_kind_of(item, cNArray))) {        GetNArray(item,na);        if (na->ndim == 1 && na->size == size) {            return 1;        } else {            return 0;        }    }    return 0;}

/* method: size() -- returns the total number of typeents */static VALUEna_ndim(VALUE self){    narray_t *na;    GetNArray(self,na);    return INT2NUM(na->ndim);}

voidna_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;    }}

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);    }    if (NA_SIZE(na) > 0 && ptr == NULL) {        rb_raise(rb_eRuntimeError,"cannot read unallocated NArray");    }    //NA_SET_LOCK(na);    return ptr;}

/* method: size() -- returns the total number of typeents */static VALUEna_size(VALUE self){    narray_t *na;    GetNArray(self,na);    return SIZE2NUM(na->size);}

char *na_get_pointer_for_write(VALUE self){    char *ptr;    narray_t *na;    GetNArray(self,na);    if (OBJ_FROZEN(self)) {        rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");    }    if (NA_TYPE(na) == 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");        }    }    //NA_SET_LOCK(na);    return ptr;}

/* @overload from_weights( weights, transfer_label = :sigmoid ) * Creates a new layer using the supplied weights array, which must be rank 2. * The inputs and bias are taken from the first dimension, and each output is assigned * from the second dimension. For example an array with shape [5,3] has 4 inputs and * 3 outputs. * @param [NArray] weights * @param [Symbol] transfer_label type of transfer function to use. * @return [RuNeNe::Layer::FeedForward] new layer using supplied weights. */VALUE layer_ff_class_from_weights( int argc, VALUE* argv, VALUE self ) {  volatile VALUE weights_in, tfn_type;  struct NARRAY *na_weights;  volatile VALUE val_weights;  int i, o;  rb_scan_args( argc, argv, "11", &weights_in, &tfn_type );  val_weights = na_cast_object(weights_in, NA_SFLOAT);  GetNArray( val_weights, na_weights );  if ( na_weights->rank != 2 ) {    rb_raise( rb_eArgError, "Weights rank should be 2, but got %d", na_weights->rank );  }  i = na_weights->shape[0] - 1;  if ( i < 1 ) {    rb_raise( rb_eArgError, "Input size %d is less than minimum of 1", i );  }  o = na_weights->shape[1];  if ( o < 1 ) {    rb_raise( rb_eArgError, "Output size %d is less than minimum of 1", o );  }  return layer_ff_new_ruby_object_from_weights( val_weights, symbol_to_transfer_type( tfn_type ) );}

static voidna_parse_narray_index(VALUE a, int orig_dim, ssize_t size, na_index_arg_t *q){    VALUE idx;    narray_t *na;    narray_data_t *nidx;    size_t k, n;    ssize_t *nidxp;    GetNArray(a,na);    if (NA_NDIM(na) != 1) {        rb_raise(rb_eIndexError, "should be 1-d NArray");    }    n = NA_SIZE(na);    idx = nary_new(cIndex,1,&n);    na_store(idx,a);    GetNArrayData(idx,nidx);    nidxp   = (ssize_t*)nidx->ptr;    q->idx  = ALLOC_N(size_t, n);    for (k=0; k<n; k++) {        q->idx[k] = na_range_check(nidxp[k], size, orig_dim);    }    q->n    = n;    q->beg  = 0;    q->step = 1;    q->reduce = 0;    q->orig_dim = orig_dim;}

VALUEnst_check_compatibility(VALUE nst, VALUE ary){    VALUE defs, def, type, item;    long len, i;    narray_t *nt;    if (TYPE(ary) != T_ARRAY) {        if (nst==CLASS_OF(ary)) { // same Struct            return Qtrue;        }        return Qfalse;    }    defs = nst_definitions(nst);    len = RARRAY_LEN(defs);    if (len != RARRAY_LEN(ary)) {        //puts("pass2");        return Qfalse;    }    for (i=0; i<len; i++) {        def  = RARRAY_AREF(defs,i);        type = RARRAY_AREF(def,1);        GetNArray(type,nt);        item = RARRAY_AREF(ary,i);        if (nt->ndim == 0) {            if (check_array(item)) {                //puts("pass3");                return Qfalse;            }        } else if (nt->ndim == 1) {            if (!check_array_1d(item, nt->size)) {                //puts("pass4");                return Qfalse;            }        } else {            // multi-dimension member            volatile VALUE vnc;            na_compose_t *nc;            int j;            //rb_p(item);            vnc = na_ary_composition(item);            //puts("pass2");            Data_Get_Struct(vnc, na_compose_t, nc);            if (nt->ndim != nc->ndim) {                return Qfalse;            }            for (j=0; j<nc->ndim; j++) {                if (nc->shape[j] != nt->shape[j]) {                    return Qfalse;                }            }            return Qtrue;        }    }    return Qtrue;}

static VALUEna_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd){    VALUE args; // should be GC protected    narray_t *na1;    na_aref_md_data_t data;    VALUE store = 0;    VALUE idx;    narray_t *nidx;    GetNArray(self,na1);    args = rb_ary_new4(argc,argv);    if (argc == 1 && result_nd == 1) {        idx = argv[0];        if (rb_obj_is_kind_of(idx, rb_cArray)) {            idx = rb_apply(numo_cNArray,id_bracket,idx);        }        if (rb_obj_is_kind_of(idx, numo_cNArray)) {            GetNArray(idx,nidx);            if (NA_NDIM(nidx)>1) {                store = nary_new(CLASS_OF(self),NA_NDIM(nidx),NA_SHAPE(nidx));                idx = na_flatten(idx);                RARRAY_ASET(args,0,idx);            }        }        // flatten should be done only for narray-view with non-uniform stride.        if (na1->ndim > 1) {            self = na_flatten(self);            GetNArray(self,na1);        }    }    data.args = args;    data.self = self;    data.store = store;    data.ndim = result_nd;    data.q = na_allocate_index_args(result_nd);    data.na1 = na1;    data.keep_dim = keep_dim;    return rb_ensure(na_aref_md_protected, (VALUE)&data, na_aref_md_ensure, (VALUE)&data);}

VALUE na_address(VALUE self) {  struct NARRAY *ary;  void * ptr;  VALUE ret;  GetNArray(self,ary);  ptr = ary->ptr;  ret = ULL2NUM( sizeof(ptr) == 4 ? (unsigned long long int) (unsigned long int) ptr : (unsigned long long int) ptr );  return ret;}

static void na_mark_ref(struct NARRAY *ary){  struct NARRAY *a2;  rb_gc_mark( ary->ref );  GetNArray(ary->ref,a2);  if (a2->type == NA_ROBJ) na_mark_obj(a2);}

VALUE rb_rim_ipl2image(IplImage *img){    struct NARRAY *n_na;    ID func;    switch(img->depth){    case IPL_DEPTH_8U:    case IPL_DEPTH_8S:        func=rb_intern("byte");        break;    case IPL_DEPTH_16U:    case IPL_DEPTH_16S:        func=rb_intern("sint");        break;    case IPL_DEPTH_32S:        func=rb_intern("lint");        break;    case IPL_DEPTH_32F:        func=rb_intern("sfloat");        break;    case IPL_DEPTH_64F:        func=rb_intern("dfloat");        break;    default:        return NULL;    }    VALUE oRimImage=        rb_funcall(rb_const_get(rb_const_get(rb_cObject,rb_intern("Rim")),                                rb_intern("Image")),                   func,                   3,                   INT2FIX(img->nChannels),                   INT2FIX(img->width),                   INT2FIX(img->height));        GetNArray(oRimImage,n_na);    size_t lineWidth=img->nChannels*img->width*na_sizeof[n_na->type];    size_t sz=n_na->total*na_sizeof[n_na->type];    if((img->widthStep==lineWidth)&&(img->imageSize==sz)){        memcpy(n_na->ptr,img->imageData,sz);    }    else{        char *src,*dst;        int i;        for(i=0,src=img->imageData,dst=n_na->ptr;            i<img->height;            i++,src+=img->widthStep,dst+=lineWidth)            memcpy(dst,src,lineWidth);    }    return oRimImage;}

void mbgd_layer__init( MBGDLayer *mbgd_layer, int num_inputs, int num_outputs ) {    int i;    int shape[2];    struct NARRAY *narr;    float *narr_de_dz_ptr;    float *narr_de_da_ptr;    float *narr_de_dw_ptr;    mbgd_layer->num_inputs = num_inputs;    mbgd_layer->num_outputs = num_outputs;    shape[0] = num_outputs;    mbgd_layer->narr_de_dz = na_make_object( NA_SFLOAT, 1, shape, cNArray );    GetNArray( mbgd_layer->narr_de_dz, narr );    narr_de_dz_ptr = (float*) narr->ptr;    for( i = 0; i < narr->total; i++ ) {        narr_de_dz_ptr[i] = 0.0;    }    mbgd_layer->de_dz = (float *) narr->ptr;    shape[0] = num_inputs;    mbgd_layer->narr_de_da = na_make_object( NA_SFLOAT, 1, shape, cNArray );    GetNArray( mbgd_layer->narr_de_da, narr );    narr_de_da_ptr = (float*) narr->ptr;    for( i = 0; i < narr->total; i++ ) {        narr_de_da_ptr[i] = 0.0;    }    mbgd_layer->de_da = (float *) narr->ptr;    shape[0] = num_inputs + 1;    shape[1] = num_outputs;    mbgd_layer->narr_de_dw = na_make_object( NA_SFLOAT, 2, shape, cNArray );    GetNArray( mbgd_layer->narr_de_dw, narr );    narr_de_dw_ptr = (float*) narr->ptr;    for( i = 0; i < narr->total; i++ ) {        narr_de_dw_ptr[i] = 0.0;    }    mbgd_layer->de_dw = (float *) narr->ptr;    return;}

/*  Replaces the contents of self with the contents of other narray.  Used in dup and clone method.  @overload initialize_copy(other)  @param [Numo::NArray] other  @return [Numo::NArray] self */static VALUEna_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;}

/* *  call-seq: *     narray.view => narray * *  Return view of NArray */VALUEna_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;}