Chapter 5. Math

Math > Class Hierarchy and Included Modules

Chapter 5. Math

In other programming languages, numbers are primitives, or basic building blocks, that are used by other objects to create logic. In Ruby, everything (almost) is an object, even numbers. For example, here are some numbers that are considered primitives by other languages. What classes do they come from?

2.class # => Fixnum
2.0.class # => Float
2_000_000_000.class # => Bignum

There's the proof in living code: Ruby does turn almost everything into an object. (The underscores in the last number, by the way, are just there for readability; the Ruby interpreter ignores them.)

Ruby has a number of classes and modules related to numbers. Here are the more important ones:

Numeric

The base class for numbers

Integer

The basic integer class, and the basis for the Fixnum class

Float

The class for real or floating-point numbers, based on the computer's native capacity to represent double-precision

Fixnum

The main integer class, based on what the computer can hold in a native machine word, such as 32 bits or 64 bits, minus 1

Bignum

The class of integers outside the range of the basic, native machine word

Math

A module that holds math functions (as methods)

Precision

A module for approximating the precision of real numbers

Rational

A class that represents fractional numbers

Complex

A class that represents complex numbers, which extend real numbers with imaginary numbers (x + iy)

Matrix

A class for creating mathematical matrixes

A hierarchy of the math classes, along with modules, is shown in Figure 5-1.

Figure 5-1. Math class and module hierarchy

5.1. Class Hierarchy and Included Modules

By the way, a handy way to quickly determine the hierarchy of a math class (or any other Ruby class) is with the ancestors method, one of Ruby's reflection methods. (Reflection is a term that describes a programming language's ability to observe itself and report on what it sees. Ruby is good at reflection, and you'll learn more about it in Chapter 10.) Call ancestors on a class name to see its inheritance hierarchy, like this:

Code View: Scroll / Show All

Fixnum.ancestors # => [Fixnum, Integer, Precision, Numeric, Comparable, Object,
Kernel]


					  

The names of included modules Precision, Comparable, and Kernel are also in the genealogy. In addition, you can use the included_modules method to discover what modules a class uses:

Object.included_modules # => [Kernel]
Numeric.included_modules # => [Comparable, Kernel]
Integer.included_modules # => [Precision, Comparable, Kernel]
Fixnum.included_modules # => [Precision, Comparable, Kernel]