Class: Rational

Inherits:
Numeric
  • Object
show all
Defined in:
lib/rational.rb

Overview

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#denominator ⇒ Object (readonly)

Returns the value of attribute denominator



432
433
434
 
# File 'lib/rational.rb', line 432

def denominator
  @denominator
end

#numerator ⇒ Object (readonly)

Returns the value of attribute numerator



431
432
433
 
# File 'lib/rational.rb', line 431

def numerator
  @numerator
end

Class Method Details

.new!(num, den = 1) ⇒ Object

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.



93
94
95
 
# File 'lib/rational.rb', line 93

def Rational.new!(num, den = 1)
  new(num, den)
end

.reduce(num, den = 1) ⇒ Object

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

Raises:

  • (ZeroDivisionError) 


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/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

Instance Method Details

#%(other) ⇒ Object

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



257
258
259
260
 
# File 'lib/rational.rb', line 257

def % (other)
  value = (self / other).floor
  return self - other * value
end

#*(a) ⇒ Object

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)



173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/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) ⇒ Object

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



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/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) ⇒ Object

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



124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/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) ⇒ Object

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



148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/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) ⇒ Object

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)



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/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) ⇒ Object

Standard comparison operator.



309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/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) ⇒ Object

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 Rational.new!



294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/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 ⇒ Object

Returns the absolute value.



277
278
279
280
281
282
283
 
# File 'lib/rational.rb', line 277

def abs
  if @numerator > 0
    self
  else
    Rational.new!(-@numerator, @denominator)
  end
end

#ceil ⇒ Object 



360
361
362
 
# File 'lib/rational.rb', line 360

def ceil()
  -((-@numerator).div(@denominator))
end

#coerce(other) ⇒ Object 



333
334
335
336
337
338
339
340
341
 
# File 'lib/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) ⇒ Object 



243
244
245
 
# File 'lib/rational.rb', line 243

def div(other)
  (self / other).floor
end

#divmod(other) ⇒ Object

Returns the quotient and remainder.

Examples:

r = Rational(7,4)        # -> Rational(7,4)
r.divmod Rational(1,2)   # -> [3, Rational(1,4)]



269
270
271
272
 
# File 'lib/rational.rb', line 269

def divmod(other)
  value = (self / other).floor
  return value, self - other * value
end

#floor ⇒ Object 



356
357
358
 
# File 'lib/rational.rb', line 356

def floor()
  @numerator.div(@denominator)
end

#hash ⇒ Object

Returns a hash code for the object.



427
428
429
 
# File 'lib/rational.rb', line 427

def hash
  @numerator.hash ^ @denominator.hash
end

#inspect ⇒ Object

Returns a reconstructable string representation:

Rational(5,8).inspect     # -> "Rational(5, 8)"



420
421
422
 
# File 'lib/rational.rb', line 420

def inspect
  sprintf("Rational(%s, %s)", @numerator.inspect, @denominator.inspect)
end

#round ⇒ Object 



373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/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 ⇒ Object

Converts the rational to a Float.



389
390
391
 
# File 'lib/rational.rb', line 389

def to_f
  @numerator.fdiv(@denominator)
end

#to_r ⇒ Object

Returns self.



411
412
413
 
# File 'lib/rational.rb', line 411

def to_r
  self
end

#to_s ⇒ Object

Returns a string representation of the rational number.

Example:

Rational(3,4).to_s          #  "3/4"
Rational(8).to_s            #  "8"



400
401
402
403
404
405
406
 
# File 'lib/rational.rb', line 400

def to_s
  if @denominator == 1
    @numerator.to_s
  else
    @numerator.to_s+"/"+@denominator.to_s
  end
end

#truncate ⇒ Object Also known as: to_i 



364
365
366
367
368
369
 
# File 'lib/rational.rb', line 364

def truncate()
  if @numerator < 0
    return -((-@numerator).div(@denominator))
  end
  @numerator.div(@denominator)
end