Class: Numo::UInt16
Constant Summary
- 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
Class Method Summary collapse
-
.[](obj) ⇒ Numo::UInt16
Cast object to Numo::UInt16.
-
.cast(obj) ⇒ Numo::UInt16
Cast object to Numo::UInt16.
-
.maximum(*args) ⇒ Object
-
.minimum(*args) ⇒ Object
Instance Method Summary collapse
-
#%(other) ⇒ Numo::NArray
Binary mod.
-
#&(other) ⇒ Numo::NArray
Binary bit_and.
-
#*(other) ⇒ Numo::NArray
Binary mul.
-
#**(other) ⇒ Numo::NArray
Binary power.
-
#+(other) ⇒ Numo::NArray
Binary add.
-
#-(other) ⇒ Numo::NArray
Binary sub.
-
#-@ ⇒ Numo::UInt16
Unary minus.
-
#/(other) ⇒ Numo::NArray
Binary div.
-
#<<(other) ⇒ Numo::NArray
Binary left_shift.
-
#>>(other) ⇒ Numo::NArray
Binary right_shift.
-
#[](dim0, ..., dimL) ⇒ Numeric, NArray::UInt16
Array element referenece or slice view.
-
#[]=(dim0, .., dimL, val) ⇒ Numeric
Array element(s) set.
-
#^(other) ⇒ Numo::NArray
Binary bit_xor.
-
#abs ⇒ Numo::UInt16
abs of self.
-
#allocate ⇒ Object
-
#bincount([weight], minlength: nil) ⇒ UInt32 or UInt64 or SFloat or DFloat
Count the number of occurrences of each non-negative integer value.
-
#clip(min, max) ⇒ Numo::NArray
Clip array elements by [min,max].
-
#coerce_cast(type) ⇒ nil
return NArray with cast to the type of self.
-
#cumprod(axis: nil, nan: false) ⇒ Numo::UInt16
cumprod of self.
-
#cumsum(axis: nil, nan: false) ⇒ Numo::UInt16
cumsum of self.
-
#divmod(other) ⇒ Numo::NArray
Binary divmod.
-
#each ⇒ Numo::NArray
Calls the given block once for each element in self, passing that element as a parameter.
-
#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.
-
#eq(other) ⇒ Numo::Bit
(also: #nearly_eq)
Comparison eq other.
-
#extract ⇒ Numeric, Numo::NArray
Extract an element only if self is a dimensionless NArray.
-
#eye([element,offset]) ⇒ Numo::UInt16
Eye: Set a value to diagonal components, set 0 to non-diagonal components.
-
#fill(other) ⇒ Numo::UInt16
Fill elements with other.
-
#format(format) ⇒ Numo::RObject
Format elements into strings.
-
#format_to_a(format) ⇒ Array
Format elements into strings.
-
#ge(other) ⇒ Numo::Bit
(also: #>=)
Comparison ge other.
-
#gt(other) ⇒ Numo::Bit
(also: #>)
Comparison gt other.
-
#inspect ⇒ String
Returns a string containing a human-readable representation of NArray.
-
#le(other) ⇒ Numo::Bit
(also: #<=)
Comparison le other.
-
#lt(other) ⇒ Numo::Bit
(also: #<)
Comparison lt other.
-
#map ⇒ Numo::UInt16
Unary map.
-
#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.
-
#max(axis: nil, keepdims: false) ⇒ Numo::UInt16
max of self.
-
#max_index(axis: nil) ⇒ Integer, Numo::Int
max_index.
-
#median(axis: nil, keepdims: false) ⇒ Numo::UInt16
median of self.
-
#min(axis: nil, keepdims: false) ⇒ Numo::UInt16
min of self.
-
#min_index(axis: nil) ⇒ Integer, Numo::Int
min_index.
-
#minmax(axis: nil, keepdims: false) ⇒ Numo::UInt16
minmax of self.
-
#mulsum(other, axis: nil, keepdims: false) ⇒ Numo::NArray
Binary mulsum.
-
#ne(other) ⇒ Numo::Bit
Comparison ne other.
-
#poly(a0, a1, ...) ⇒ Numo::UInt16
Polynomial.: a0 + a1x + a2x2 + a3*x3 + …
-
#prod(axis: nil, keepdims: false) ⇒ Numo::UInt16
prod of self.
-
#ptp(axis: nil, keepdims: false) ⇒ Numo::UInt16
ptp of self.
-
#rand([[low],high]) ⇒ Numo::UInt16
Generate uniformly distributed random numbers on self narray.
-
#reciprocal ⇒ Numo::UInt16
Unary reciprocal.
-
#seq([beg,[step]]) ⇒ Numo::UInt16
(also: #indgen)
Set linear sequence of numbers to self.
-
#sign ⇒ Numo::UInt16
Unary sign.
-
#sort(axis: nil) ⇒ Numo::UInt16
sort of self.
-
#sort_index(axis: nil) ⇒ Integer, Numo::Int
sort_index.
-
#square ⇒ Numo::UInt16
Unary square.
-
#store(other) ⇒ Numo::UInt16
Store elements to Numo::UInt16 from other.
-
#sum(axis: nil, keepdims: false) ⇒ Numo::UInt16
sum of self.
-
#to_a ⇒ Array
Convert self to Array.
-
#|(other) ⇒ Numo::NArray
Binary bit_or.
-
#~ ⇒ Numo::UInt16
Unary bit_not.
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, #empty?, #expand_dims, eye, #flatten, #fliplr, #flipud, 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::UInt16 .cast(array) ⇒ Numo::UInt16
Cast object to Numo::UInt16.
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 |
# File 'ext/numo/narray/types/uint16.c', line 1262
static VALUE
uint16_s_cast(VALUE type, VALUE obj)
{
VALUE v;
narray_t *na;
dtype x;
if (CLASS_OF(obj)==cT) {
return obj;
}
if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
x = m_num_to_data(obj);
return uint16_new_dim0(x);
}
if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
return uint16_cast_array(obj);
}
if (IsNArray(obj)) {
GetNArray(obj,na);
v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
if (NA_SIZE(na) > 0) {
uint16_store(v,obj);
}
return v;
}
#line 41 "gen/tmpl/cast.c"
rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
return Qnil;
}
|
.[](elements) ⇒ Numo::UInt16 .cast(array) ⇒ Numo::UInt16
Cast object to Numo::UInt16.
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 |
# File 'ext/numo/narray/types/uint16.c', line 1262
static VALUE
uint16_s_cast(VALUE type, VALUE obj)
{
VALUE v;
narray_t *na;
dtype x;
if (CLASS_OF(obj)==cT) {
return obj;
}
if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
x = m_num_to_data(obj);
return uint16_new_dim0(x);
}
if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
return uint16_cast_array(obj);
}
if (IsNArray(obj)) {
GetNArray(obj,na);
v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
if (NA_SIZE(na) > 0) {
uint16_store(v,obj);
}
return v;
}
#line 41 "gen/tmpl/cast.c"
rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
return Qnil;
}
|
.maximum(*args) ⇒ Object
4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 |
# File 'ext/numo/narray/types/uint16.c', line 4452
static VALUE
uint16_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_uint16_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
#line 60 "gen/tmpl/ewcomp.c"
rb_scan_args(argc, argv, "20", &a1, &a2);
return na_ndloop(&ndf, 2, a1, a2);
}
|
.minimum(*args) ⇒ Object
4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 |
# File 'ext/numo/narray/types/uint16.c', line 4503
static VALUE
uint16_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_uint16_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
#line 60 "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.
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 |
# File 'ext/numo/narray/types/uint16.c', line 2461
static VALUE
uint16_mod(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 |
# File 'ext/numo/narray/types/uint16.c', line 3150
static VALUE
uint16_bit_and(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 |
# File 'ext/numo/narray/types/uint16.c', line 2267
static VALUE
uint16_mul(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_mul_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, '*', 1, other);
}
}
|
#**(other) ⇒ Numo::NArray
Binary power.
2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 |
# File 'ext/numo/narray/types/uint16.c', line 2603
static VALUE
uint16_pow(VALUE self, VALUE other)
{
#line 69 "gen/tmpl/pow.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 |
# File 'ext/numo/narray/types/uint16.c', line 2081
static VALUE
uint16_add(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_add_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, '+', 1, other);
}
}
|
#-(other) ⇒ Numo::NArray
Binary sub.
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 |
# File 'ext/numo/narray/types/uint16.c', line 2174
static VALUE
uint16_sub(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_sub_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, '-', 1, other);
}
}
|
#-@ ⇒ Numo::UInt16
Unary minus.
2693 2694 2695 2696 2697 2698 2699 2700 2701 |
# File 'ext/numo/narray/types/uint16.c', line 2693
static VALUE
uint16_minus(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_minus, FULL_LOOP, 1,1, ain,aout};
return na_ndloop(&ndf, 1, self);
}
|
#/(other) ⇒ Numo::NArray
Binary div.
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 |
# File 'ext/numo/narray/types/uint16.c', line 2364
static VALUE
uint16_div(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 |
# File 'ext/numo/narray/types/uint16.c', line 3513
static VALUE
uint16_left_shift(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 |
# File 'ext/numo/narray/types/uint16.c', line 3606
static VALUE
uint16_right_shift(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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, NArray::UInt16
Array element referenece or slice view. — Returns the element at +dim0+, +dim1+, … are Numeric indices for each dimension, or returns a NArray View as a sliced subarray if +dim0+, +dim1+, … includes other than Numeric index, e.g., Range or Array or true.
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 |
# File 'ext/numo/narray/types/uint16.c', line 1334
static VALUE
uint16_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
Array element(s) set. — Replace element(s) at +dim0+, +dim1+, … (index/range/array/true for each dimention). Broadcasting mechanism is applied.
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 |
# File 'ext/numo/narray/types/uint16.c', line 1391
static VALUE
uint16_aset(int argc, VALUE *argv, VALUE self)
{
int nd;
size_t pos;
char *ptr;
VALUE a;
dtype x;
argc--;
if (argc==0) {
uint16_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);
uint16_store(a, argv[argc]);
} else {
x = uint16_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.
3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 |
# File 'ext/numo/narray/types/uint16.c', line 3336
static VALUE
uint16_bit_xor(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_bit_xor_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, '^', 1, other);
}
}
|
#abs ⇒ Numo::UInt16
abs of self.
1995 1996 1997 1998 1999 2000 2001 2002 2003 |
# File 'ext/numo/narray/types/uint16.c', line 1995
static VALUE
uint16_abs(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cRT,0}};
ndfunc_t ndf = { iter_uint16_abs, FULL_LOOP, 1, 1, ain, aout };
return na_ndloop(&ndf, 1, self);
}
|
#allocate ⇒ Object
139 140 141 142 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 |
# File 'ext/numo/narray/types/uint16.c', line 139
static VALUE
uint16_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 "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;
}
|
#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.
4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 |
# File 'ext/numo/narray/types/uint16.c', line 4738
static VALUE
uint16_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);
v = uint16_max(0,0,self);
#line 157 "gen/tmpl/bincount.c"
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 uint16_bincount_64(self, length);
} else {
return uint16_bincount_32(self, length);
}
} else {
wclass = CLASS_OF(weight);
if (wclass == numo_cSFloat) {
return uint16_bincount_sf(self, weight, length);
} else {
return uint16_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.
3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 |
# File 'ext/numo/narray/types/uint16.c', line 3957
static VALUE
uint16_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_uint16_clip_min, STRIDE_LOOP, 2, 1, ain, aout };
ndfunc_t ndf_max = { iter_uint16_clip_max, STRIDE_LOOP, 2, 1, ain, aout };
ndfunc_t ndf_both = { iter_uint16_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.
1425 1426 1427 1428 1429 |
# File 'ext/numo/narray/types/uint16.c', line 1425
static VALUE
uint16_coerce_cast(VALUE self, VALUE type)
{
return Qnil;
}
|
#cumprod(axis: nil, nan: false) ⇒ Numo::UInt16
cumprod of self.
4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 |
# File 'ext/numo/narray/types/uint16.c', line 4865
static VALUE
uint16_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_uint16_cumprod, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
2, 1, ain, aout };
#line 46 "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::UInt16
cumsum of self.
4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 |
# File 'ext/numo/narray/types/uint16.c', line 4814
static VALUE
uint16_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_uint16_cumsum, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
2, 1, ain, aout };
#line 46 "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.
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 |
# File 'ext/numo/narray/types/uint16.c', line 2523
static VALUE
uint16_divmod(VALUE self, VALUE other)
{
#line 50 "gen/tmpl/binary2.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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| … }
1686 1687 1688 1689 1690 1691 1692 1693 1694 |
# File 'ext/numo/narray/types/uint16.c', line 1686
static VALUE
uint16_each(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{Qnil,0}};
ndfunc_t ndf = {iter_uint16_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,…| … }
1837 1838 1839 1840 1841 1842 1843 1844 1845 |
# File 'ext/numo/narray/types/uint16.c', line 1837
static VALUE
uint16_each_with_index(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{Qnil,0}};
ndfunc_t ndf = {iter_uint16_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.
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 |
# File 'ext/numo/narray/types/uint16.c', line 2999
static VALUE
uint16_eq(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 |
# File 'ext/numo/narray/types/uint16.c', line 178
static VALUE
uint16_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::UInt16
Eye: Set a value to diagonal components, set 0 to non-diagonal components.
5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 |
# File 'ext/numo/narray/types/uint16.c', line 5104
static VALUE
uint16_eye(int argc, VALUE *argv, VALUE self)
{
ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
ndfunc_t ndf = {iter_uint16_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::UInt16
Fill elements with other.
1506 1507 1508 1509 1510 1511 1512 1513 1514 |
# File 'ext/numo/narray/types/uint16.c', line 1506
static VALUE
uint16_fill(VALUE self, VALUE val)
{
ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
ndfunc_t ndf = { iter_uint16_fill, FULL_LOOP, 2, 0, ain, 0 };
na_ndloop(&ndf, 2, self, val);
return self;
}
|
#format(format) ⇒ Numo::RObject
Format elements into strings.
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 |
# File 'ext/numo/narray/types/uint16.c', line 1566
static VALUE
uint16_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_uint16_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.
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 |
# File 'ext/numo/narray/types/uint16.c', line 1617
static VALUE
uint16_format_to_a(int argc, VALUE *argv, VALUE self)
{
volatile 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_uint16_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.
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 |
# File 'ext/numo/narray/types/uint16.c', line 3726
static VALUE
uint16_ge(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 |
# File 'ext/numo/narray/types/uint16.c', line 3669
static VALUE
uint16_gt(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
1644 1645 1646 1647 1648 |
# File 'ext/numo/narray/types/uint16.c', line 1644
VALUE
uint16_inspect(VALUE ary)
{
return na_ndloop_inspect(ary, iter_uint16_inspect, Qnil);
}
|
#le(other) ⇒ Numo::Bit Also known as: <=
Comparison le other.
3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 |
# File 'ext/numo/narray/types/uint16.c', line 3840
static VALUE
uint16_le(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_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.
3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 |
# File 'ext/numo/narray/types/uint16.c', line 3783
static VALUE
uint16_lt(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_lt_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, id_lt, 1, other);
}
}
|
#map ⇒ Numo::UInt16
Unary map.
1770 1771 1772 1773 1774 1775 1776 1777 1778 |
# File 'ext/numo/narray/types/uint16.c', line 1770
static VALUE
uint16_map(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_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,… | … } |
1934 1935 1936 1937 1938 1939 1940 1941 1942 |
# File 'ext/numo/narray/types/uint16.c', line 1934
static VALUE
uint16_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_uint16_map_with_index, FULL_LOOP, 1,1, ain,aout};
return na_ndloop_with_index(&ndf, 1, self);
}
|
#max(axis: nil, keepdims: false) ⇒ Numo::UInt16
max of self.
4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 |
# File 'ext/numo/narray/types/uint16.c', line 4138
static VALUE
uint16_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_uint16_max, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
#line 40 "gen/tmpl/accum.c"
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
v = na_ndloop(&ndf, 2, self, reduce);
return uint16_extract(v);
#line 48 "gen/tmpl/accum.c"
}
|
#max_index(axis: nil) ⇒ Integer, Numo::Int
max_index. Return an index of result.
4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 |
# File 'ext/numo/narray/types/uint16.c', line 4253
static VALUE
uint16_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_uint16_max_index_index64;
#line 56 "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_uint16_max_index_index32;
#line 65 "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::UInt16
median of self.
5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 |
# File 'ext/numo/narray/types/uint16.c', line 5856
static VALUE
uint16_median(int argc, VALUE *argv, VALUE self)
{
VALUE 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 "gen/tmpl/median.c"
ndf.func = iter_uint16_median;
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
return na_ndloop(&ndf, 2, self, reduce);
}
|
#min(axis: nil, keepdims: false) ⇒ Numo::UInt16
min of self.
4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 |
# File 'ext/numo/narray/types/uint16.c', line 4094
static VALUE
uint16_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_uint16_min, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
#line 40 "gen/tmpl/accum.c"
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
v = na_ndloop(&ndf, 2, self, reduce);
return uint16_extract(v);
#line 48 "gen/tmpl/accum.c"
}
|
#min_index(axis: nil) ⇒ Integer, Numo::Int
min_index. Return an index of result.
4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 |
# File 'ext/numo/narray/types/uint16.c', line 4340
static VALUE
uint16_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_uint16_min_index_index64;
#line 56 "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_uint16_min_index_index32;
#line 65 "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::UInt16
minmax of self.
4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 |
# File 'ext/numo/narray/types/uint16.c', line 4403
static VALUE
uint16_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_uint16_minmax, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 2,2, ain,aout};
#line 43 "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.
4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 |
# File 'ext/numo/narray/types/uint16.c', line 4954
static VALUE
uint16_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 "gen/tmpl/accum_binary.c"
klass = na_upcast(CLASS_OF(self),CLASS_OF(argv[0]));
if (klass==cT) {
return uint16_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.
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 |
# File 'ext/numo/narray/types/uint16.c', line 3056
static VALUE
uint16_ne(VALUE self, VALUE other)
{
#line 46 "gen/tmpl/cond_binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_ne_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, id_ne, 1, other);
}
}
|
#poly(a0, a1, ...) ⇒ Numo::UInt16
Polynomial.: a0 + a1x + a2x2 + a3x**3 + … + anxn
5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 |
# File 'ext/numo/narray/types/uint16.c', line 5311
static VALUE
uint16_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_uint16_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 uint16_extract(v);
}
|
#prod(axis: nil, keepdims: false) ⇒ Numo::UInt16
prod of self.
4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 |
# File 'ext/numo/narray/types/uint16.c', line 4050
static VALUE
uint16_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] = {{cT,0}};
ndfunc_t ndf = { iter_uint16_prod, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
#line 40 "gen/tmpl/accum.c"
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
v = na_ndloop(&ndf, 2, self, reduce);
return uint16_extract(v);
#line 48 "gen/tmpl/accum.c"
}
|
#ptp(axis: nil, keepdims: false) ⇒ Numo::UInt16
ptp of self.
4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 |
# File 'ext/numo/narray/types/uint16.c', line 4182
static VALUE
uint16_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_uint16_ptp, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
#line 40 "gen/tmpl/accum.c"
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
v = na_ndloop(&ndf, 2, self, reduce);
return uint16_extract(v);
#line 48 "gen/tmpl/accum.c"
}
|
#rand([[low],high]) ⇒ Numo::UInt16
Generate uniformly distributed random numbers on self narray.
5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 |
# File 'ext/numo/narray/types/uint16.c', line 5254
static VALUE
uint16_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_uint16_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 153 "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::UInt16
Unary reciprocal.
2777 2778 2779 2780 2781 2782 2783 2784 2785 |
# File 'ext/numo/narray/types/uint16.c', line 2777
static VALUE
uint16_reciprocal(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_reciprocal, FULL_LOOP, 1,1, ain,aout};
return na_ndloop(&ndf, 1, self);
}
|
#seq([beg,[step]]) ⇒ Numo::UInt16 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.
5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 |
# File 'ext/numo/narray/types/uint16.c', line 5040
static VALUE
uint16_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_uint16_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 83 "gen/tmpl/seq.c"
if (vbeg!=Qnil) {g->beg = NUM2DBL(vbeg);}
if (vstep!=Qnil) {g->step = NUM2DBL(vstep);}
#line 90 "gen/tmpl/seq.c"
na_ndloop3(&ndf, g, 1, self);
return self;
}
|
#sign ⇒ Numo::UInt16
Unary sign.
2861 2862 2863 2864 2865 2866 2867 2868 2869 |
# File 'ext/numo/narray/types/uint16.c', line 2861
static VALUE
uint16_sign(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_sign, FULL_LOOP, 1,1, ain,aout};
return na_ndloop(&ndf, 1, self);
}
|
#sort(axis: nil) ⇒ Numo::UInt16
sort of self.
5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 |
# File 'ext/numo/narray/types/uint16.c', line 5507
static VALUE
uint16_sort(int argc, VALUE *argv, VALUE self)
{
VALUE reduce;
ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
ndfunc_t ndf = {0, STRIDE_LOOP|NDF_FLAT_REDUCE, 2,0, ain,0};
if (!TEST_INPLACE(self)) {
self = na_copy(self);
}
#line 42 "gen/tmpl/sort.c"
ndf.func = iter_uint16_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.
5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 |
# File 'ext/numo/narray/types/uint16.c', line 5773
static VALUE
uint16_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 "gen/tmpl/sort_index.c"
ndf.func = uint16_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 "gen/tmpl/sort_index.c"
ndf.func = uint16_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::UInt16
Unary square.
2945 2946 2947 2948 2949 2950 2951 2952 2953 |
# File 'ext/numo/narray/types/uint16.c', line 2945
static VALUE
uint16_square(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_square, FULL_LOOP, 1,1, ain,aout};
return na_ndloop(&ndf, 1, self);
}
|
#store(other) ⇒ Numo::UInt16
Store elements to Numo::UInt16 from other.
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 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 |
# File 'ext/numo/narray/types/uint16.c', line 1010
static VALUE
uint16_store(VALUE self, VALUE obj)
{
VALUE r, klass;
klass = CLASS_OF(obj);
if (klass==numo_cUInt16) {
uint16_store_uint16(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (IS_INTEGER_CLASS(klass) || klass==rb_cFloat || klass==rb_cComplex) {
uint16_store_numeric(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cBit) {
uint16_store_bit(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cDFloat) {
uint16_store_dfloat(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cSFloat) {
uint16_store_sfloat(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cInt64) {
uint16_store_int64(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cInt32) {
uint16_store_int32(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cInt16) {
uint16_store_int16(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cInt8) {
uint16_store_int8(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cUInt64) {
uint16_store_uint64(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cUInt32) {
uint16_store_uint32(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cUInt8) {
uint16_store_uint8(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==numo_cRObject) {
uint16_store_robject(self,obj);
return self;
}
#line 19 "gen/tmpl/store.c"
if (klass==rb_cArray) {
uint16_store_array(self,obj);
return self;
}
if (IsNArray(obj)) {
r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
if (CLASS_OF(r)==cT) {
uint16_store(self,r);
return self;
}
}
#line 36 "gen/tmpl/store.c"
rb_raise(nary_eCastError, "unknown conversion from %s to %s",
rb_class2name(CLASS_OF(obj)),
rb_class2name(CLASS_OF(self)));
return self;
}
|
#sum(axis: nil, keepdims: false) ⇒ Numo::UInt16
sum of self.
4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 |
# File 'ext/numo/narray/types/uint16.c', line 4006
static VALUE
uint16_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] = {{cT,0}};
ndfunc_t ndf = { iter_uint16_sum, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
#line 40 "gen/tmpl/accum.c"
reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
v = na_ndloop(&ndf, 2, self, reduce);
return uint16_extract(v);
#line 48 "gen/tmpl/accum.c"
}
|
#to_a ⇒ Array
Convert self to Array.
1466 1467 1468 1469 1470 1471 1472 1473 |
# File 'ext/numo/narray/types/uint16.c', line 1466
static VALUE
uint16_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_uint16_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.
3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 |
# File 'ext/numo/narray/types/uint16.c', line 3243
static VALUE
uint16_bit_or(VALUE self, VALUE other)
{
#line 87 "gen/tmpl/binary.c"
VALUE klass, v;
klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
if (klass==cT) {
return uint16_bit_or_self(self, other);
} else {
v = rb_funcall(klass, id_cast, 1, self);
return rb_funcall(v, '|', 1, other);
}
}
|
#~ ⇒ Numo::UInt16
Unary bit_not.
3427 3428 3429 3430 3431 3432 3433 3434 3435 |
# File 'ext/numo/narray/types/uint16.c', line 3427
static VALUE
uint16_bit_not(VALUE self)
{
ndfunc_arg_in_t ain[1] = {{cT,0}};
ndfunc_arg_out_t aout[1] = {{cT,0}};
ndfunc_t ndf = {iter_uint16_bit_not, FULL_LOOP, 1,1, ain,aout};
return na_ndloop(&ndf, 1, self);
}
|