Class: Integer (Ruby 2.3.4)

    In Files

    • numeric.c
    • rational.c

    Class/Module Index [+]

    Quicksearch

    Integer

    This class is the basis for the two concrete classes that hold whole numbers, Bignum and Fixnum.

    Public Instance Methods

    to_i → integer click to toggle source

    As int is already an Integer, all these methods simply return the receiver.

    Synonyms are to_int, floor, ceil, truncate.

     
                   static VALUE
    int_to_i(VALUE num)
    {
        return num;
    }
                
    chr([encoding]) → string click to toggle source

    Returns a string containing the character represented by the int‘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;
        rb_encoding *enc;
    
        if (rb_num_to_uint(num, &i) == 0) {
        }
        else if (FIXNUM_P(num)) {
            rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(num));
        }
        else {
            rb_raise(rb_eRangeError, "bignum out of char range");
        }
    
        switch (argc) {
          case 0:
            if (0xff < i) {
                enc = rb_default_internal_encoding();
                if (!enc) {
                    rb_raise(rb_eRangeError, "%d out of char range", i);
                }
                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_check_arity(argc, 0, 1);
            break;
        }
        enc = rb_to_encoding(argv[0]);
        if (!enc) enc = rb_ascii8bit_encoding();
      decode:
        return rb_enc_uint_chr(i, enc);
    }
                
    denominator → 1 click to toggle source

    Returns 1.

     
                   static VALUE
    integer_denominator(VALUE self)
    {
        return INT2FIX(1);
    }
                
    downto(limit) {|i| block } → self click to toggle source
    downto(limit) → an_enumerator

    Iterates the given 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"
    #=> "5.. 4.. 3.. 2.. 1..   Liftoff!"
    
     
                   static VALUE
    int_downto(VALUE from, VALUE to)
    {
        RETURN_SIZED_ENUMERATOR(from, 1, &to, int_downto_size);
        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;
    }
                
    even? → true or false click to toggle source

    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;
    }
                
    to_i → integer click to toggle source

    As int is already an Integer, all these methods simply return the receiver.

    Synonyms are to_int, floor, ceil, truncate.

     
                   static VALUE
    int_to_i(VALUE num)
    {
        return num;
    }
                
    gcd(int2) → integer click to toggle source

    Returns the greatest common divisor (always positive). 0.gcd(x) and x.gcd(0) return abs(x).

    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);
    }
                
    gcdlcm(int2) → array click to toggle source

    Returns an array; [int.gcd(int2), int.lcm(int2)].

    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));
    }
                
    integer? → true click to toggle source

    Since int is already an Integer, this always returns true.

     
                   static VALUE
    int_int_p(VALUE num)
    {
        return Qtrue;
    }
                
    lcm(int2) → integer click to toggle source

    Returns the least common multiple (always positive). 0.lcm(x) and x.lcm(0) return zero.

    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);
    }
                
    next → integer click to toggle source

    Returns the Integer equal to int + 1, same as #next.

    1.next      #=> 2
    (-1).next   #=> 0
    
     
                   VALUE
    rb_int_succ(VALUE num)
    {
        if (FIXNUM_P(num)) {
            long i = FIX2LONG(num) + 1;
            return LONG2NUM(i);
        }
        if (RB_TYPE_P(num, T_BIGNUM)) {
            return rb_big_plus(num, INT2FIX(1));
        }
        return rb_funcall(num, '+', 1, INT2FIX(1));
    }
                
    numerator → self click to toggle source

    Returns self.

     
                   static VALUE
    integer_numerator(VALUE self)
    {
        return self;
    }
                
    odd? → true or false click to toggle source

    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;
    }
                
    ord → self click to toggle source

    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(VALUE num)
    {
        return num;
    }
                
    pred → integer click to toggle source

    Returns the Integer equal to int - 1.

    1.pred      #=> 0
    (-1).pred   #=> -2
    
     
                   VALUE
    rb_int_pred(VALUE num)
    {
        if (FIXNUM_P(num)) {
            long i = FIX2LONG(num) - 1;
            return LONG2NUM(i);
        }
        if (RB_TYPE_P(num, T_BIGNUM)) {
            return rb_big_minus(num, INT2FIX(1));
        }
        return rb_funcall(num, '-', 1, INT2FIX(1));
    }
                
    rationalize([eps]) → rational click to toggle source

    Returns the value as a rational. The 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);
    }
                
    round([ndigits]) → integer or float click to toggle source

    Rounds int 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;
        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;
        }
        return int_round_0(num, ndigits);
    }
                
    succ → integer click to toggle source

    Returns the Integer equal to int + 1, same as #next.

    1.next      #=> 2
    (-1).next   #=> 0
    
     
                   VALUE
    rb_int_succ(VALUE num)
    {
        if (FIXNUM_P(num)) {
            long i = FIX2LONG(num) + 1;
            return LONG2NUM(i);
        }
        if (RB_TYPE_P(num, T_BIGNUM)) {
            return rb_big_plus(num, INT2FIX(1));
        }
        return rb_funcall(num, '+', 1, INT2FIX(1));
    }
                
    times {|i| block } → self click to toggle source
    times → an_enumerator

    Iterates the given 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
    #=> 0 1 2 3 4
    
     
                   static VALUE
    int_dotimes(VALUE num)
    {
        RETURN_SIZED_ENUMERATOR(num, 0, 0, int_dotimes_size);
    
        if (FIXNUM_P(num)) {
            long i, end;
    
            end = FIX2LONG(num);
            for (i=0; i<end; i++) {
                rb_yield_1(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;
    }
                
    to_i → integer click to toggle source

    As int is already an Integer, all these methods simply return the receiver.

    Synonyms are to_int, floor, ceil, truncate.

     
                   static VALUE
    int_to_i(VALUE num)
    {
        return num;
    }
                
    to_i → integer click to toggle source

    As int is already an Integer, all these methods simply return the receiver.

    Synonyms are to_int, floor, ceil, truncate.

     
                   static VALUE
    int_to_i(VALUE num)
    {
        return num;
    }
                
    to_r → rational click to toggle source

    Returns the value as a rational.

    1.to_r        #=> (1/1)
    (1<<64).to_r  #=> (18446744073709551616/1)
    
     
                   static VALUE
    integer_to_r(VALUE self)
    {
        return rb_rational_new1(self);
    }
                
    to_i → integer click to toggle source

    As int is already an Integer, all these methods simply return the receiver.

    Synonyms are to_int, floor, ceil, truncate.

     
                   static VALUE
    int_to_i(VALUE num)
    {
        return num;
    }
                
    upto(limit) {|i| block } → self click to toggle source
    upto(limit) → an_enumerator

    Iterates the given block, passing in integer values from int up to and including limit.

    If no block is given, an Enumerator is returned instead.

    For example:

    5.upto(10) { |i| print i, " " }
    #=> 5 6 7 8 9 10
    
     
                   static VALUE
    int_upto(VALUE from, VALUE to)
    {
        RETURN_SIZED_ENUMERATOR(from, 1, &to, int_upto_size);
        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;
    }