Class: Rational

Class | Rational
In: | rational.rb
Parent: | Numeric

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

### Methods

% * ** + - / <=> == abs coerce divmod hash inspect new new! reduce to_f to_i to_r to_s

### Attributes

denominator | [R] |
numerator | [R] |

### Public Class methods

new(num, den)

This method is actually private.

[Source]

    # 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)

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.

[Source]

    # File rational.rb, line 93
      def Rational.new!(num, den = 1)
        new(num, den)
      end

reduce(num, den = 1)

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

[Source]

    # 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)

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

[Source]

    # File rational.rb, line 253
      def % (other)
        value = (self / other).to_i
        return self - other * value
      end

*(a)

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)

[Source]

    # 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)

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

[Source]

    # 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)

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

[Source]

    # 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)

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

[Source]

    # 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)

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)

[Source]

    # 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)

Standard comparison operator.

[Source]

    # File rational.rb, line 305
      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)

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!

[Source]

    # File rational.rb, line 290
      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()

Returns the absolute value.

[Source]

    # File rational.rb, line 273
      def abs
        if @numerator > 0
          Rational.new!(@numerator, @denominator)
        else
          Rational.new!(-@numerator, @denominator)
        end
      end

coerce(other)

[Source]

    # File rational.rb, line 329
      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

divmod(other)

Returns the quotient and remainder.

Examples:

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

[Source]

    # File rational.rb, line 265
      def divmod(other)
        value = (self / other).to_i
        return value, self - other * value
      end

hash()

Returns a hash code for the object.

[Source]

    # File rational.rb, line 395
      def hash
        @numerator.hash ^ @denominator.hash
      end

inspect()

Returns a reconstructable string representation:

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

[Source]

    # File rational.rb, line 388
      def inspect
        sprintf("Rational(%s, %s)", @numerator.inspect, @denominator.inspect)
      end

to_f()

Converts the rational to a Float.

[Source]

    # File rational.rb, line 357
      def to_f
        @numerator.to_f/@denominator.to_f
      end

to_i()

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             # -> -2
      (-1.75).to_i                    # -> -1

In other words:

      Rational(-7,4) == -1.75                 # -> true
      Rational(-7,4).to_i == (-1.75).to_i     # false

[Source]

    # File rational.rb, line 350
      def to_i
        Integer(@numerator.div(@denominator))
      end

to_r()

Returns `self`.

[Source]

    # File rational.rb, line 379
      def to_r
        self
      end

to_s()

Returns a string representation of the rational number.

Example:

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

[Source]

    # File rational.rb, line 368
      def to_s
        if @denominator == 1
          @numerator.to_s
        else
          @numerator.to_s+"/"+@denominator.to_s
        end
      end

[Validate]