ruby-1.8.7-rational.patch

kstephens (Kurt Stephens), 01/07/2010 03:43 am

+    #
     # Documentation by Kevin Jackson and Gavin Sinclair.
+    #
     # Performance improvements by Kurt Stephens.
+    #
     # When you <tt>require 'rational'</tt>, all interactions between numbers
     # potentially return a rational result.  For example:
+    #
-...
           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
         @numerator = num.to_i
         @denominator = den.to_i
       end
+      #
-...
       #   r + 0.5                # -> 1.25
+      #
       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
         case a
         when Rational # => Rational | Integer
           Rational(       (@numerator * a.denominator) + (a.numerator * @denominator), @denominator * a.denominator)
         when Integer  # => Rational
           Rational.reduce((@numerator                ) + (a           * @denominator), @denominator)
         when Float
           self.to_f + a
         else
           x, y = a.coerce(self)
           x + y
-...
       #   r - 0.5              # -> 0.25
+      #
       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
         case a
         when Rational # => Rational | Integer
           Rational(       (@numerator * a.denominator) - (a.numerator * @denominator), @denominator * a.denominator)
         when Integer  # => Rational
           Rational.reduce((@numerator                ) - (a           * @denominator), @denominator)
         when Float
           self.to_f - a
         else
           x, y = a.coerce(self)
           x - y
-...
       end
+      #
       # Unary Minus--Returns the receiver's value, negated.
+      #
       def -@
         Rational.new!(- @numerator, @denominator)
       end
+      #
       # Returns the product of this value and +a+.
+      #
       # Examples:
-...
       #   r * Rational(1,2)    # -> Rational(3,8)
+      #
       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
         case a
         when Rational
           Rational(@numerator * a.numerator, @denominator * a.denominator)
         when Integer
           Rational(@numerator * a          , @denominator)
         when Float
           self.to_f * a
         else
           x, y = a.coerce(self)
           x * y
-...
       #   r / Rational(1,2)    # -> Rational(3,2)
+      #
       def / (a)
         if a.kind_of?(Rational)
           num = @numerator * a.denominator
           den = @denominator * a.numerator
           Rational(num, den)
         elsif a.kind_of?(Integer)
         case a
         when Rational
           Rational(@numerator * a.denominator, @denominator * a.numerator)
         when Integer
           raise ZeroDivisionError, "division by zero" if a == 0
           self / Rational.new!(a, 1)
         elsif a.kind_of?(Float)
           Float(self) / a
           Rational(@numerator                , @denominator * a          )
         when Float
           self.to_f / a
         else
           x, y = a.coerce(self)
           x / y
-...
       #   r ** Rational(1,2)   # -> 0.866025403784439
+      #
       def ** (other)
         if other.kind_of?(Rational)
           Float(self) ** other
         elsif other.kind_of?(Integer)
         case other
         when Rational, Float
           self.to_f ** other
         when Integer
           if other > 0
     	num = @numerator ** other
     	den = @denominator ** other
     	Rational.new!(@numerator ** other, @denominator ** other)
           elsif other < 0
     	num = @denominator ** -other
     	den = @numerator ** -other
           elsif other == 0
     	num = 1
     	den = 1
     	Rational.new!(@denominator ** -other, @numerator ** -other)
           else
     	Rational.new!(1, 1) # why not Fixnum 1?
           end
           Rational.new!(num, den)
         elsif other.kind_of?(Float)
           Float(self) ** other
         else
           x, y = other.coerce(self)
           x ** y
-...
+      #
       def % (other)
         value = (self / other).floor
         return self - other * value
         self - other * value
       end
+      #
-...
+      #
       def divmod(other)
         value = (self / other).floor
         return value, self - other * value
         [ value, self - other * value ]
       end
+      #
-...
         end
       end
       # Returns true or false.
       def zero?
         @numerator.zero?
       end
       # See Numeric#nonzero?
       def nonzero?
         @numerator.nonzero? ? self : nil
       end
+      #
       # Returns +true+ iff this value is numerically equal to +other+.
+      #
-...
       # Don't use Rational.new!
+      #
       def == (other)
         if other.kind_of?(Rational)
         case other
         when 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
         when Integer
           @numerator == other && @denominator == 1
         when Float
           self.to_f == other
         else
           other == self
         end
-...
       # Standard comparison operator.
+      #
       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
         case other
         when Rational
           ((@numerator * other.denominator) <=> (other.numerator * @denominator))
         when Integer
           ((@numerator                    ) <=> (other           * @denominator))
         when Float
           self.to_f <=> other
         else
           return nil
           if defined? other.coerce
             x, y = other.coerce(self)
             x <=> y
           end # nil
         end
       end
       def coerce(other)
         if other.kind_of?(Float)
           return other, self.to_f
         elsif other.kind_of?(Integer)
           return Rational.new!(other, 1), self
         case other
         when Float
           [ other, self.to_f ]
         when Integer
           [ Rational.new!(other, 1), self ]
         else
           super
         end
-...
       def truncate()
         if @numerator < 0
           return -((-@numerator).div(@denominator))
           -((-@numerator).div(@denominator))
         else
           @numerator.div(@denominator)
         end
         @numerator.div(@denominator)
       end
       alias_method :to_i, :truncate
       def round()
         if @numerator < 0
           num = -@numerator
           num = num * 2 + @denominator
           den = @denominator * 2
           -(num.div(den))
           -((@numerator * -2 + @denominator).div(@denominator * 2))
         else
           num = @numerator * 2 + @denominator
           den = @denominator * 2
           num.div(den)
           ((@numerator * 2 + @denominator).div(@denominator * 2))
         end
       end
-...
         if @denominator == 1
           @numerator.to_s
         else
           @numerator.to_s+"/"+@denominator.to_s
           "#{@numerator}/#{@denominator}"
         end
       end
-...
       #   Rational(5,8).inspect     # -> "Rational(5, 8)"
+      #
       def inspect
         sprintf("Rational(%s, %s)", @numerator.inspect, @denominator.inspect)
         "Rational(#{@numerator.inspect}, #{@denominator.inspect})"
       end
+      #

         return Qtrue;
+    }
     static VALUE
     fix_gcd(int argc, VALUE *argv, VALUE self) {
       if ( argc != 1 ) {
         rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 1);
+      }
       /* Handle Fixnum#gcd(Fixnum) here. */
       if ( FIXNUM_P(argv[0]) ) {
         /* fprintf(stderr, "Using Fixnum#gcd(Fixnum)\n"); */
         long a = FIX2LONG(self);
         long b = FIX2LONG(argv[0]);
         long min = a < 0 ? - a : a;
         long max = b < 0 ? - b : b;
         while ( min > 0 ) {
           int tmp = min;
           min = max % min;
           max = tmp;
+        }
         return LONG2FIX(max);
       } else {
         /* Delegate to Integer#gcd. */
         return rb_call_super(1, argv);
+      }
+    }
     void
     Init_Numeric()
+    {
-...
         rb_define_method(rb_cFixnum, "divmod", fix_divmod, 1);
         rb_define_method(rb_cFixnum, "quo", fix_quo, 1);
         rb_define_method(rb_cFixnum, "fdiv", fix_quo, 1);
         rb_define_method(rb_cFixnum, "gcd", fix_gcd, -1);
         rb_define_method(rb_cFixnum, "**", fix_pow, 1);
         rb_define_method(rb_cFixnum, "abs", fix_abs, 0);

Ruby » Ruby 1.8

ruby-1.8.7-rational.patch