Class: Numo::Int8

Inherits:
NArray show all
Defined in:
ext/numo/narray/types/int8.c

Constant Summary collapse

UPCAST = 
hCast
ELEMENT_BIT_SIZE = 
INT2FIX(sizeof(dtype)*8)
ELEMENT_BYTE_SIZE = 
INT2FIX(sizeof(dtype))
CONTIGUOUS_STRIDE = 
INT2FIX(sizeof(dtype))
MAX = 
M_MAX
MIN = 
M_MIN

Constants inherited from NArray

NArray::VERSION

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from NArray

#==, #append, array_type, asarray, #at, byte_size, #byte_size, #byte_swapped?, #cast_to, #coerce, #column_major?, column_stack, concatenate, #concatenate, #contiguous?, #cov, debug=, #debug_info, #deg2rad, #delete, #diag, #diag_indices, diag_indices, #diagonal, #diff, #dot, #dsplit, dstack, #each_over_axis, #empty?, #expand_dims, eye, #flatten, #fliplr, #flipud, #fortran_contiguous?, #free, from_binary, #host_order?, #hsplit, hstack, #initialize, #initialize_copy, #inner, #inplace, #inplace!, #inplace?, #insert, inspect_cols, inspect_cols=, inspect_rows, inspect_rows=, #kron, linspace, logspace, #marshal_dump, #marshal_load, #ndim, #new_fill, new_like, #new_narray, #new_ones, #new_zeros, ones, #out_of_place!, #outer, parse, profile, profile=, #rad2deg, #repeat, #reshape, #reshape!, #reverse, #rot90, #row_major?, #shape, #size, #split, srand, #store_binary, #swap_byte, #swapaxes, #tile, #to_binary, #to_c, #to_f, #to_host, #to_i, #to_network, #to_swapped, #to_vacs, #trace, #transpose, #tril, #tril!, #tril_indices, tril_indices, #triu, #triu!, #triu_indices, triu_indices, upcast, #view, #vsplit, vstack, zeros

Constructor Details

This class inherits a constructor from Numo::NArray

Class Method Details

.[](elements) ⇒ Numo::Int8 .cast(array) ⇒ Numo::Int8

Cast object to Numo::Int8.

Parameters:

  • elements (Numeric, Array)
  • array (Array)

Returns:



1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
 
# File 'ext/numo/narray/types/int8.c', line 1278

static VALUE
int8_s_cast(VALUE type, VALUE obj)
{
    VALUE v;
    narray_t *na;
    dtype x;

    if (rb_obj_class(obj)==cT) {
        return obj;
    }
    if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
        x = m_num_to_data(obj);
        return int8_new_dim0(x);
    }
    if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
        return int8_cast_array(obj);
    }
    if (IsNArray(obj)) {
        GetNArray(obj,na);
        v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
        if (NA_SIZE(na) > 0) {
            int8_store(v,obj);
        }
        return v;
    }
    
#line 41 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cast.c"
    rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
    return Qnil;
    
}

.[](elements) ⇒ Numo::Int8 .cast(array) ⇒ Numo::Int8

Cast object to Numo::Int8.

Parameters:

  • elements (Numeric, Array)
  • array (Array)

Returns:



1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
 
# File 'ext/numo/narray/types/int8.c', line 1278

static VALUE
int8_s_cast(VALUE type, VALUE obj)
{
    VALUE v;
    narray_t *na;
    dtype x;

    if (rb_obj_class(obj)==cT) {
        return obj;
    }
    if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
        x = m_num_to_data(obj);
        return int8_new_dim0(x);
    }
    if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
        return int8_cast_array(obj);
    }
    if (IsNArray(obj)) {
        GetNArray(obj,na);
        v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
        if (NA_SIZE(na) > 0) {
            int8_store(v,obj);
        }
        return v;
    }
    
#line 41 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cast.c"
    rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
    return Qnil;
    
}

.maximum(*args) ⇒ Object 



4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
4617
4618
4619
4620
4621
 
# File 'ext/numo/narray/types/int8.c', line 4606

static VALUE
int8_s_maximum(int argc, VALUE *argv, VALUE mod)
{
    VALUE a1 = Qnil;
    VALUE a2 = Qnil;
    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout };

    
#line 60 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/ewcomp.c"
    rb_scan_args(argc, argv, "20", &a1, &a2);
    

    return na_ndloop(&ndf, 2, a1, a2);
}

.minimum(*args) ⇒ Object 



4657
4658
4659
4660
4661
4662
4663
4664
4665
4666
4667
4668
4669
4670
4671
4672
 
# File 'ext/numo/narray/types/int8.c', line 4657

static VALUE
int8_s_minimum(int argc, VALUE *argv, VALUE mod)
{
    VALUE a1 = Qnil;
    VALUE a2 = Qnil;
    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout };

    
#line 60 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/ewcomp.c"
    rb_scan_args(argc, argv, "20", &a1, &a2);
    

    return na_ndloop(&ndf, 2, a1, a2);
}

Instance Method Details

#%(other) ⇒ Numo::NArray

Binary mod.

Parameters:

Returns:



2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
 
# File 'ext/numo/narray/types/int8.c', line 2455

static VALUE
int8_mod(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_mod_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '%', 1, other);
    }
    
}

#&(other) ⇒ Numo::NArray

Binary bit_and.

Parameters:

Returns:



3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
 
# File 'ext/numo/narray/types/int8.c', line 3082

static VALUE
int8_bit_and(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_bit_and_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '&', 1, other);
    }
    
}

#*(other) ⇒ Numo::NArray

Binary mul.

Parameters:

Returns:



2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
 
# File 'ext/numo/narray/types/int8.c', line 2241

static VALUE
int8_mul(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_mul_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '*', 1, other);
    }
    
}

#**(other) ⇒ Numo::NArray

Binary power.

Parameters:

Returns:



2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
 
# File 'ext/numo/narray/types/int8.c', line 2597

static VALUE
int8_pow(VALUE self, VALUE other)
{
    
#line 69 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/pow.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_pow_self(self,other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_pow, 1, other);
    }
    
}

#+(other) ⇒ Numo::NArray

Binary add.

Parameters:

Returns:



2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
 
# File 'ext/numo/narray/types/int8.c', line 2035

static VALUE
int8_add(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_add_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '+', 1, other);
    }
    
}

#-(other) ⇒ Numo::NArray

Binary sub.

Parameters:

Returns:



2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
 
# File 'ext/numo/narray/types/int8.c', line 2138

static VALUE
int8_sub(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_sub_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '-', 1, other);
    }
    
}

#-@ ⇒ Numo::Int8

Unary minus.

Returns:



2669
2670
2671
2672
2673
2674
2675
2676
2677
 
# File 'ext/numo/narray/types/int8.c', line 2669

static VALUE
int8_minus(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_minus, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}

#/(other) ⇒ Numo::NArray

Binary div.

Parameters:

Returns:



2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
 
# File 'ext/numo/narray/types/int8.c', line 2348

static VALUE
int8_div(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_div_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '/', 1, other);
    }
    
}

#<<(other) ⇒ Numo::NArray

Binary left_shift.

Parameters:

Returns:



3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
 
# File 'ext/numo/narray/types/int8.c', line 3457

static VALUE
int8_left_shift(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_left_shift_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_left_shift, 1, other);
    }
    
}

#>>(other) ⇒ Numo::NArray

Binary right_shift.

Parameters:

Returns:



3560
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
 
# File 'ext/numo/narray/types/int8.c', line 3560

static VALUE
int8_right_shift(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_right_shift_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_right_shift, 1, other);
    }
    
}

#[](dim0, ..., dimL) ⇒ Numeric, Numo::Int8

Multi-dimensional element reference.

Parameters:

Returns:

  • (Numeric, Numo::Int8) —

    an element or NArray view.

See Also:



1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
 
# File 'ext/numo/narray/types/int8.c', line 1320

static VALUE
int8_aref(int argc, VALUE *argv, VALUE self)
{
    int nd;
    size_t pos;
    char *ptr;

    nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
    if (nd) {
        return na_aref_main(argc, argv, self, 0, nd);
    } else {
        ptr = na_get_pointer_for_read(self) + pos;
        return m_extract(ptr);
    }
}

#[]=(dim0, ..., dimL, val) ⇒ Numeric, ...

Multi-dimensional element assignment.

Parameters:

Returns:

  • (Numeric, Numo::NArray, Array) —

    returns val (last argument).

See Also:



1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
 
# File 'ext/numo/narray/types/int8.c', line 1347

static VALUE
int8_aset(int argc, VALUE *argv, VALUE self)
{
    int nd;
    size_t pos;
    char *ptr;
    VALUE a;
    dtype x;

    argc--;
    if (argc==0) {
        int8_store(self, argv[argc]);
    } else {
        nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
        if (nd) {
            a = na_aref_main(argc, argv, self, 0, nd);
            int8_store(a, argv[argc]);
        } else {
            x = int8_extract_data(argv[argc]);
            ptr = na_get_pointer_for_read_write(self) + pos;
            *(dtype*)ptr = x;
        }

    }
    return argv[argc];
}

#^(other) ⇒ Numo::NArray

Binary bit_xor.

Parameters:

Returns:



3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
 
# File 'ext/numo/narray/types/int8.c', line 3288

static VALUE
int8_bit_xor(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_bit_xor_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '^', 1, other);
    }
    
}

#abs ⇒ Numo::Int8

abs of self.

Returns:



1939
1940
1941
1942
1943
1944
1945
1946
1947
 
# File 'ext/numo/narray/types/int8.c', line 1939

static VALUE
int8_abs(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cRT,0}};
    ndfunc_t ndf = { iter_int8_abs, FULL_LOOP, 1, 1, ain, aout };

    return na_ndloop(&ndf, 1, self);
}

#allocate ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'ext/numo/narray/types/int8.c', line 143

static VALUE
int8_allocate(VALUE self)
{
    narray_t *na;
    char *ptr;

    GetNArray(self,na);

    switch(NA_TYPE(na)) {
    case NARRAY_DATA_T:
        ptr = NA_DATA_PTR(na);
        if (na->size > 0 && ptr == NULL) {
            ptr = xmalloc(sizeof(dtype) * na->size);
            
#line 22 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/allocate.c"
            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;
}

#argmax(axis: nil) ⇒ Integer, Numo::Int

Index of the maximum value.

Examples:

a = Numo::NArray[3,4,1,2]
a.argmax  #=> 1

b = Numo::NArray[[3,4,1],[2,0,5]]
b.argmax                       #=> 5
b.argmax(axis:1)               #=> [1, 2]
b.argmax(axis:0)               #=> [0, 0, 1]
b.at(b.argmax(axis:0), 0..-1)  #=> [3, 4, 5]

Parameters:

  • axis (Numeric, Array, Range) —

    Finds maximum values along the axis and returns indices along the axis.

Returns:

  • (Integer, Numo::Int) —

    returns the result indices.

See Also:



4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
 
# File 'ext/numo/narray/types/int8.c', line 4405

static VALUE
int8_argmax(int argc, VALUE *argv, VALUE self)
{
    narray_t *na;
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{0,0,0}};
    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,1, ain,aout};

    GetNArray(self,na);
    if (na->ndim==0) {
        return INT2FIX(0);
    }
    if (na->size > (~(u_int32_t)0)) {
        aout[0].type = numo_cInt64;
        ndf.func = iter_int8_argmax_arg64;
      
#line 75 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_arg.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    } else {
        aout[0].type = numo_cInt32;
        ndf.func = iter_int8_argmax_arg32;
      
#line 83 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_arg.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    }

    return na_ndloop(&ndf, 2, self, reduce);
}

#argmin(axis: nil) ⇒ Integer, Numo::Int

Index of the minimum value.

Examples:

a = Numo::NArray[3,4,1,2]
a.argmin  #=> 2

b = Numo::NArray[[3,4,1],[2,0,5]]
b.argmin                       #=> 4
b.argmin(axis:1)               #=> [2, 1]
b.argmin(axis:0)               #=> [1, 1, 0]
b.at(b.argmin(axis:0), 0..-1)  #=> [2, 0, 1]

Parameters:

  • axis (Numeric, Array, Range) —

    Finds minimum values along the axis and returns indices along the axis.

Returns:

  • (Integer, Numo::Int) —

    returns the result indices.

See Also:



4497
4498
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
 
# File 'ext/numo/narray/types/int8.c', line 4497

static VALUE
int8_argmin(int argc, VALUE *argv, VALUE self)
{
    narray_t *na;
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{0,0,0}};
    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,1, ain,aout};

    GetNArray(self,na);
    if (na->ndim==0) {
        return INT2FIX(0);
    }
    if (na->size > (~(u_int32_t)0)) {
        aout[0].type = numo_cInt64;
        ndf.func = iter_int8_argmin_arg64;
      
#line 75 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_arg.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    } else {
        aout[0].type = numo_cInt32;
        ndf.func = iter_int8_argmin_arg32;
      
#line 83 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_arg.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    }

    return na_ndloop(&ndf, 2, self, reduce);
}

#bincount([weight], minlength: nil) ⇒ UInt32 or UInt64 or SFloat or DFloat

Count the number of occurrences of each non-negative integer value. Only Integer-types has this method.

Examples:

Numo::Int32[0..4].bincount
# => Numo::UInt32#shape=[5]
# [1, 1, 1, 1, 1]

Numo::Int32[0, 1, 1, 3, 2, 1, 7].bincount
# => Numo::UInt32#shape=[8]
# [1, 3, 1, 1, 0, 0, 0, 1]

x = Numo::Int32[0, 1, 1, 3, 2, 1, 7, 23]
x.bincount.size == x.max+1
# => true

w = Numo::DFloat[0.3, 0.5, 0.2, 0.7, 1.0, -0.6]
x = Numo::Int32[0, 1, 1, 2, 2, 2]
x.bincount(w)
# => Numo::DFloat#shape=[3]
# [0.3, 0.7, 1.1]

Parameters:

  • weight (SFloat or DFloat or Array) —

    (optional) Array of float values. Its size along last axis should be same as that of self.

  • minlength (Integer) —

    (keyword, optional) Minimum size along last axis for the output array.

Returns:

  • (UInt32 or UInt64 or SFloat or DFloat) —

    Returns Float NArray if weight array is supplied, otherwise returns UInt32 or UInt64 depending on the size along last axis.



4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
 
# File 'ext/numo/narray/types/int8.c', line 4892

static VALUE
int8_bincount(int argc, VALUE *argv, VALUE self)
{
    VALUE weight=Qnil, kw=Qnil;
    VALUE opts[1] = {Qundef};
    VALUE v, wclass;
    ID table[1] = {id_minlength};
    size_t length, minlength;

    rb_scan_args(argc, argv, "01:", &weight, &kw);
    rb_get_kwargs(kw, table, 0, 1, opts);

  
#line 151 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/bincount.c"
    v = int8_minmax(0,0,self);
    if (m_num_to_data(RARRAY_AREF(v,0)) < 0) {
        rb_raise(rb_eArgError,"array items must be non-netagive");
    }
    v = RARRAY_AREF(v,1);
  
    length = NUM2SIZET(v) + 1;

    if (opts[0] != Qundef) {
        minlength = NUM2SIZET(opts[0]);
        if (minlength > length) {
            length = minlength;
        }
    }

    if (NIL_P(weight)) {
        if (length > 4294967295ul) {
            return int8_bincount_64(self, length);
        } else {
            return int8_bincount_32(self, length);
        }
    } else {
        wclass = rb_obj_class(weight);
        if (wclass == numo_cSFloat) {
            return int8_bincount_sf(self, weight, length);
        } else {
            return int8_bincount_df(self, weight, length);
        }
    }
}

#clip(min, max) ⇒ Numo::NArray

Clip array elements by [min,max]. If either of min or max is nil, one side is clipped.

Examples:

a = Numo::Int32.new(10).seq
# => Numo::Int32#shape=[10]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a.clip(1,8)
# => Numo::Int32#shape=[10]
# [1, 1, 2, 3, 4, 5, 6, 7, 8, 8]

a.inplace.clip(3,6)
a
# => Numo::Int32#shape=[10]
# [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]

b = Numo::Int32.new(10).seq
# => Numo::Int32#shape=[10]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

b.clip([3,4,1,1,1,4,4,4,4,4], 8)
# => Numo::Int32#shape=[10]
# [3, 4, 2, 3, 4, 5, 6, 7, 8, 8]

Parameters:

Returns:



3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
 
# File 'ext/numo/narray/types/int8.c', line 3907

static VALUE
int8_clip(VALUE self, VALUE min, VALUE max)
{
    ndfunc_arg_in_t ain[3] = {{Qnil,0},{cT,0},{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf_min = { iter_int8_clip_min, STRIDE_LOOP, 2, 1, ain, aout };
    ndfunc_t ndf_max = { iter_int8_clip_max, STRIDE_LOOP, 2, 1, ain, aout };
    ndfunc_t ndf_both = { iter_int8_clip, STRIDE_LOOP, 3, 1, ain, aout };

    if (RTEST(min)) {
        if (RTEST(max)) {
            return na_ndloop(&ndf_both, 3, self, min, max);
        } else {
            return na_ndloop(&ndf_min, 2, self, min);
        }
    } else {
        if (RTEST(max)) {
            return na_ndloop(&ndf_max, 2, self, max);
        }
    }
    rb_raise(rb_eArgError,"min and max are not given");
    return Qnil;
}

#coerce_cast(type) ⇒ nil

return NArray with cast to the type of self.

Returns:

  • (nil) 


1381
1382
1383
1384
1385
 
# File 'ext/numo/narray/types/int8.c', line 1381

static VALUE
int8_coerce_cast(VALUE self, VALUE type)
{
    return Qnil;
}

#cumprod(axis: nil, nan: false) ⇒ Numo::Int8

cumprod of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs cumprod along the axis.

  • nan (TrueClass) —

    If true, apply NaN-aware algorithm (avoid NaN if exists).

Returns:



5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
 
# File 'ext/numo/narray/types/int8.c', line 5023

static VALUE
int8_cumprod(int argc, VALUE *argv, VALUE self)
{
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_cumprod, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
                     2, 1, ain, aout };

  
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    return na_ndloop(&ndf, 2, self, reduce);
}

#cumsum(axis: nil, nan: false) ⇒ Numo::Int8

cumsum of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs cumsum along the axis.

  • nan (TrueClass) —

    If true, apply NaN-aware algorithm (avoid NaN if exists).

Returns:



4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
 
# File 'ext/numo/narray/types/int8.c', line 4972

static VALUE
int8_cumsum(int argc, VALUE *argv, VALUE self)
{
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_cumsum, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
                     2, 1, ain, aout };

  
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    return na_ndloop(&ndf, 2, self, reduce);
}

#divmod(other) ⇒ Numo::NArray

Binary divmod.

Parameters:

Returns:



2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
 
# File 'ext/numo/narray/types/int8.c', line 2517

static VALUE
int8_divmod(VALUE self, VALUE other)
{
    
#line 50 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary2.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_divmod_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_divmod, 1, other);
    }
    
}

#each ⇒ Numo::NArray

Calls the given block once for each element in self, passing that element as a parameter. For a block {|x| ... },

Yield Parameters:

  • x (Numeric) —

    an element of NArray.

Returns:

See Also:



1644
1645
1646
1647
1648
1649
1650
1651
1652
 
# File 'ext/numo/narray/types/int8.c', line 1644

static VALUE
int8_each(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
    ndfunc_t ndf = {iter_int8_each, FULL_LOOP_NIP, 1,0, ain,0};

    na_ndloop(&ndf, 1, self);
    return self;
}

#each_with_index ⇒ Numo::NArray

Invokes the given block once for each element of self, passing that element and indices along each axis as parameters. For a block {|x,i,j,...| ... },

Yield Parameters:

  • x (Numeric) —

    an element

  • i,j,... (Integer) —

    multitimensional indices

Returns:

See Also:



1781
1782
1783
1784
1785
1786
1787
1788
1789
 
# File 'ext/numo/narray/types/int8.c', line 1781

static VALUE
int8_each_with_index(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
    ndfunc_t ndf = {iter_int8_each_with_index, FULL_LOOP_NIP, 1,0, ain,0};

    na_ndloop_with_index(&ndf, 1, self);
    return self;
}

#eq(other) ⇒ Numo::Bit Also known as: nearly_eq

Comparison eq other.

Parameters:

Returns:



2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
 
# File 'ext/numo/narray/types/int8.c', line 2921

static VALUE
int8_eq(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_eq_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_eq, 1, other);
    }
    
}

#extract ⇒ Numeric, Numo::NArray

Extract an element only if self is a dimensionless NArray. — Extract element value as Ruby Object if self is a dimensionless NArray, otherwise returns self.

Returns:



182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'ext/numo/narray/types/int8.c', line 182

static VALUE
int8_extract(VALUE self)
{
    volatile VALUE v;
    char *ptr;
    narray_t *na;
    GetNArray(self,na);

    if (na->ndim==0) {
        ptr = na_get_pointer_for_read(self) + na_get_offset(self);
        v = m_extract(ptr);
        na_release_lock(self);
        return v;
    }
    return self;
}

#eye([element,offset]) ⇒ Numo::Int8

Eye: Set a value to diagonal components, set 0 to non-diagonal components.

Parameters:

  • element (Numeric) —

    Diagonal element to be stored. Default is 1.

  • 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.

Returns:



5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
 
# File 'ext/numo/narray/types/int8.c', line 5263

static VALUE
int8_eye(int argc, VALUE *argv, VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
    ndfunc_t ndf = {iter_int8_eye, NO_LOOP, 1,0, ain,0};
    ssize_t kofs;
    dtype data;
    char *g;
    int nd;
    narray_t *na;

    // check arguments
    if (argc > 2) {
        rb_raise(rb_eArgError,"too many arguments (%d for 0..2)",argc);
    } else if (argc == 2) {
        data = m_num_to_data(argv[0]);
        kofs = NUM2SSIZET(argv[1]);
    } else if (argc == 1) {
        data = m_num_to_data(argv[0]);
        kofs = 0;
    } else {
        data = m_one;
        kofs = 0;
    }

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

    // Diagonal offset from the main diagonal.
    if (kofs >= 0) {
        if ((size_t)(kofs) >= na->shape[nd-1]) {
            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
                     "last dimension size(%"SZF"d)",kofs,na->shape[nd-1]);
        }
    } else {
        if ((size_t)(-kofs) >= na->shape[nd-2]) {
            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
                     "last-1 dimension size(%"SZF"d)",kofs,na->shape[nd-2]);
        }
    }

    g = ALLOCA_N(char,sizeof(ssize_t)+sizeof(dtype));
    *(ssize_t*)g = kofs;
    *(dtype*)(g+sizeof(ssize_t)) = data;

    na_ndloop3(&ndf, g, 1, self);
    return self;
}

#fill(other) ⇒ Numo::Int8

Fill elements with other.

Parameters:

  • other (Numeric)

Returns:



1462
1463
1464
1465
1466
1467
1468
1469
1470
 
# File 'ext/numo/narray/types/int8.c', line 1462

static VALUE
int8_fill(VALUE self, VALUE val)
{
    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
    ndfunc_t ndf = { iter_int8_fill, FULL_LOOP, 2, 0, ain, 0 };

    na_ndloop(&ndf, 2, self, val);
    return self;
}

#format(format) ⇒ Numo::RObject

Format elements into strings.

Parameters:

  • format (String)

Returns:



1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
 
# File 'ext/numo/narray/types/int8.c', line 1522

static VALUE
int8_format(int argc, VALUE *argv, VALUE self)
{
    VALUE fmt=Qnil;

    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_option}};
    ndfunc_arg_out_t aout[1] = {{numo_cRObject,0}};
    ndfunc_t ndf = { iter_int8_format, FULL_LOOP_NIP, 2, 1, ain, aout };

    rb_scan_args(argc, argv, "01", &fmt);
    return na_ndloop(&ndf, 2, self, fmt);
}

#format_to_a(format) ⇒ Array

Format elements into strings.

Parameters:

  • format (String)

Returns:

  • (Array) —

    array of formated strings.



1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
 
# File 'ext/numo/narray/types/int8.c', line 1573

static VALUE
int8_format_to_a(int argc, VALUE *argv, VALUE self)
{
    VALUE fmt=Qnil;
    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
    ndfunc_t ndf = { iter_int8_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };

    rb_scan_args(argc, argv, "01", &fmt);
    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
}

#ge(other) ⇒ Numo::Bit Also known as: >=

Comparison ge other.

Parameters:

Returns:



3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
 
# File 'ext/numo/narray/types/int8.c', line 3680

static VALUE
int8_ge(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_ge_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_ge, 1, other);
    }
    
}

#gt(other) ⇒ Numo::Bit Also known as: >

Comparison gt other.

Parameters:

Returns:



3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
 
# File 'ext/numo/narray/types/int8.c', line 3623

static VALUE
int8_gt(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_gt_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_gt, 1, other);
    }
    
}

#inspect ⇒ String

Returns a string containing a human-readable representation of NArray.

Returns:

  • (String) 


1600
1601
1602
1603
1604
 
# File 'ext/numo/narray/types/int8.c', line 1600

static VALUE
int8_inspect(VALUE ary)
{
    return na_ndloop_inspect(ary, iter_int8_inspect, Qnil);
}

#le(other) ⇒ Numo::Bit Also known as: <=

Comparison le other.

Parameters:

Returns:



3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
 
# File 'ext/numo/narray/types/int8.c', line 3794

static VALUE
int8_le(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_le_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_le, 1, other);
    }
    
}

#lt(other) ⇒ Numo::Bit Also known as: <

Comparison lt other.

Parameters:

Returns:



3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
 
# File 'ext/numo/narray/types/int8.c', line 3737

static VALUE
int8_lt(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_lt_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_lt, 1, other);
    }
    
}

#map ⇒ Numo::Int8

Unary map.

Returns:



1710
1711
1712
1713
1714
1715
1716
1717
1718
 
# File 'ext/numo/narray/types/int8.c', line 1710

static VALUE
int8_map(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_map, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}

#map_with_index ⇒ Numo::NArray

Invokes the given block once for each element of self, passing that element and indices along each axis as parameters. Creates a new NArray containing the values returned by the block. Inplace option is allowed, i.e., nary.inplace.map overwrites nary. For a block {|x,i,j,...| ... },

Yield Parameters:

  • x (Numeric) —

    an element

  • i,j,... (Integer) —

    multitimensional indices

Returns:

See Also:



1878
1879
1880
1881
1882
1883
1884
1885
1886
 
# File 'ext/numo/narray/types/int8.c', line 1878

static VALUE
int8_map_with_index(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_map_with_index, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop_with_index(&ndf, 1, self);
}

#max(axis: nil, keepdims: false) ⇒ Numo::Int8

max of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs max along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100
4101
4102
4103
4104
4105
 
# File 'ext/numo/narray/types/int8.c', line 4088

static VALUE
int8_max(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_max, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };

  
#line 40 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v =  na_ndloop(&ndf, 2, self, reduce);
  
    return int8_extract(v);
  
#line 48 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
}

#max_index(axis: nil) ⇒ Integer, Numo::Int

Index of the maximum value.

Examples:

a = Numo::NArray[3,4,1,2]
a.max_index  #=> 1

b = Numo::NArray[[3,4,1],[2,0,5]]
b.max_index             #=> 5
b.max_index(axis:1)     #=> [1, 5]
b.max_index(axis:0)     #=> [0, 1, 5]
b[b.max_index(axis:0)]  #=> [3, 4, 5]

Parameters:

  • axis (Numeric, Array, Range) —

    Finds maximum values along the axis and returns flat 1-d indices.

Returns:

  • (Integer, Numo::Int) —

    returns result indices.

See Also:



4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
 
# File 'ext/numo/narray/types/int8.c', line 4213

static VALUE
int8_max_index(int argc, VALUE *argv, VALUE self)
{
    narray_t *na;
    VALUE idx, reduce;
    ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{0,0,0}};
    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};

    GetNArray(self,na);
    if (na->ndim==0) {
        return INT2FIX(0);
    }
    if (na->size > (~(u_int32_t)0)) {
        aout[0].type = numo_cInt64;
        idx = nary_new(numo_cInt64, na->ndim, na->shape);
        ndf.func = iter_int8_max_index_index64;
      
#line 77 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_index.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    } else {
        aout[0].type = numo_cInt32;
        idx = nary_new(numo_cInt32, na->ndim, na->shape);
        ndf.func = iter_int8_max_index_index32;
      
#line 86 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_index.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    }
    rb_funcall(idx, rb_intern("seq"), 0);

    return na_ndloop(&ndf, 3, self, idx, reduce);
}

#median(axis: nil, keepdims: false) ⇒ Numo::Int8

median of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Finds median along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



6141
6142
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156
6157
 
# File 'ext/numo/narray/types/int8.c', line 6141

static VALUE
int8_median(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
    ndfunc_t ndf = {0, NDF_HAS_LOOP|NDF_FLAT_REDUCE, 2,1, ain,aout};

    self = na_copy(self); // as temporary buffer
  
#line 60 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/median.c"
    ndf.func = iter_int8_median;
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v = na_ndloop(&ndf, 2, self, reduce);
    return int8_extract(v);
}

#min(axis: nil, keepdims: false) ⇒ Numo::Int8

min of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs min along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
 
# File 'ext/numo/narray/types/int8.c', line 4044

static VALUE
int8_min(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_min, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };

  
#line 40 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v =  na_ndloop(&ndf, 2, self, reduce);
  
    return int8_extract(v);
  
#line 48 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
}

#min_index(axis: nil) ⇒ Integer, Numo::Int

Index of the minimum value.

Examples:

a = Numo::NArray[3,4,1,2]
a.min_index  #=> 2

b = Numo::NArray[[3,4,1],[2,0,5]]
b.min_index             #=> 4
b.min_index(axis:1)     #=> [2, 4]
b.min_index(axis:0)     #=> [3, 4, 2]
b[b.min_index(axis:0)]  #=> [2, 0, 1]

Parameters:

  • axis (Numeric, Array, Range) —

    Finds minimum values along the axis and returns flat 1-d indices.

Returns:

  • (Integer, Numo::Int) —

    returns result indices.

See Also:



4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328
4329
4330
4331
4332
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343
 
# File 'ext/numo/narray/types/int8.c', line 4310

static VALUE
int8_min_index(int argc, VALUE *argv, VALUE self)
{
    narray_t *na;
    VALUE idx, reduce;
    ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{0,0,0}};
    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};

    GetNArray(self,na);
    if (na->ndim==0) {
        return INT2FIX(0);
    }
    if (na->size > (~(u_int32_t)0)) {
        aout[0].type = numo_cInt64;
        idx = nary_new(numo_cInt64, na->ndim, na->shape);
        ndf.func = iter_int8_min_index_index64;
      
#line 77 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_index.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    } else {
        aout[0].type = numo_cInt32;
        idx = nary_new(numo_cInt32, na->ndim, na->shape);
        ndf.func = iter_int8_min_index_index32;
      
#line 86 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_index.c"
        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
      
    }
    rb_funcall(idx, rb_intern("seq"), 0);

    return na_ndloop(&ndf, 3, self, idx, reduce);
}

#minmax(axis: nil, keepdims: false) ⇒ Numo::Int8

minmax of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Finds min-max along the axis.

  • keepdims (TrueClass) —

    (keyword) If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
 
# File 'ext/numo/narray/types/int8.c', line 4557

static VALUE
int8_minmax(int argc, VALUE *argv, VALUE self)
{
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
    ndfunc_t ndf = {iter_int8_minmax, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,2, ain,aout};

  
#line 43 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/minmax.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    return na_ndloop(&ndf, 2, self, reduce);
}

#mulsum(other, axis: nil, keepdims: false) ⇒ Numo::NArray

Binary mulsum.

Parameters:

  • other (Numo::NArray, Numeric)
  • axis (Numeric, Array, Range) —

    Performs mulsum along the axis.

  • keepdims (TrueClass) —

    (keyword) If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



5112
5113
5114
5115
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
 
# File 'ext/numo/narray/types/int8.c', line 5112

static VALUE
int8_mulsum(int argc, VALUE *argv, VALUE self)
{
    //
    VALUE klass, v;
    //
    if (argc < 1) {
        rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
    }
    //
#line 92 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum_binary.c"
    klass = na_upcast(rb_obj_class(self),rb_obj_class(argv[0]));
    if (klass==cT) {
        return int8_mulsum_self(argc, argv, self);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall2(v, rb_intern("mulsum"), argc, argv);
    }
    //
}

#ne(other) ⇒ Numo::Bit

Comparison ne other.

Parameters:

Returns:



2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
 
# File 'ext/numo/narray/types/int8.c', line 2978

static VALUE
int8_ne(VALUE self, VALUE other)
{
    
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/cond_binary.c"
    VALUE klass, v;
    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_ne_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, id_ne, 1, other);
    }
    
}

#poly(a0, a1, ..., an) ⇒ Numo::Int8

Calculate polynomial. x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n

Parameters:

Returns:



5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495
 
# File 'ext/numo/narray/types/int8.c', line 5472

static VALUE
int8_poly(VALUE self, VALUE args)
{
    int argc, i;
    VALUE *argv;
    volatile VALUE v, a;
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_poly, NO_LOOP, 0, 1, 0, aout };

    argc = RARRAY_LEN(args);
    ndf.nin = argc+1;
    ndf.ain = ALLOCA_N(ndfunc_arg_in_t,argc+1);
    for (i=0; i<argc+1; i++) {
        ndf.ain[i].type = cT;
    }
    argv = ALLOCA_N(VALUE,argc+1);
    argv[0] = self;
    for (i=0; i<argc; i++) {
        argv[i+1] = RARRAY_PTR(args)[i];
    }
    a = rb_ary_new4(argc+1, argv);
    v = na_ndloop2(&ndf, a);
    return int8_extract(v);
}

#prod(axis: nil, keepdims: false) ⇒ Numo::Int8

prod of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs prod along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
 
# File 'ext/numo/narray/types/int8.c', line 4000

static VALUE
int8_prod(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{numo_cInt64,0}};
    ndfunc_t ndf = { iter_int8_prod, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };

  
#line 40 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v =  na_ndloop(&ndf, 2, self, reduce);
  
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    return rb_funcall(v,rb_intern("extract"),0);
  
}

#ptp(axis: nil, keepdims: false) ⇒ Numo::Int8

ptp of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs ptp along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
 
# File 'ext/numo/narray/types/int8.c', line 4132

static VALUE
int8_ptp(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = { iter_int8_ptp, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };

  
#line 40 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v =  na_ndloop(&ndf, 2, self, reduce);
  
    return int8_extract(v);
  
#line 48 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
}

#rand([[low],high]) ⇒ Numo::Int8

Generate uniformly distributed random numbers on self narray.

Examples:

Numo::DFloat.new(6).rand
# => Numo::DFloat#shape=[6]
# [0.0617545, 0.373067, 0.794815, 0.201042, 0.116041, 0.344032]

Numo::DComplex.new(6).rand(5+5i)
# => Numo::DComplex#shape=[6]
# [2.69974+3.68908i, 0.825443+0.254414i, 0.540323+0.34354i, 4.52061+2.39322i, ...]

Numo::Int32.new(6).rand(2,5)
# => Numo::Int32#shape=[6]
# [4, 3, 3, 2, 4, 2]

Parameters:

  • low (Numeric) —

    lower inclusive boundary of random numbers. (default=0)

  • high (Numeric) —

    upper exclusive boundary of random numbers. (default=1 or 1+1i for complex types)

Returns:



5415
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438
5439
5440
5441
5442
5443
 
# File 'ext/numo/narray/types/int8.c', line 5415

static VALUE
int8_rand(int argc, VALUE *args, VALUE self)
{
    rand_opt_t g;
    VALUE v1=Qnil, v2=Qnil;
    dtype high;
    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
    ndfunc_t ndf = {iter_int8_rand, FULL_LOOP, 1,0, ain,0};

    
    rb_scan_args(argc, args, "11", &v1, &v2);
    if (v2==Qnil) {
        g.low = m_zero;
        g.max = high = m_num_to_data(v1);
    
#line 155 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/rand.c"
    } else {
        g.low = m_num_to_data(v1);
        high = m_num_to_data(v2);
        g.max = m_sub(high,g.low);
    }
    
    if (high <= g.low) {
        rb_raise(rb_eArgError,"high must be larger than low");
    }
    
    na_ndloop3(&ndf, &g, 1, self);
    return self;
}

#reciprocal ⇒ Numo::Int8

Unary reciprocal.

Returns:



2735
2736
2737
2738
2739
2740
2741
2742
2743
 
# File 'ext/numo/narray/types/int8.c', line 2735

static VALUE
int8_reciprocal(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_reciprocal, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}

#seq([beg,[step]]) ⇒ Numo::Int8 Also known as: indgen

Set linear sequence of numbers to self. The sequence is obtained from beg+i*step where i is 1-dimensional index.

Examples:

Numo::DFloat.new(6).seq(1,-0.2)
# => Numo::DFloat#shape=[6]
# [1, 0.8, 0.6, 0.4, 0.2, 0]

Numo::DComplex.new(6).seq(1,-0.2+0.2i)
# => Numo::DComplex#shape=[6]
# [1+0i, 0.8+0.2i, 0.6+0.4i, 0.4+0.6i, 0.2+0.8i, 0+1i]

Parameters:

  • beg (Numeric) —

    begining of sequence. (default=0)

  • step (Numeric) —

    step of sequence. (default=1)

Returns:



5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
 
# File 'ext/numo/narray/types/int8.c', line 5199

static VALUE
int8_seq(int argc, VALUE *args, VALUE self)
{
    seq_opt_t *g;
    VALUE vbeg=Qnil, vstep=Qnil;
    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
    ndfunc_t ndf = {iter_int8_seq, FULL_LOOP, 1,0, ain,0};

    g = ALLOCA_N(seq_opt_t,1);
    g->beg = m_zero;
    g->step = m_one;
    g->count = 0;
    rb_scan_args(argc, args, "02", &vbeg, &vstep);
#line 84 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/seq.c"
    if (vbeg!=Qnil) {g->beg = NUM2DBL(vbeg);}
    if (vstep!=Qnil) {g->step = NUM2DBL(vstep);}

#line 91 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/seq.c"
    na_ndloop3(&ndf, g, 1, self);
    return self;
}

#sign ⇒ Numo::Int8

Unary sign.

Returns:



2801
2802
2803
2804
2805
2806
2807
2808
2809
 
# File 'ext/numo/narray/types/int8.c', line 2801

static VALUE
int8_sign(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_sign, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}

#sort(axis: nil) ⇒ Numo::Int8

sort of self.

Examples:

Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]

Parameters:

  • axis (Numeric, Array, Range) —

    Performs sort along the axis.

Returns:



5730
5731
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
5744
5745
5746
5747
 
# File 'ext/numo/narray/types/int8.c', line 5730

static VALUE
int8_sort(int argc, VALUE *argv, VALUE self)
{
    VALUE reduce;
    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
    ndfunc_t ndf = {0, NDF_HAS_LOOP|NDF_FLAT_REDUCE, 2,0, ain,0};

    if (!TEST_INPLACE(self)) {
        self = na_copy(self);
    }
  
#line 42 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/sort.c"
    ndf.func = iter_int8_sort;
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    na_ndloop(&ndf, 2, self, reduce);
    return self;
}

#sort_index(axis: nil) ⇒ Integer, Numo::Int

sort_index. Returns an index array of sort result.

Examples:

Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]

Parameters:

  • axis (Numeric, Array, Range) —

    Performs sort_index along the axis.

Returns:

  • (Integer, Numo::Int) —

    returns result index of sort_index.



6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072
6073
6074
6075
6076
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
 
# File 'ext/numo/narray/types/int8.c', line 6058

static VALUE
int8_sort_index(int argc, VALUE *argv, VALUE self)
{
    size_t size;
    narray_t *na;
    VALUE idx, tmp, reduce, res;
    char *buf;
    ndfunc_arg_in_t ain[3] = {{cT,0},{0,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{0,0,0}};
    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_CUM, 3,1, ain,aout};

    GetNArray(self,na);
    if (na->ndim==0) {
        return INT2FIX(0);
    }
    if (na->size > (~(u_int32_t)0)) {
        ain[1].type =
        aout[0].type = numo_cInt64;
        idx = nary_new(numo_cInt64, na->ndim, na->shape);
       
#line 84 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/sort_index.c"
         ndf.func = int8_index64_qsort;
         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
       
    } else {
        ain[1].type =
        aout[0].type = numo_cInt32;
        idx = nary_new(numo_cInt32, na->ndim, na->shape);
       
#line 96 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/sort_index.c"
         ndf.func = int8_index32_qsort;
         reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
       
    }
    rb_funcall(idx, rb_intern("seq"), 0);

    size = na->size*sizeof(void*); // max capa
    buf = rb_alloc_tmp_buffer(&tmp, size);
    res = na_ndloop3(&ndf, buf, 3, self, idx, reduce);
    rb_free_tmp_buffer(&tmp);
    return res;
}

#square ⇒ Numo::Int8

Unary square.

Returns:



2867
2868
2869
2870
2871
2872
2873
2874
2875
 
# File 'ext/numo/narray/types/int8.c', line 2867

static VALUE
int8_square(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_square, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}

#store(other) ⇒ Numo::Int8

Store elements to Numo::Int8 from other.

Parameters:

  • other (Object)

Returns:



1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
 
# File 'ext/numo/narray/types/int8.c', line 1026

static VALUE
int8_store(VALUE self, VALUE obj)
{
    VALUE r, klass;

    klass = rb_obj_class(obj);

    
    if (klass==numo_cInt8) {
        int8_store_int8(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (IS_INTEGER_CLASS(klass) || klass==rb_cFloat || klass==rb_cComplex) {
        int8_store_numeric(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cBit) {
        int8_store_bit(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cDFloat) {
        int8_store_dfloat(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cSFloat) {
        int8_store_sfloat(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cInt64) {
        int8_store_int64(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cInt32) {
        int8_store_int32(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cInt16) {
        int8_store_int16(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cUInt64) {
        int8_store_uint64(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cUInt32) {
        int8_store_uint32(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cUInt16) {
        int8_store_uint16(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cUInt8) {
        int8_store_uint8(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==numo_cRObject) {
        int8_store_robject(self,obj);
        return self;
    }
    
#line 19 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    if (klass==rb_cArray) {
        int8_store_array(self,obj);
        return self;
    }
    

    if (IsNArray(obj)) {
        r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
        if (rb_obj_class(r)==cT) {
            int8_store(self,r);
            return self;
        }
    }

    
#line 36 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/store.c"
    rb_raise(nary_eCastError, "unknown conversion from %s to %s",
             rb_class2name(rb_obj_class(obj)),
             rb_class2name(rb_obj_class(self)));
    
    return self;
}

#sum(axis: nil, keepdims: false) ⇒ Numo::Int8

sum of self.

Parameters:

  • axis (Numeric, Array, Range) —

    Performs sum along the axis.

  • keepdims (TrueClass) —

    If true, the reduced axes are left in the result array as dimensions with size one.

Returns:



3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
 
# File 'ext/numo/narray/types/int8.c', line 3956

static VALUE
int8_sum(int argc, VALUE *argv, VALUE self)
{
    VALUE v, reduce;
    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
    ndfunc_arg_out_t aout[1] = {{numo_cInt64,0}};
    ndfunc_t ndf = { iter_int8_sum, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };

  
#line 40 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
  
    v =  na_ndloop(&ndf, 2, self, reduce);
  
#line 46 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/accum.c"
    return rb_funcall(v,rb_intern("extract"),0);
  
}

#to_a ⇒ Array

Convert self to Array.

Returns:

  • (Array) 


1422
1423
1424
1425
1426
1427
1428
1429
 
# File 'ext/numo/narray/types/int8.c', line 1422

static VALUE
int8_to_a(VALUE self)
{
    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
    ndfunc_t ndf = { iter_int8_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
}

#|(other) ⇒ Numo::NArray

Binary bit_or.

Parameters:

Returns:



3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
 
# File 'ext/numo/narray/types/int8.c', line 3185

static VALUE
int8_bit_or(VALUE self, VALUE other)
{
    
#line 226 "/home/masa/numo/numo-narray/ext/numo/narray/gen/tmpl/binary.c"
    VALUE klass, v;

    klass = na_upcast(rb_obj_class(self),rb_obj_class(other));
    if (klass==cT) {
        return int8_bit_or_self(self, other);
    } else {
        v = rb_funcall(klass, id_cast, 1, self);
        return rb_funcall(v, '|', 1, other);
    }
    
}

#~ ⇒ Numo::Int8

Unary bit_not.

Returns:



3361
3362
3363
3364
3365
3366
3367
3368
3369
 
# File 'ext/numo/narray/types/int8.c', line 3361

static VALUE
int8_bit_not(VALUE self)
{
    ndfunc_arg_in_t ain[1] = {{cT,0}};
    ndfunc_arg_out_t aout[1] = {{cT,0}};
    ndfunc_t ndf = {iter_int8_bit_not, FULL_LOOP, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, self);
}