In the figure the class hierarchy of the numeric classes; some methods of the classes are listed in the figure.

The classes for numbers are: **Float**, **Complex**, **Integer**, **Rational**; there
are two subclass of *Integer*: **Bignum** and **Fixnum**;
Bignum are numbers with an arbitrary number of digits; Fixnum
are 8 bytes long integers, (but different platform can have different lengths);
conversion between Bignum and Fixnum is automatically
managed by Ruby: when a number is less than
about 4E9 it's a Fixnum, otherwise it is a Bignum.
Integer numbers can be built with
the **Integer method**, converting its argument to an integer.
Integers can also be expressed in hexadecimal, octal or binary form:

0xis the prefix for hexadecimal representations

0bis the prefix prefix for binary representation

0is the prefix prefix for octal representation

Floats are double precision , **always a digit is needed before and after the point**:
".1" or "1." are not valid float numbers.
"e" or "E" is before the (optional) exponent.
Float numbers can be built with the **Float method**, converting its argument to a
float number.

There are two special values for floats: "*infinite*" and "*nan*",
to deal with float division by zero, but
integer division by zero raises the exception: ZeroDivisionError

0.0/0.0 => NaN 1.0/0.0 => Infinity 0/0 => ZeroDivisionError: ....

Rational numbers are the ratio of two integers, used to express periodic
numbers without a loss of precision.
Complex numbers are printed as sum of a real and an imaginary part. Es.: *(2+5i)* .

Rational and complex have some specific methods and
can be built with the "**Rational** and **Complex methods**:

Complex(1) => (1+0i) Complex(2, 3) => (2+3i) Complex(0.3) => (0.3+0i) Complex('0.3-0.5i') => (0.3-0.5i) Complex(2, 3).real => 2 # real part Complex(2, 3).imag => 3 # imaginary part) Complex(2, 3).conj => (2-3i) Complex(0,1).phase => 1.5707963267948966 # radians Complex(0,1).polar => [1, 1.5707963267948966] # modulus, phase Complex(0,1).rect => [0, 1] # Array with real and imaginary parts a=Rational("1/2") a=1.quo(5) # division between integers that gives a rational number Rational(1) => (1/1) Rational(2, 3) => (2/3) Rational(4, -6) => (-2/3) Rational('0.3') => (3/10) Rational('2/3') => (2/3) Rational('0.5') => (1/2) (Rational(3,2)).numerator => 3 (Rational(3,2)).denominator => 2 (Rational(3,2)).truncate => 1 (Rational(3,2)).round => 2

**Underscores can be used inside numbers** to separate digits:

a=1_000_000 => 1000000 b=2_000.0_1 => 2000.01

All numerical operators are implemented as methods of the
Numeric class: for this reason a function-like notation is legal for operators:
"*1.+(2)*" can be used, and returns the number 3, as: "*1+2*".

The comparison operators: *< ; > ; <= ; >=, == ; between?*
are implemented in the **Comparable module**; each numeric class implements
in a different way only the operator: *<=>* (sometimes named: *spaceship* operator);
the Comparable operators use the *<=>* operator of the specific class to give results.
This mechanism is similar to the use virtual functions of
the C++ language.

In the following table the most used methods of Numerics are included, also those which apply only to some subclasses of Numerics.

Operator | Function | Examples |
---|---|---|

** ; pow(x,y) | power | a**3 |

* / | Multiplication,division | a*b ; 3*2 => 6 ; 3/2=1 |

% | Remainder | 5/2. => 1.0 |

+ - | Addition, subtraction | a+b ; 2+5 => 7 |

<< >> | bitwise shift | 4<<1 => 8 |

& | ^ | bitwise and, or, xor | |

<=> | comparisons, returns: -1, 0 , 1 ; if less, equal greater | |

< > <= >= | comparisons | 4<1=> false |

between? | inclusion in a range | 2.between?(1,4) => true |

== != | equal, not equal | |

zero? | true if zero | 3.2.zero? => false |

eql? | same value AND type | 1.0.eql? 1 => false |

equal? | reference equality: if a is the same object as b: a.equal?(b) => true | |

abs ; magnitude | Absolute value | -1.abs => 1 |

abs2 | square modulus | -2.abs2 => 4 |

ceil | minimum greater integer | 1.2.ceil => 2 ; -1.2.ceil => -1 |

floor | maximum lower integer | 1.7.floor =>1 ; -1.2.floor =>-2 |

round | rounds a number | 1.4.round => 1 ; 1.5.round => 2 |

div | integer division | 5.2.div(2.0) => 2 |

divmod | quotient and remainder | 5.divmod(2) => Array :[2, 1] |

fdiv | float division | 3.fdiv(2) => 1.5 |

quo | division with maximum precision (Rational numbers if integer operands) |

even? | true if even | 2.even? => true |

odd? | true if odd | 3.odd? => true |

next ; succ | next integer | 1.next => 2 |

pred | previous integer | 2.pred =>1 |

gcd | greatest common denominator | 10.gcd(15) => 5 |

lcm | lowest common multiple | 10.lcm 15 => 30 |

finite? | true if finite | (1.0/0.0).finite? => false |

infinite? | test if infinite | (-1.0/0.0).infinite? => -1 |

nan? | test if not a number | (0.0/0.0).nan? => true |

**to_s** # converts to string, for fixmum the argument is the base, es.: 16.to_s => "16" ; 16.to_s(2) => "10000" ; 16.to_s(16) => "10" **to_i** # converts to integer; **to_f** # converts to float; **to_r** # converts to rational

The subscript operator "**[]**" can be used for Fixnum,
and returns single bits of a number:

2[0] => 0 2[1] => 1 3[0] => 1 3[1] => 1 3[2] => 0

In the following some operators are listed, ordered by precedence (high to low precedence):

[ ] [ ]= ** ! ~ + - (unary operators) * / % + - >> << & ^ | <= < > >= <=> == === != =~ !~ && || .. ... ?: = %= /= -= += |= &= >>= <<= *= &&= ||= **= ^= not or and if unless while until begin/end