Extended maintenance of Ruby versions 1.8.7 and 1.9.2 ended on July 31, 2014. Read more

• rational.rb

Quicksearch

# Rational

Rational implements a rational class for numbers.

A rational number is a number that can be expressed as a fraction p/q where p and q are integers and q != 0. A rational number p/q is said to have numerator p and denominator q. Numbers that are not rational are called irrational numbers. (mathworld.wolfram.com/RationalNumber.html)

To create a Rational Number:

```Rational(a,b)             # -> a/b
Rational.new!(a,b)        # -> a/b
```

Examples:

```Rational(5,6)             # -> 5/6
Rational(5)               # -> 5/1
```

Rational numbers are reduced to their lowest terms:

```Rational(6,10)            # -> 3/5
```

But not if you use the unusual method “new!”:

```Rational.new!(6,10)       # -> 6/10
```

Division by zero is obviously not allowed:

```Rational(3,0)             # -> ZeroDivisionError
```

denominator[R]
numerator[R]

### Public Class Methods

new(num, den) click to toggle source

This method is actually private.

```
# File rational.rb, line 102
def initialize(num, den)
if den < 0
num = -num
den = -den
end
if num.kind_of?(Integer) and den.kind_of?(Integer)
@numerator = num
@denominator = den
else
@numerator = num.to_i
@denominator = den.to_i
end
end
```
new!(num, den = 1) click to toggle source

Implements the constructor. This method does not reduce to lowest terms or check for division by zero. Therefore #Rational() should be preferred in normal use.

```
# File rational.rb, line 93
def Rational.new!(num, den = 1)
new(num, den)
end
```
reduce(num, den = 1) click to toggle source

Reduces the given numerator and denominator to their lowest terms. Use Rational() instead.

```
# File rational.rb, line 71
def Rational.reduce(num, den = 1)
raise ZeroDivisionError, "denominator is zero" if den == 0

if den < 0
num = -num
den = -den
end
gcd = num.gcd(den)
num = num.div(gcd)
den = den.div(gcd)
if den == 1 && defined?(Unify)
num
else
new!(num, den)
end
end
```

### Public Instance Methods

%(other) click to toggle source

Returns the remainder when this value is divided by `other`.

Examples:

```r = Rational(7,4)    # -> Rational(7,4)
r % Rational(1,2)    # -> Rational(1,4)
r % 1                # -> Rational(3,4)
r % Rational(1,7)    # -> Rational(1,28)
r % 0.26             # -> 0.19
```
```
# File rational.rb, line 257
def % (other)
value = (self / other).floor
return self - other * value
end
```
*(a) click to toggle source

Returns the product of this value and `a`.

Examples:

```r = Rational(3,4)    # -> Rational(3,4)
r * 2                # -> Rational(3,2)
r * 4                # -> Rational(3,1)
r * 0.5              # -> 0.375
r * Rational(1,2)    # -> Rational(3,8)
```
```
# File rational.rb, line 173
def * (a)
if a.kind_of?(Rational)
num = @numerator * a.numerator
den = @denominator * a.denominator
Rational(num, den)
elsif a.kind_of?(Integer)
self * Rational.new!(a, 1)
elsif a.kind_of?(Float)
Float(self) * a
else
x, y = a.coerce(self)
x * y
end
end
```
**(other) click to toggle source

Returns this value raised to the given power.

Examples:

```r = Rational(3,4)    # -> Rational(3,4)
r ** 2               # -> Rational(9,16)
r ** 2.0             # -> 0.5625
r ** Rational(1,2)   # -> 0.866025403784439
```
```
# File rational.rb, line 220
def ** (other)
if other.kind_of?(Rational)
Float(self) ** other
elsif other.kind_of?(Integer)
if other > 0
num = @numerator ** other
den = @denominator ** other
elsif other < 0
num = @denominator ** -other
den = @numerator ** -other
elsif other == 0
num = 1
den = 1
end
Rational.new!(num, den)
elsif other.kind_of?(Float)
Float(self) ** other
else
x, y = other.coerce(self)
x ** y
end
end
```
+(a) click to toggle source

Returns the addition of this value and `a`.

Examples:

```r = Rational(3,4)      # -> Rational(3,4)
r + 1                  # -> Rational(7,4)
r + 0.5                # -> 1.25
```
```
# File rational.rb, line 124
def + (a)
if a.kind_of?(Rational)
num = @numerator * a.denominator
num_a = a.numerator * @denominator
Rational(num + num_a, @denominator * a.denominator)
elsif a.kind_of?(Integer)
self + Rational.new!(a, 1)
elsif a.kind_of?(Float)
Float(self) + a
else
x, y = a.coerce(self)
x + y
end
end
```
-(a) click to toggle source

Returns the difference of this value and `a`. subtracted.

Examples:

```r = Rational(3,4)    # -> Rational(3,4)
r - 1                # -> Rational(-1,4)
r - 0.5              # -> 0.25
```
```
# File rational.rb, line 148
def - (a)
if a.kind_of?(Rational)
num = @numerator * a.denominator
num_a = a.numerator * @denominator
Rational(num - num_a, @denominator*a.denominator)
elsif a.kind_of?(Integer)
self - Rational.new!(a, 1)
elsif a.kind_of?(Float)
Float(self) - a
else
x, y = a.coerce(self)
x - y
end
end
```
/(a) click to toggle source

Returns the quotient of this value and `a`.

```r = Rational(3,4)    # -> Rational(3,4)
r / 2                # -> Rational(3,8)
r / 2.0              # -> 0.375
r / Rational(1,2)    # -> Rational(3,2)
```
```
# File rational.rb, line 195
def / (a)
if a.kind_of?(Rational)
num = @numerator * a.denominator
den = @denominator * a.numerator
Rational(num, den)
elsif a.kind_of?(Integer)
raise ZeroDivisionError, "division by zero" if a == 0
self / Rational.new!(a, 1)
elsif a.kind_of?(Float)
Float(self) / a
else
x, y = a.coerce(self)
x / y
end
end
```
<=>(other) click to toggle source

Standard comparison operator.

```
# File rational.rb, line 309
def <=> (other)
if other.kind_of?(Rational)
num = @numerator * other.denominator
num_a = other.numerator * @denominator
v = num - num_a
if v > 0
return 1
elsif v < 0
return  -1
else
return 0
end
elsif other.kind_of?(Integer)
return self <=> Rational.new!(other, 1)
elsif other.kind_of?(Float)
return Float(self) <=> other
elsif defined? other.coerce
x, y = other.coerce(self)
return x <=> y
else
return nil
end
end
```
==(other) click to toggle source

Returns `true` iff this value is numerically equal to `other`.

But beware:

```Rational(1,2) == Rational(4,8)          # -> true
Rational(1,2) == Rational.new!(4,8)     # -> false
```

Don’t use ::new!

```
# File rational.rb, line 294
def == (other)
if other.kind_of?(Rational)
@numerator == other.numerator and @denominator == other.denominator
elsif other.kind_of?(Integer)
self == Rational.new!(other, 1)
elsif other.kind_of?(Float)
Float(self) == other
else
other == self
end
end
```
abs() click to toggle source

Returns the absolute value.

```
# File rational.rb, line 277
def abs
if @numerator > 0
self
else
Rational.new!(-@numerator, @denominator)
end
end
```
ceil() click to toggle source
```
# File rational.rb, line 360
def ceil()
-((-@numerator).div(@denominator))
end
```
coerce(other) click to toggle source
```
# File rational.rb, line 333
def coerce(other)
if other.kind_of?(Float)
return other, self.to_f
elsif other.kind_of?(Integer)
return Rational.new!(other, 1), self
else
super
end
end
```
div(other) click to toggle source
```
# File rational.rb, line 243
def div(other)
(self / other).floor
end
```
divmod(other) click to toggle source

Returns the quotient and remainder.

Examples:

```r = Rational(7,4)        # -> Rational(7,4)
r.divmod Rational(1,2)   # -> [3, Rational(1,4)]
```
```
# File rational.rb, line 269
def divmod(other)
value = (self / other).floor
return value, self - other * value
end
```
floor() click to toggle source

Converts the rational to an Integer. Not the nearest integer, the truncated integer. Study the following example carefully:

```Rational(+7,4).to_i             # -> 1
Rational(-7,4).to_i             # -> -1
(-1.75).to_i                    # -> -1
```

In other words:

```Rational(-7,4) == -1.75                 # -> true
Rational(-7,4).to_i == (-1.75).to_i     # -> true
```
```
# File rational.rb, line 356
def floor()
@numerator.div(@denominator)
end
```
hash() click to toggle source

Returns a hash code for the object.

```
# File rational.rb, line 427
def hash
@numerator.hash ^ @denominator.hash
end
```
inspect() click to toggle source

Returns a reconstructable string representation:

```Rational(5,8).inspect     # -> "Rational(5, 8)"
```
```
# File rational.rb, line 420
def inspect
sprintf("Rational(%s, %s)", @numerator.inspect, @denominator.inspect)
end
```
round() click to toggle source
```
# File rational.rb, line 373
def round()
if @numerator < 0
num = -@numerator
num = num * 2 + @denominator
den = @denominator * 2
-(num.div(den))
else
num = @numerator * 2 + @denominator
den = @denominator * 2
num.div(den)
end
end
```
to_f() click to toggle source

Converts the rational to a Float.

```
# File rational.rb, line 389
def to_f
@numerator.fdiv(@denominator)
end
```
to_i() click to toggle source
Alias for: truncate
to_r() click to toggle source

Returns `self`.

```
# File rational.rb, line 411
def to_r
self
end
```
to_s() click to toggle source

Returns a string representation of the rational number.

Example:

```Rational(3,4).to_s          #  "3/4"
Rational(8).to_s            #  "8"
```
```
# File rational.rb, line 400
def to_s
if @denominator == 1
@numerator.to_s
else
@numerator.to_s+"/"+@denominator.to_s
end
end
```
truncate() click to toggle source
```
# File rational.rb, line 364
def truncate()
if @numerator < 0
return -((-@numerator).div(@denominator))
end
@numerator.div(@denominator)
end
```
Also aliased as: to_i