123456789_123456789_123456789_123456789_123456789_

Class: Fixnum

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::Integer, ::Numeric
Instance Chain:
self, ::Integer, ::Numeric, ::Comparable
Inherits: Integer
Defined in: numeric.c,
numeric.c

Overview

Holds Integer values that can be represented in a native machine word (minus 1 bit). If any operation on a Fixnum exceeds this range, the value is automatically converted to a ::Bignum.

Fixnum objects have immediate value. This means that when they are assigned or passed as parameters, the actual object is passed, rather than a reference to that object.

Assignment does not alias Fixnum objects. There is effectively only one Fixnum object instance for any given integer value, so, for example, you cannot add a singleton method to a Fixnum. Any attempt to add a singleton method to a Fixnum object will raise a ::TypeError.

Instance Attribute Summary

::Integer - Inherited

#even?

Returns true if int is an even number.
#integer?

Since int is already an ::Integer, this always returns true.
#odd?

Returns true if int is an odd number.

::Numeric - Inherited

#integer?

Returns true if num is an ::Integer (including Fixnum and ::Bignum).
#nonzero?

Returns self if num is not zero, nil otherwise.
#real

Returns self.
#real?

Returns true if num is a Real number.
#zero?

Returns true if num has a zero value.

Instance Method Summary

::Integer - Inherited

#ceil

Alias for Integer#to_i.
#chr

Returns a string containing the character represented by the int's value according to encoding.
#denominator

Returns 1.
#downto

Iterates the given block, passing decreasing values from int down to and including limit.
#floor

Alias for Integer#to_i.
#gcd

Returns the greatest common divisor (always positive).
#gcdlcm

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

Returns the least common multiple (always positive).
#next

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

Returns self.
#ord

Returns the int itself.
#pred

Returns the ::Integer equal to int - 1.
#rationalize

Returns the value as a rational.
#round

Rounds int to a given precision in decimal digits (default 0 digits).
#succ

Alias for Integer#next.
#times

Iterates the given block int times, passing in values from zero to int - 1.
#to_i

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

Alias for Integer#to_i.
#to_r

Returns the value as a rational.
#truncate

Alias for Integer#to_i.
#upto

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

::Numeric - Inherited

#%

x.modulo(y) means x-y*(x/y).floor.
#+@

Unary Plus—Returns the receiver's value.
#-@

Unary Minus—Returns the receiver's value, negated.
#<=>

Returns zero if number equals other, otherwise nil is returned if the two values are incomparable.
#abs

Returns the absolute value of num.
#abs2

Returns square of self.
#angle

Alias for Numeric#arg.
#arg

Returns 0 if the value is positive, pi otherwise.
#ceil

Returns the smallest possible ::Integer that is greater than or equal to num.
#coerce

If a +numeric is the same type as num, returns an array containing numeric and num.
#conj

Returns self.
#conjugate

Alias for Numeric#conj.
#denominator

Returns the denominator (always positive).
#div

Uses #/ to perform division, then converts the result to an integer.
#divmod

Returns an array containing the quotient and modulus obtained by dividing num by numeric.
#eql?

Returns true if num and numeric are the same type and have equal values.
#fdiv

Returns float division.
#floor

Returns the largest integer less than or equal to num.
#i

Returns the corresponding imaginary number.
#imag

Returns zero.
#imaginary

Alias for Numeric#imag.
#initialize_copy

Numerics are immutable values, which should not be copied.
#magnitude

Alias for Numeric#abs.
#modulo

Alias for Numeric#%.
#numerator

Returns the numerator.
#phase

Alias for Numeric#arg.
#polar

Returns an array; [num.abs, num.arg].
#quo

Returns most exact division (rational for integers, float for floats).
#rect

Returns an array; [num, 0].
#rectangular

Alias for Numeric#rect.
#remainder

x.remainder(y) means x-y*(x/y).truncate.
#round

Rounds num to a given precision in decimal digits (default 0 digits).
#singleton_method_added

Trap attempts to add methods to ::Numeric objects.
#step

Invokes the given block with the sequence of numbers starting at num, incremented by step (defaulted to 1) on each call.
#to_c

Returns the value as a complex.
#to_int

Invokes the child class's to_i method to convert num to an integer.
#truncate

Returns num truncated to an ::Integer.

::Comparable - Included

#<

Compares two objects based on the receiver's #<=> method, returning true if it returns -1.
#<=

Compares two objects based on the receiver's #<=> method, returning true if it returns -1 or 0.
#==

Compares two objects based on the receiver's #<=> method, returning true if it returns 0.
#>

Compares two objects based on the receiver's #<=> method, returning true if it returns 1.
#>=

Compares two objects based on the receiver's #<=> method, returning true if it returns 0 or 1.
#between?

Returns false if obj #<=> min is less than zero or if anObject #<=> max is greater than zero, true otherwise.

Instance Attribute Details

#even? ⇒ Boolean (readonly)

Returns true if fix is an even number.

#odd? ⇒ Boolean (readonly)

Returns true if fix is an odd number.

#zero? ⇒ Boolean (readonly)

Returns true if fix is zero.

Instance Method Details

#%(other) ⇒ Numeric #modulo(other) ⇒ Numeric
Also known as: #modulo

Returns fix modulo other.

See Numeric#divmod for more information.

#&(integer) ⇒ integer_result

Bitwise AND.

#*(numeric) ⇒ numeric_result

Performs multiplication: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a ::Bignum.

#**(numeric) ⇒ numeric_result

Raises fix to the power of numeric, which may be negative or fractional.

2 ** 3      #=> 8
2 ** -1     #=> (1/2)
2 ** 0.5    #=> 1.4142135623731

#+(numeric) ⇒ numeric_result

Performs addition: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a ::Bignum.

#-(numeric) ⇒ numeric_result

Performs subtraction: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a ::Bignum.

#- ⇒ Integer

Negates fix, which may return a ::Bignum.

#/(numeric) ⇒ numeric_result

Performs division: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a ::Bignum.

#<(real) ⇒ Boolean

Returns true if the value of fix is less than that of real.

#<<(count) ⇒ Integer

Shifts fix left count positions, or right if count is negative.

#<=(real) ⇒ Boolean

Returns true if the value of fix is less than or equal to that of real.

#<=>(numeric) ⇒ 1, ...

Comparison—Returns -1, 0, +1 or nil depending on whether fix is less than, equal to, or greater than numeric.

This is the basis for the tests in the ::Comparable module.

nil is returned if the two values are incomparable.

#==(other) ⇒ Boolean Also known as: #===

Return true if fix equals other numerically.

1 == 2      #=> false
1 == 1.0    #=> true

#==(other) ⇒ Boolean #===(other) ⇒ Boolean

Alias for #==.

#>(real) ⇒ Boolean

Returns true if the value of fix is greater than that of real.

#>=(real) ⇒ Boolean

Returns true if the value of fix is greater than or equal to that of real.

#>>(count) ⇒ Integer

Shifts fix right count positions, or left if count is negative.

#[](n) ⇒ 0, 1

Bit Reference—Returns the nth bit in the binary representation of fix, where fix[0] is the least significant bit.

For example:

a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010

#^(integer) ⇒ integer_result

Bitwise EXCLUSIVE OR.

#abs ⇒ Integer #magnitude ⇒ Integer
Also known as: #magnitude

Returns the absolute value of fix.

-12345.abs   #=> 12345
12345.abs    #=> 12345

#bit_length ⇒ Integer

Returns the number of bits of the value of int.

“the number of bits” means that the bit position of the highest bit which is different to the sign bit. (The bit position of the bit 2**n is n+1.) If there is no such bit (zero or minus one), zero is returned.

I.e. This method returns ceil(log2(int < 0 ? -int : int+1)).

(-2**12-1).bit_length     #=> 13
(-2**12).bit_length       #=> 12
(-2**12+1).bit_length     #=> 12
-0x101.bit_length         #=> 9
-0x100.bit_length         #=> 8
-0xff.bit_length          #=> 8
-2.bit_length             #=> 1
-1.bit_length             #=> 0
0.bit_length              #=> 0
1.bit_length              #=> 1
0xff.bit_length           #=> 8
0x100.bit_length          #=> 9
(2**12-1).bit_length      #=> 12
(2**12).bit_length        #=> 13
(2**12+1).bit_length      #=> 13

This method can be used to detect overflow in Array#pack as follows.

if n.bit_length < 32
  [n].pack("l") # no overflow
else
  raise "overflow"
end

#div(numeric) ⇒ Integer

Performs integer division: returns integer result of dividing fix by numeric.

#divmod(numeric) ⇒ Array

See Numeric#divmod.

#fdiv(numeric) ⇒ Float

Returns the floating point result of dividing fix by numeric.

654321.fdiv(13731)      #=> 47.6528293642124
654321.fdiv(13731.24)   #=> 47.6519964693647

#to_s(base = 10) ⇒ String #inspect(base = 10) ⇒ String

Alias for #to_s.

#abs ⇒ Integer #magnitude ⇒ Integer

Alias for #abs.

#%(other) ⇒ Numeric #modulo(other) ⇒ Numeric

Alias for #%.

#size ⇒ Fixnum

Returns the number of bytes in the machine representation of fix.

1.size            #=> 4
-1.size           #=> 4
2147483647.size   #=> 4

#next ⇒ Integer #succ ⇒ Integer

Returns the ::Integer equal to int + 1.

1.next      #=> 2
(-1).next   #=> 0

#to_f ⇒ Float

Converts fix to a ::Float.

#to_s(base = 10) ⇒ String Also known as: #inspect

Returns a string containing the representation of fix radix base (between 2 and 36).

12345.to_s       #=> "12345"
12345.to_s(2)    #=> "11000000111001"
12345.to_s(8)    #=> "30071"
12345.to_s(10)   #=> "12345"
12345.to_s(16)   #=> "3039"
12345.to_s(36)   #=> "9ix"

#|(integer) ⇒ integer_result

Bitwise OR.

#~ ⇒ Integer

One's complement: returns a number where each bit is flipped.