As int is already an Integer, all these methods simply return the receiver.
static VALUE
int_to_i(VALUE num)
{
return num;
}
Returns a string containing the character represented by the receiver’s value according to encoding.
65.chr #=> "A" 230.chr #=> "\346" 255.chr(Encoding::UTF_8) #=> "\303\277"
static VALUE
int_chr(int argc, VALUE *argv, VALUE num)
{
char c;
unsigned int i = NUM2UINT(num);
rb_encoding *enc;
switch (argc) {
case 0:
if (i < 0) {
out_of_range:
rb_raise(rb_eRangeError, "%d out of char range", i);
}
if (0xff < i) {
enc = rb_default_internal_encoding();
if (!enc) goto out_of_range;
goto decode;
}
c = (char)i;
if (i < 0x80) {
return rb_usascii_str_new(&c, 1);
}
else {
return rb_str_new(&c, 1);
}
case 1:
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
break;
}
enc = rb_to_encoding(argv[0]);
if (!enc) enc = rb_ascii8bit_encoding();
decode:
return rb_enc_uint_chr(i, enc);
}
Returns 1.
static VALUE
integer_denominator(VALUE self)
{
return INT2FIX(1);
}
Iterates block, passing decreasing values from int down to and including limit.
If no block is given, an enumerator is returned instead.
5.downto(1) { |n| print n, ".. " } print " Liftoff!\n"
produces:
5.. 4.. 3.. 2.. 1.. Liftoff!
static VALUE
int_downto(VALUE from, VALUE to)
{
RETURN_ENUMERATOR(from, 1, &to);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i=FIX2LONG(from); i >= end; i--) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '<', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '-', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}
Returns true if int is an even number.
static VALUE
int_even_p(VALUE num)
{
if (rb_funcall(num, '%', 1, INT2FIX(2)) == INT2FIX(0)) {
return Qtrue;
}
return Qfalse;
}
As int is already an Integer, all these methods simply return the receiver.
static VALUE
int_to_i(VALUE num)
{
return num;
}
Returns the greatest common divisor (always positive). 0.gcd(x) and x.gcd(0) return abs(x).
For example:
2.gcd(2) #=> 2 3.gcd(-7) #=> 1 ((1<<31)-1).gcd((1<<61)-1) #=> 1
VALUE
rb_gcd(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_gcd(self, other);
}
Returns an array; [int.gcd(int2), int.lcm(int2)].
For example:
2.gcdlcm(2) #=> [2, 2] 3.gcdlcm(-7) #=> [1, 21] ((1<<31)-1).gcdlcm((1<<61)-1) #=> [1, 4951760154835678088235319297]
VALUE
rb_gcdlcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
}
Always returns true.
static VALUE
int_int_p(VALUE num)
{
return Qtrue;
}
Returns the least common multiple (always positive). 0.lcm(x) and x.lcm(0) return zero.
For example:
2.lcm(2) #=> 2 3.lcm(-7) #=> 21 ((1<<31)-1).lcm((1<<61)-1) #=> 4951760154835678088235319297
VALUE
rb_lcm(VALUE self, VALUE other)
{
other = nurat_int_value(other);
return f_lcm(self, other);
}
Returns the Integer equal to int + 1.
1.next #=> 2 (-1).next #=> 0
static VALUE
int_succ(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) + 1;
return LONG2NUM(i);
}
return rb_funcall(num, '+', 1, INT2FIX(1));
}
Returns self.
static VALUE
integer_numerator(VALUE self)
{
return self;
}
Returns true if int is an odd number.
static VALUE
int_odd_p(VALUE num)
{
if (rb_funcall(num, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
return Qtrue;
}
return Qfalse;
}
Returns the int itself.
?a.ord #=> 97
This method is intended for compatibility to character constant in Ruby 1.9. For example, ?a.ord returns 97 both in 1.8 and 1.9.
static VALUE
int_ord(num)
VALUE num;
{
return num;
}
Returns the Integer equal to int - 1.
1.pred #=> 0 (-1).pred #=> -2
static VALUE
int_pred(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) - 1;
return LONG2NUM(i);
}
return rb_funcall(num, '-', 1, INT2FIX(1));
}
Returns the value as a rational. An optional argument eps is always ignored.
static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
rb_scan_args(argc, argv, "01", NULL);
return integer_to_r(self);
}
Rounds flt to a given precision in decimal digits (default 0 digits). Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and round down for negative.
1.round #=> 1 1.round(2) #=> 1.0 15.round(-1) #=> 20
static VALUE
int_round(int argc, VALUE* argv, VALUE num)
{
VALUE n, f, h, r;
int ndigits;
if (argc == 0) return num;
rb_scan_args(argc, argv, "1", &n);
ndigits = NUM2INT(n);
if (ndigits > 0) {
return rb_Float(num);
}
if (ndigits == 0) {
return num;
}
ndigits = -ndigits;
if (ndigits < 0) {
rb_raise(rb_eArgError, "ndigits out of range");
}
f = int_pow(10, ndigits);
if (FIXNUM_P(num) && FIXNUM_P(f)) {
SIGNED_VALUE x = FIX2LONG(num), y = FIX2LONG(f);
int neg = x < 0;
if (neg) x = -x;
x = (x + y / 2) / y * y;
if (neg) x = -x;
return LONG2NUM(x);
}
h = rb_funcall(f, '/', 1, INT2FIX(2));
r = rb_funcall(num, '%', 1, f);
n = rb_funcall(num, '-', 1, r);
if (!RTEST(rb_funcall(r, '<', 1, h))) {
n = rb_funcall(n, '+', 1, f);
}
return n;
}
Returns the Integer equal to int + 1.
1.next #=> 2 (-1).next #=> 0
static VALUE
int_succ(VALUE num)
{
if (FIXNUM_P(num)) {
long i = FIX2LONG(num) + 1;
return LONG2NUM(i);
}
return rb_funcall(num, '+', 1, INT2FIX(1));
}
Iterates block int times, passing in values from zero to int - 1.
If no block is given, an enumerator is returned instead.
5.times do |i| print i, " " end
produces:
0 1 2 3 4
static VALUE
int_dotimes(VALUE num)
{
RETURN_ENUMERATOR(num, 0, 0);
if (FIXNUM_P(num)) {
long i, end;
end = FIX2LONG(num);
for (i=0; i<end; i++) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = INT2FIX(0);
for (;;) {
if (!RTEST(rb_funcall(i, '<', 1, num))) break;
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
}
return num;
}
As int is already an Integer, all these methods simply return the receiver.
static VALUE
int_to_i(VALUE num)
{
return num;
}
As int is already an Integer, all these methods simply return the receiver.
static VALUE
int_to_i(VALUE num)
{
return num;
}
Returns the value as a rational.
For example:
1.to_r #=> (1/1) (1<<64).to_r #=> (18446744073709551616/1)
static VALUE
integer_to_r(VALUE self)
{
return rb_rational_new1(self);
}
As int is already an Integer, all these methods simply return the receiver.
static VALUE
int_to_i(VALUE num)
{
return num;
}
Iterates block, passing in integer values from int up to and including limit.
If no block is given, an enumerator is returned instead.
5.upto(10) { |i| print i, " " }
produces:
5 6 7 8 9 10
static VALUE
int_upto(VALUE from, VALUE to)
{
RETURN_ENUMERATOR(from, 1, &to);
if (FIXNUM_P(from) && FIXNUM_P(to)) {
long i, end;
end = FIX2LONG(to);
for (i = FIX2LONG(from); i <= end; i++) {
rb_yield(LONG2FIX(i));
}
}
else {
VALUE i = from, c;
while (!(c = rb_funcall(i, '>', 1, to))) {
rb_yield(i);
i = rb_funcall(i, '+', 1, INT2FIX(1));
}
if (NIL_P(c)) rb_cmperr(i, to);
}
return from;
}