-require_relative '../../spec_helper'

-require_relative '../../fixtures/rational'

-

-describe :kernel_Rational, shared: true do

- describe "passed Integer" do

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- it "returns a new Rational number with 1 as the denominator" do

- Rational(1).should eql(Rational(1, 1))

- Rational(-3).should eql(Rational(-3, 1))

- Rational(bignum_value).should eql(Rational(bignum_value, 1))

- end

- end

- end

-

- describe "passed two integers" do

- it "returns a new Rational number" do

- rat = Rational(1, 2)

- rat.numerator.should == 1

- rat.denominator.should == 2

- rat.should be_an_instance_of(Rational)

-

- rat = Rational(-3, -5)

- rat.numerator.should == 3

- rat.denominator.should == 5

- rat.should be_an_instance_of(Rational)

-

- rat = Rational(bignum_value, 3)

- rat.numerator.should == bignum_value

- rat.denominator.should == 3

- rat.should be_an_instance_of(Rational)

- end

-

- it "reduces the Rational" do

- rat = Rational(2, 4)

- rat.numerator.should == 1

- rat.denominator.should == 2

-

- rat = Rational(3, 9)

- rat.numerator.should == 1

- rat.denominator.should == 3

- end

- end

-

- describe "when passed a String" do

- it "converts the String to a Rational using the same method as String#to_r" do

- r = Rational(13, 25)

- s_r = ".52".to_r

- r_s = Rational(".52")

-

- r_s.should == r

- r_s.should == s_r

- end

-

- it "scales the Rational value of the first argument by the Rational value of the second" do

- Rational(".52", ".6").should == Rational(13, 15)

- Rational(".52", "1.6").should == Rational(13, 40)

- end

-

- it "does not use the same method as Float#to_r" do

- r = Rational(3, 5)

- f_r = 0.6.to_r

- r_s = Rational("0.6")

-

- r_s.should == r

- r_s.should_not == f_r

- end

- end

-

- describe "when passed a Numeric" do

- it "calls #to_r to convert the first argument to a Rational" do

- num = RationalSpecs::SubNumeric.new(2)

-

- Rational(num).should == Rational(2)

- end

- end

-

- describe "when passed a Complex" do

- it "returns a Rational from the real part if the imaginary part is 0" do

- Rational(Complex(1, 0)).should == Rational(1)

- end

-

- it "raises a RangeError if the imaginary part is not 0" do

- -> { Rational(Complex(1, 2)) }.should raise_error(RangeError)

- end

- end

-

- it "raises a ZeroDivisionError if the second argument is 0" do

- -> { Rational(1, 0) }.should raise_error(ZeroDivisionError, "divided by 0")

- -> { Rational(1, 0.0) }.should raise_error(ZeroDivisionError, "divided by 0")

- end

-

- it "raises a TypeError if the first argument is nil" do

- -> { Rational(nil) }.should raise_error(TypeError)

- end

-

- it "raises a TypeError if the second argument is nil" do

- -> { Rational(1, nil) }.should raise_error(TypeError)

- end

-

- it "raises a TypeError if the first argument is a Symbol" do

- -> { Rational(:sym) }.should raise_error(TypeError)

- end

-

- it "raises a TypeError if the second argument is a Symbol" do

- -> { Rational(1, :sym) }.should raise_error(TypeError)

- end

-

- describe "when passed exception: false" do

- describe "and [non-Numeric]" do

- it "swallows an error" do

- Rational(:sym, exception: false).should == nil

- Rational("abc", exception: false).should == nil

- end

- end

-

- describe "and [non-Numeric, Numeric]" do

- it "swallows an error" do

- Rational(:sym, 1, exception: false).should == nil

- Rational("abc", 1, exception: false).should == nil

- end

- end

-

- describe "and [anything, non-Numeric]" do

- it "swallows an error" do

- Rational(:sym, :sym, exception: false).should == nil

- Rational("abc", :sym, exception: false).should == nil

- end

- end

-

- describe "and non-Numeric String arguments" do

- it "swallows an error" do

- Rational("a", "b", exception: false).should == nil

- Rational("a", 0, exception: false).should == nil

- Rational(0, "b", exception: false).should == nil

- end

- end

-

- describe "and nil arguments" do

- it "swallows an error" do

- Rational(nil, exception: false).should == nil

- Rational(nil, nil, exception: false).should == nil

- end

- end

- end

-

- it "freezes its result" do

- Rational(1).frozen?.should == true

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_abs, shared: true do

- it "returns self's absolute value" do

- Rational(3, 4).send(@method).should == Rational(3, 4)

- Rational(-3, 4).send(@method).should == Rational(3, 4)

- Rational(3, -4).send(@method).should == Rational(3, 4)

-

- Rational(bignum_value, -bignum_value).send(@method).should == Rational(bignum_value, bignum_value)

- end

-end

-require_relative '../../fixtures/rational'

-

-describe :rational_arithmetic_exception_in_coerce, shared: true do

- it "does not rescue exception raised in other#coerce" do

- b = mock("numeric with failed #coerce")

- b.should_receive(:coerce).and_raise(RationalSpecs::CoerceError)

-

- # e.g. Rational(3, 4) + b

- -> { Rational(3, 4).send(@method, b) }.should raise_error(RationalSpecs::CoerceError)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_ceil, shared: true do

- before do

- @rational = Rational(2200, 7)

- end

-

- describe "with no arguments (precision = 0)" do

- it "returns an Integer" do

- @rational.ceil.should be_kind_of(Integer)

- end

-

- it "returns the truncated value toward positive infinity" do

- @rational.ceil.should == 315

- Rational(1, 2).ceil.should == 1

- Rational(-1, 2).ceil.should == 0

- end

- end

-

- describe "with a precision < 0" do

- it "returns an Integer" do

- @rational.ceil(-2).should be_kind_of(Integer)

- @rational.ceil(-1).should be_kind_of(Integer)

- end

-

- it "moves the truncation point n decimal places left" do

- @rational.ceil(-3).should == 1000

- @rational.ceil(-2).should == 400

- @rational.ceil(-1).should == 320

- end

- end

-

- describe "with precision > 0" do

- it "returns a Rational" do

- @rational.ceil(1).should be_kind_of(Rational)

- @rational.ceil(2).should be_kind_of(Rational)

- end

-

- it "moves the truncation point n decimal places right" do

- @rational.ceil(1).should == Rational(3143, 10)

- @rational.ceil(2).should == Rational(31429, 100)

- @rational.ceil(3).should == Rational(157143, 500)

- end

- end

-end

-require_relative '../../spec_helper'

-require_relative '../../fixtures/rational'

-

-describe :rational_cmp_rat, shared: true do

- it "returns 1 when self is greater than the passed argument" do

- (Rational(4, 4) <=> Rational(3, 4)).should equal(1)

- (Rational(-3, 4) <=> Rational(-4, 4)).should equal(1)

- end

-

- it "returns 0 when self is equal to the passed argument" do

- (Rational(4, 4) <=> Rational(4, 4)).should equal(0)

- (Rational(-3, 4) <=> Rational(-3, 4)).should equal(0)

- end

-

- it "returns -1 when self is less than the passed argument" do

- (Rational(3, 4) <=> Rational(4, 4)).should equal(-1)

- (Rational(-4, 4) <=> Rational(-3, 4)).should equal(-1)

- end

-end

-

-describe :rational_cmp_int, shared: true do

- it "returns 1 when self is greater than the passed argument" do

- (Rational(4, 4) <=> 0).should equal(1)

- (Rational(4, 4) <=> -10).should equal(1)

- (Rational(-3, 4) <=> -1).should equal(1)

- end

-

- it "returns 0 when self is equal to the passed argument" do

- (Rational(4, 4) <=> 1).should equal(0)

- (Rational(-8, 4) <=> -2).should equal(0)

- end

-

- it "returns -1 when self is less than the passed argument" do

- (Rational(3, 4) <=> 1).should equal(-1)

- (Rational(-4, 4) <=> 0).should equal(-1)

- end

-end

-

-describe :rational_cmp_float, shared: true do

- it "returns 1 when self is greater than the passed argument" do

- (Rational(4, 4) <=> 0.5).should equal(1)

- (Rational(4, 4) <=> -1.5).should equal(1)

- (Rational(-3, 4) <=> -0.8).should equal(1)

- end

-

- it "returns 0 when self is equal to the passed argument" do

- (Rational(4, 4) <=> 1.0).should equal(0)

- (Rational(-6, 4) <=> -1.5).should equal(0)

- end

-

- it "returns -1 when self is less than the passed argument" do

- (Rational(3, 4) <=> 1.2).should equal(-1)

- (Rational(-4, 4) <=> 0.5).should equal(-1)

- end

-end

-

-describe :rational_cmp_coerce, shared: true do

- it "calls #coerce on the passed argument with self" do

- rational = Rational(3, 4)

-

- obj = mock("Object")

- obj.should_receive(:coerce).with(rational).and_return([1, 2])

-

- rational <=> obj

- end

-

- it "calls #<=> on the coerced Rational with the coerced Object" do

- rational = Rational(3, 4)

-

- coerced_rational = mock("Coerced Rational")

- coerced_rational.should_receive(:<=>).and_return(:result)

-

- coerced_obj = mock("Coerced Object")

-

- obj = mock("Object")

- obj.should_receive(:coerce).and_return([coerced_rational, coerced_obj])

-

- (rational <=> obj).should == :result

- end

-end

-

-describe :rational_cmp_coerce_exception, shared: true do

- it "does not rescue exception raised in other#coerce" do

- b = mock("numeric with failed #coerce")

- b.should_receive(:coerce).and_raise(RationalSpecs::CoerceError)

-

- -> { Rational(3, 4) <=> b }.should raise_error(RationalSpecs::CoerceError)

- end

-end

-

-describe :rational_cmp_other, shared: true do

- it "returns nil" do

- (Rational <=> mock("Object")).should be_nil

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_denominator, shared: true do

- it "returns the denominator" do

- Rational(3, 4).denominator.should equal(4)

- Rational(3, -4).denominator.should equal(4)

-

- Rational(1, bignum_value).denominator.should == bignum_value

- end

-

- it "returns 1 if no denominator was given" do

- Rational(80).denominator.should == 1

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_div_rat, shared: true do

- it "performs integer division and returns the result" do

- Rational(2, 3).div(Rational(2, 3)).should == 1

- Rational(-2, 9).div(Rational(-9, 2)).should == 0

- end

-

- it "raises a ZeroDivisionError when the argument has a numerator of 0" do

- -> { Rational(3, 4).div(Rational(0, 3)) }.should raise_error(ZeroDivisionError)

- end

-

- it "raises a ZeroDivisionError when the argument has a numerator of 0.0" do

- -> { Rational(3, 4).div(Rational(0.0, 3)) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_div_float, shared: true do

- it "performs integer division and returns the result" do

- Rational(2, 3).div(30.333).should == 0

- Rational(2, 9).div(Rational(-8.6)).should == -1

- Rational(3.12).div(0.5).should == 6

- end

-

- it "raises a ZeroDivisionError when the argument is 0.0" do

- -> { Rational(3, 4).div(0.0) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_div_int, shared: true do

- it "performs integer division and returns the result" do

- Rational(2, 1).div(1).should == 2

- Rational(25, 5).div(-50).should == -1

- end

-

- it "raises a ZeroDivisionError when the argument is 0" do

- -> { Rational(3, 4).div(0) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_div, shared: true do

- it "returns an Integer" do

- Rational(229, 21).div(82).should be_kind_of(Integer)

- end

-

- it "raises an ArgumentError if passed more than one argument" do

- -> { Rational(3, 4).div(2,3) }.should raise_error(ArgumentError)

- end

-

- # See http://redmine.ruby-lang.org/issues/show/1648

- it "raises a TypeError if passed a non-numeric argument" do

- -> { Rational(3, 4).div([]) }.should raise_error(TypeError)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_divide_rat, shared: true do

- it "returns self divided by other as a Rational" do

- Rational(3, 4).send(@method, Rational(3, 4)).should eql(Rational(1, 1))

- Rational(2, 4).send(@method, Rational(1, 4)).should eql(Rational(2, 1))

-

- Rational(2, 4).send(@method, 2).should == Rational(1, 4)

- Rational(6, 7).send(@method, -2).should == Rational(-3, 7)

- end

-

- it "raises a ZeroDivisionError when passed a Rational with a numerator of 0" do

- -> { Rational(3, 4).send(@method, Rational(0, 1)) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_divide_int, shared: true do

- it "returns self divided by other as a Rational" do

- Rational(3, 4).send(@method, 2).should eql(Rational(3, 8))

- Rational(2, 4).send(@method, 2).should eql(Rational(1, 4))

- Rational(6, 7).send(@method, -2).should eql(Rational(-3, 7))

- end

-

- it "raises a ZeroDivisionError when passed 0" do

- -> { Rational(3, 4).send(@method, 0) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_divide_float, shared: true do

- it "returns self divided by other as a Float" do

- Rational(3, 4).send(@method, 0.75).should eql(1.0)

- Rational(3, 4).send(@method, 0.25).should eql(3.0)

- Rational(3, 4).send(@method, 0.3).should eql(2.5)

-

- Rational(-3, 4).send(@method, 0.3).should eql(-2.5)

- Rational(3, -4).send(@method, 0.3).should eql(-2.5)

- Rational(3, 4).send(@method, -0.3).should eql(-2.5)

- end

-

- it "returns infinity when passed 0" do

- Rational(3, 4).send(@method, 0.0).infinite?.should eql(1)

- Rational(-3, -4).send(@method, 0.0).infinite?.should eql(1)

-

- Rational(-3, 4).send(@method, 0.0).infinite?.should eql(-1)

- Rational(3, -4).send(@method, 0.0).infinite?.should eql(-1)

- end

-end

-

-describe :rational_divide, shared: true do

- it "calls #coerce on the passed argument with self" do

- rational = Rational(3, 4)

- obj = mock("Object")

- obj.should_receive(:coerce).with(rational).and_return([1, 2])

-

- rational.send(@method, obj)

- end

-

- it "calls #/ on the coerced Rational with the coerced Object" do

- rational = Rational(3, 4)

-

- coerced_rational = mock("Coerced Rational")

- coerced_rational.should_receive(:/).and_return(:result)

-

- coerced_obj = mock("Coerced Object")

-

- obj = mock("Object")

- obj.should_receive(:coerce).and_return([coerced_rational, coerced_obj])

-

- rational.send(@method, obj).should == :result

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_divmod_rat, shared: true do

- it "returns the quotient as Integer and the remainder as Rational" do

- Rational(7, 4).divmod(Rational(1, 2)).should eql([3, Rational(1, 4)])

- Rational(7, 4).divmod(Rational(-1, 2)).should eql([-4, Rational(-1, 4)])

- Rational(0, 4).divmod(Rational(4, 3)).should eql([0, Rational(0, 1)])

-

- Rational(bignum_value, 4).divmod(Rational(4, 3)).should eql([3458764513820540928, Rational(0, 1)])

- end

-

- it "raises a ZeroDivisionError when passed a Rational with a numerator of 0" do

- -> { Rational(7, 4).divmod(Rational(0, 3)) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_divmod_int, shared: true do

- it "returns the quotient as Integer and the remainder as Rational" do

- Rational(7, 4).divmod(2).should eql([0, Rational(7, 4)])

- Rational(7, 4).divmod(-2).should eql([-1, Rational(-1, 4)])

-

- Rational(bignum_value, 4).divmod(3).should eql([1537228672809129301, Rational(1, 1)])

- end

-

- it "raises a ZeroDivisionError when passed 0" do

- -> { Rational(7, 4).divmod(0) }.should raise_error(ZeroDivisionError)

- end

-end

-

-describe :rational_divmod_float, shared: true do

- it "returns the quotient as Integer and the remainder as Float" do

- Rational(7, 4).divmod(0.5).should eql([3, 0.25])

- end

-

- it "returns the quotient as Integer and the remainder as Float" do

- Rational(7, 4).divmod(-0.5).should eql([-4, -0.25])

- end

-

- it "raises a ZeroDivisionError when passed 0" do

- -> { Rational(7, 4).divmod(0.0) }.should raise_error(ZeroDivisionError)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_equal_value_rat, shared: true do

- it "returns true if self has the same numerator and denominator as the passed argument" do

- (Rational(3, 4) == Rational(3, 4)).should be_true

- (Rational(-3, -4) == Rational(3, 4)).should be_true

- (Rational(-4, 5) == Rational(4, -5)).should be_true

-

- (Rational(bignum_value, 3) == Rational(bignum_value, 3)).should be_true

- (Rational(-bignum_value, 3) == Rational(bignum_value, -3)).should be_true

- end

-end

-

-describe :rational_equal_value_int, shared: true do

- it "returns true if self has the passed argument as numerator and a denominator of 1" do

- # Rational(x, y) reduces x and y automatically

- (Rational(4, 2) == 2).should be_true

- (Rational(-4, 2) == -2).should be_true

- (Rational(4, -2) == -2).should be_true

- end

-end

-

-describe :rational_equal_value_float, shared: true do

- it "converts self to a Float and compares it with the passed argument" do

- (Rational(3, 4) == 0.75).should be_true

- (Rational(4, 2) == 2.0).should be_true

- (Rational(-4, 2) == -2.0).should be_true

- (Rational(4, -2) == -2.0).should be_true

- end

-end

-

-describe :rational_equal_value, shared: true do

- it "returns the result of calling #== with self on the passed argument" do

- obj = mock("Object")

- obj.should_receive(:==).and_return(:result)

-

- (Rational(3, 4) == obj).should_not be_false

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_exponent, shared: true do

- describe "when passed Rational" do

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- it "returns Rational(1) if the exponent is Rational(0)" do

- (Rational(0) ** Rational(0)).should eql(Rational(1))

- (Rational(1) ** Rational(0)).should eql(Rational(1))

- (Rational(3, 4) ** Rational(0)).should eql(Rational(1))

- (Rational(-1) ** Rational(0)).should eql(Rational(1))

- (Rational(-3, 4) ** Rational(0)).should eql(Rational(1))

- (Rational(bignum_value) ** Rational(0)).should eql(Rational(1))

- (Rational(-bignum_value) ** Rational(0)).should eql(Rational(1))

- end

-

- it "returns self raised to the argument as a Rational if the exponent's denominator is 1" do

- (Rational(3, 4) ** Rational(1, 1)).should eql(Rational(3, 4))

- (Rational(3, 4) ** Rational(2, 1)).should eql(Rational(9, 16))

- (Rational(3, 4) ** Rational(-1, 1)).should eql(Rational(4, 3))

- (Rational(3, 4) ** Rational(-2, 1)).should eql(Rational(16, 9))

- end

-

- it "returns self raised to the argument as a Float if the exponent's denominator is not 1" do

- (Rational(3, 4) ** Rational(4, 3)).should be_close(0.681420222312052, TOLERANCE)

- (Rational(3, 4) ** Rational(-4, 3)).should be_close(1.46752322173095, TOLERANCE)

- (Rational(3, 4) ** Rational(4, -3)).should be_close(1.46752322173095, TOLERANCE)

- end

-

- it "returns a complex number when self is negative and the passed argument is not 0" do

- (Rational(-3, 4) ** Rational(-4, 3)).should be_close(Complex(-0.7337616108654732, 1.2709123906625817), TOLERANCE)

- end

- end

- end

-

- describe "when passed Integer" do

- it "returns the Rational value of self raised to the passed argument" do

- (Rational(3, 4) ** 4).should == Rational(81, 256)

- (Rational(3, 4) ** -4).should == Rational(256, 81)

- (Rational(-3, 4) ** -4).should == Rational(256, 81)

- (Rational(3, -4) ** -4).should == Rational(256, 81)

-

- (Rational(bignum_value, 4) ** 4).should == Rational(452312848583266388373324160190187140051835877600158453279131187530910662656, 1)

- (Rational(3, bignum_value) ** -4).should == Rational(115792089237316195423570985008687907853269984665640564039457584007913129639936, 81)

- (Rational(-bignum_value, 4) ** -4).should == Rational(1, 452312848583266388373324160190187140051835877600158453279131187530910662656)

- (Rational(3, -bignum_value) ** -4).should == Rational(115792089237316195423570985008687907853269984665640564039457584007913129639936, 81)

- end

-

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- it "returns Rational(1, 1) when the passed argument is 0" do

- (Rational(3, 4) ** 0).should eql(Rational(1, 1))

- (Rational(-3, 4) ** 0).should eql(Rational(1, 1))

- (Rational(3, -4) ** 0).should eql(Rational(1, 1))

-

- (Rational(bignum_value, 4) ** 0).should eql(Rational(1, 1))

- (Rational(3, -bignum_value) ** 0).should eql(Rational(1, 1))

- end

- end

- end

-

- describe "when passed Bignum" do

- # #5713

- it "returns Rational(0) when self is Rational(0) and the exponent is positive" do

- (Rational(0) ** bignum_value).should eql(Rational(0))

- end

-

- it "raises ZeroDivisionError when self is Rational(0) and the exponent is negative" do

- -> { Rational(0) ** -bignum_value }.should raise_error(ZeroDivisionError)

- end

-

- it "returns Rational(1) when self is Rational(1)" do

- (Rational(1) ** bignum_value).should eql(Rational(1))

- (Rational(1) ** -bignum_value).should eql(Rational(1))

- end

-

- it "returns Rational(1) when self is Rational(-1) and the exponent is positive and even" do

- (Rational(-1) ** bignum_value(0)).should eql(Rational(1))

- (Rational(-1) ** bignum_value(2)).should eql(Rational(1))

- end

-

- it "returns Rational(-1) when self is Rational(-1) and the exponent is positive and odd" do

- (Rational(-1) ** bignum_value(1)).should eql(Rational(-1))

- (Rational(-1) ** bignum_value(3)).should eql(Rational(-1))

- end

-

- ruby_version_is ""..."3.4" do

- it "returns positive Infinity when self is > 1" do

- -> {

- (Rational(2) ** bignum_value).infinite?.should == 1

- }.should complain(/warning: in a\*\*b, b may be too big/)

- -> {

- (Rational(fixnum_max) ** bignum_value).infinite?.should == 1

- }.should complain(/warning: in a\*\*b, b may be too big/)

- end

-

- it "returns 0.0 when self is > 1 and the exponent is negative" do

- -> {

- (Rational(2) ** -bignum_value).should eql(0.0)

- }.should complain(/warning: in a\*\*b, b may be too big/)

- -> {

- (Rational(fixnum_max) ** -bignum_value).should eql(0.0)

- }.should complain(/warning: in a\*\*b, b may be too big/)

- end

- end

-

- ruby_version_is "3.4" do

- it "raises an ArgumentError when self is > 1" do

- -> {

- (Rational(2) ** bignum_value)

- }.should raise_error(ArgumentError)

- -> {

- (Rational(fixnum_max) ** bignum_value)

- }.should raise_error(ArgumentError)

- end

-

- it "raises an ArgumentError when self is > 1 and the exponent is negative" do

- -> {

- (Rational(2) ** -bignum_value)

- }.should raise_error(ArgumentError)

- -> {

- (Rational(fixnum_max) ** -bignum_value)

- }.should raise_error(ArgumentError)

- end

- end

-

- # Fails on linux due to pow() bugs in glibc: http://sources.redhat.com/bugzilla/show_bug.cgi?id=3866

- platform_is_not :linux do

- ruby_version_is ""..."3.4" do

- it "returns positive Infinity when self < -1" do

- -> {

- (Rational(-2) ** bignum_value).infinite?.should == 1

- }.should complain(/warning: in a\*\*b, b may be too big/)

- -> {

- (Rational(-2) ** (bignum_value + 1)).infinite?.should == 1

- }.should complain(/warning: in a\*\*b, b may be too big/)

- -> {

- (Rational(fixnum_min) ** bignum_value).infinite?.should == 1

- }.should complain(/warning: in a\*\*b, b may be too big/)

- end

-

- it "returns 0.0 when self is < -1 and the exponent is negative" do

- -> {

- (Rational(-2) ** -bignum_value).should eql(0.0)

- }.should complain(/warning: in a\*\*b, b may be too big/)

- -> {

- (Rational(fixnum_min) ** -bignum_value).should eql(0.0)

- }.should complain(/warning: in a\*\*b, b may be too big/)

- end

- end

-

- ruby_version_is "3.4" do

- it "returns positive Infinity when self < -1" do

- -> {

- (Rational(-2) ** bignum_value)

- }.should raise_error(ArgumentError)

- -> {

- (Rational(fixnum_min) ** bignum_value)

- }.should raise_error(ArgumentError)

- end

-

- it "returns 0.0 when self is < -1 and the exponent is negative" do

- -> {

- (Rational(-2) ** -bignum_value)

- }.should raise_error(ArgumentError)

- -> {

- (Rational(fixnum_min) ** -bignum_value)

- }.should raise_error(ArgumentError)

- end

- end

- end

- end

-

- describe "when passed Float" do

- it "returns self converted to Float and raised to the passed argument" do

- (Rational(3, 1) ** 3.0).should eql(27.0)

- (Rational(3, 1) ** 1.5).should be_close(5.19615242270663, TOLERANCE)

- (Rational(3, 1) ** -1.5).should be_close(0.192450089729875, TOLERANCE)

- end

-

- it "returns a complex number if self is negative and the passed argument is not 0" do

- (Rational(-3, 2) ** 1.5).should be_close(Complex(0.0, -1.8371173070873836), TOLERANCE)

- (Rational(3, -2) ** 1.5).should be_close(Complex(0.0, -1.8371173070873836), TOLERANCE)

- (Rational(3, -2) ** -1.5).should be_close(Complex(0.0, 0.5443310539518174), TOLERANCE)

- end

-

- it "returns Complex(1.0) when the passed argument is 0.0" do

- (Rational(3, 4) ** 0.0).should == Complex(1.0)

- (Rational(-3, 4) ** 0.0).should == Complex(1.0)

- (Rational(-3, 4) ** 0.0).should == Complex(1.0)

- end

- end

-

- it "calls #coerce on the passed argument with self" do

- rational = Rational(3, 4)

- obj = mock("Object")

- obj.should_receive(:coerce).with(rational).and_return([1, 2])

-

- rational ** obj

- end

-

- it "calls #** on the coerced Rational with the coerced Object" do

- rational = Rational(3, 4)

-

- coerced_rational = mock("Coerced Rational")

- coerced_rational.should_receive(:**).and_return(:result)

-

- coerced_obj = mock("Coerced Object")

-

- obj = mock("Object")

- obj.should_receive(:coerce).and_return([coerced_rational, coerced_obj])

-

- (rational ** obj).should == :result

- end

-

- it "raises ZeroDivisionError for Rational(0, 1) passed a negative Integer" do

- [-1, -4, -9999].each do |exponent|

- -> { Rational(0, 1) ** exponent }.should raise_error(ZeroDivisionError, "divided by 0")

- end

- end

-

- it "raises ZeroDivisionError for Rational(0, 1) passed a negative Rational with denominator 1" do

- [Rational(-1, 1), Rational(-3, 1)].each do |exponent|

- -> { Rational(0, 1) ** exponent }.should raise_error(ZeroDivisionError, "divided by 0")

- end

- end

-

- # #7513

- it "raises ZeroDivisionError for Rational(0, 1) passed a negative Rational" do

- -> { Rational(0, 1) ** Rational(-3, 2) }.should raise_error(ZeroDivisionError, "divided by 0")

- end

-

- platform_is_not :solaris do # See https://github.com/ruby/spec/issues/134

- it "returns Infinity for Rational(0, 1) passed a negative Float" do

- [-1.0, -3.0, -3.14].each do |exponent|

- (Rational(0, 1) ** exponent).infinite?.should == 1

- end

- end

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_fdiv, shared: true do

- it "needs to be reviewed for spec completeness"

-end

-require_relative '../../spec_helper'

-

-describe :rational_floor, shared: true do

- before do

- @rational = Rational(2200, 7)

- end

-

- describe "with no arguments (precision = 0)" do

- it "returns an integer" do

- @rational.floor.should be_kind_of(Integer)

- end

-

- it "returns the truncated value toward negative infinity" do

- @rational.floor.should == 314

- Rational(1, 2).floor.should == 0

- Rational(-1, 2).floor.should == -1

- end

- end

-

- describe "with a precision < 0" do

- it "returns an integer" do

- @rational.floor(-2).should be_kind_of(Integer)

- @rational.floor(-1).should be_kind_of(Integer)

- end

-

- it "moves the truncation point n decimal places left" do

- @rational.floor(-3).should == 0

- @rational.floor(-2).should == 300

- @rational.floor(-1).should == 310

- end

- end

-

- describe "with a precision > 0" do

- it "returns a Rational" do

- @rational.floor(1).should be_kind_of(Rational)

- @rational.floor(2).should be_kind_of(Rational)

- end

-

- it "moves the truncation point n decimal places right" do

- @rational.floor(1).should == Rational(1571, 5)

- @rational.floor(2).should == Rational(7857, 25)

- @rational.floor(3).should == Rational(62857, 200)

- end

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_hash, shared: true do

- # BUG: Rational(2, 3).hash == Rational(3, 2).hash

- it "is static" do

- Rational(2, 3).hash.should == Rational(2, 3).hash

- Rational(2, 4).hash.should_not == Rational(2, 3).hash

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_inspect, shared: true do

- it "returns a string representation of self" do

- Rational(3, 4).inspect.should == "(3/4)"

- Rational(-5, 8).inspect.should == "(-5/8)"

- Rational(-1, -2).inspect.should == "(1/2)"

-

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- Rational(bignum_value, 1).inspect.should == "(#{bignum_value}/1)"

- end

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_modulo, shared: true do

- it "returns the remainder when this value is divided by other" do

- Rational(2, 3).send(@method, Rational(2, 3)).should == Rational(0, 1)

- Rational(4, 3).send(@method, Rational(2, 3)).should == Rational(0, 1)

- Rational(2, -3).send(@method, Rational(-2, 3)).should == Rational(0, 1)

- Rational(0, -1).send(@method, -1).should == Rational(0, 1)

-

- Rational(7, 4).send(@method, Rational(1, 2)).should == Rational(1, 4)

- Rational(7, 4).send(@method, 1).should == Rational(3, 4)

- Rational(7, 4).send(@method, Rational(1, 7)).should == Rational(1, 28)

-

- Rational(3, 4).send(@method, -1).should == Rational(-1, 4)

- Rational(1, -5).send(@method, -1).should == Rational(-1, 5)

- end

-

- it "returns a Float value when the argument is Float" do

- Rational(7, 4).send(@method, 1.0).should be_kind_of(Float)

- Rational(7, 4).send(@method, 1.0).should == 0.75

- Rational(7, 4).send(@method, 0.26).should be_close(0.19, 0.0001)

- end

-

- it "raises ZeroDivisionError on zero denominator" do

- -> {

- Rational(3, 5).send(@method, Rational(0, 1))

- }.should raise_error(ZeroDivisionError)

-

- -> {

- Rational(0, 1).send(@method, Rational(0, 1))

- }.should raise_error(ZeroDivisionError)

-

- -> {

- Rational(3, 5).send(@method, 0)

- }.should raise_error(ZeroDivisionError)

- end

-

- it "raises a ZeroDivisionError when the argument is 0.0" do

- -> {

- Rational(3, 5).send(@method, 0.0)

- }.should raise_error(ZeroDivisionError)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_multiply_rat, shared: true do

- it "returns self divided by other as a Rational" do

- (Rational(3, 4) * Rational(3, 4)).should eql(Rational(9, 16))

- (Rational(2, 4) * Rational(1, 4)).should eql(Rational(1, 8))

-

- (Rational(3, 4) * Rational(0, 1)).should eql(Rational(0, 4))

- end

-end

-

-describe :rational_multiply_int, shared: true do

- it "returns self divided by other as a Rational" do

- (Rational(3, 4) * 2).should eql(Rational(3, 2))

- (Rational(2, 4) * 2).should eql(Rational(1, 1))

- (Rational(6, 7) * -2).should eql(Rational(-12, 7))

-

- (Rational(3, 4) * 0).should eql(Rational(0, 4))

- end

-end

-

-describe :rational_multiply_float, shared: true do

- it "returns self divided by other as a Float" do

- (Rational(3, 4) * 0.75).should eql(0.5625)

- (Rational(3, 4) * 0.25).should eql(0.1875)

- (Rational(3, 4) * 0.3).should be_close(0.225, TOLERANCE)

-

- (Rational(-3, 4) * 0.3).should be_close(-0.225, TOLERANCE)

- (Rational(3, -4) * 0.3).should be_close(-0.225, TOLERANCE)

- (Rational(3, 4) * -0.3).should be_close(-0.225, TOLERANCE)

-

- (Rational(3, 4) * 0.0).should eql(0.0)

- (Rational(-3, -4) * 0.0).should eql(0.0)

-

- (Rational(-3, 4) * 0.0).should eql(0.0)

- (Rational(3, -4) * 0.0).should eql(0.0)

- end

-end

-

-describe :rational_multiply, shared: true do

- it "calls #coerce on the passed argument with self" do

- rational = Rational(3, 4)

- obj = mock("Object")

- obj.should_receive(:coerce).with(rational).and_return([1, 2])

-

- rational * obj

- end

-

- it "calls #* on the coerced Rational with the coerced Object" do

- rational = Rational(3, 4)

-

- coerced_rational = mock("Coerced Rational")

- coerced_rational.should_receive(:*).and_return(:result)

-

- coerced_obj = mock("Coerced Object")

-

- obj = mock("Object")

- obj.should_receive(:coerce).and_return([coerced_rational, coerced_obj])

-

- (rational * obj).should == :result

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_numerator, shared: true do

- it "returns the numerator" do

- Rational(3, 4).numerator.should equal(3)

- Rational(3, -4).numerator.should equal(-3)

-

- Rational(bignum_value, 1).numerator.should == bignum_value

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_plus_rat, shared: true do

- it "returns the result of subtracting other from self as a Rational" do

- (Rational(3, 4) + Rational(0, 1)).should eql(Rational(3, 4))

- (Rational(3, 4) + Rational(1, 4)).should eql(Rational(1, 1))

-

- (Rational(3, 4) + Rational(2, 1)).should eql(Rational(11, 4))

- end

-end

-

-describe :rational_plus_int, shared: true do

- it "returns the result of subtracting other from self as a Rational" do

- (Rational(3, 4) + 1).should eql(Rational(7, 4))

- (Rational(3, 4) + 2).should eql(Rational(11, 4))

- end

-end

-

-describe :rational_plus_float, shared: true do

- it "returns the result of subtracting other from self as a Float" do

- (Rational(3, 4) + 0.2).should eql(0.95)

- (Rational(3, 4) + 2.5).should eql(3.25)

- end

-end

-

-describe :rational_plus, shared: true do

- it "calls #coerce on the passed argument with self" do

- rational = Rational(3, 4)

- obj = mock("Object")

- obj.should_receive(:coerce).with(rational).and_return([1, 2])

-

- rational + obj

- end

-

- it "calls #+ on the coerced Rational with the coerced Object" do

- rational = Rational(3, 4)

-

- coerced_rational = mock("Coerced Rational")

- coerced_rational.should_receive(:+).and_return(:result)

-

- coerced_obj = mock("Coerced Object")

-

- obj = mock("Object")

- obj.should_receive(:coerce).and_return([coerced_rational, coerced_obj])

-

- (rational + obj).should == :result

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_remainder, shared: true do

- it "needs to be reviewed for spec completeness"

-end

-require_relative '../../spec_helper'

-

-describe :rational_round, shared: true do

- before do

- @rational = Rational(2200, 7)

- end

-

- describe "with no arguments (precision = 0)" do

- it "returns an integer" do

- @rational.round.should be_kind_of(Integer)

- Rational(0, 1).round(0).should be_kind_of(Integer)

- Rational(124, 1).round(0).should be_kind_of(Integer)

- end

-

- it "returns the truncated value toward the nearest integer" do

- @rational.round.should == 314

- Rational(0, 1).round(0).should == 0

- Rational(2, 1).round(0).should == 2

- end

-

- it "returns the rounded value toward the nearest integer" do

- Rational(1, 2).round.should == 1

- Rational(-1, 2).round.should == -1

- Rational(3, 2).round.should == 2

- Rational(-3, 2).round.should == -2

- Rational(5, 2).round.should == 3

- Rational(-5, 2).round.should == -3

- end

- end

-

- describe "with a precision < 0" do

- it "returns an integer" do

- @rational.round(-2).should be_kind_of(Integer)

- @rational.round(-1).should be_kind_of(Integer)

- Rational(0, 1).round(-1).should be_kind_of(Integer)

- Rational(2, 1).round(-1).should be_kind_of(Integer)

- end

-

- it "moves the truncation point n decimal places left" do

- @rational.round(-3).should == 0

- @rational.round(-2).should == 300

- @rational.round(-1).should == 310

- end

- end

-

- describe "with a precision > 0" do

- it "returns a Rational" do

- @rational.round(1).should be_kind_of(Rational)

- @rational.round(2).should be_kind_of(Rational)

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- Rational(0, 1).round(1).should be_kind_of(Rational)

- Rational(2, 1).round(1).should be_kind_of(Rational)

- end

- end

-

- it "moves the truncation point n decimal places right" do

- @rational.round(1).should == Rational(3143, 10)

- @rational.round(2).should == Rational(31429, 100)

- @rational.round(3).should == Rational(157143, 500)

- Rational(0, 1).round(1).should == Rational(0, 1)

- Rational(2, 1).round(1).should == Rational(2, 1)

- end

-

- it "doesn't alter the value if the precision is too great" do

- Rational(3, 2).round(10).should == Rational(3, 2).round(20)

- end

-

- # #6605

- it "doesn't fail when rounding to an absurdly large positive precision" do

- Rational(3, 2).round(2_097_171).should == Rational(3, 2)

- end

- end

-

- describe "with half option" do

- it "returns an Integer when precision is not passed" do

- Rational(10, 4).round(half: nil).should == 3

- Rational(10, 4).round(half: :up).should == 3

- Rational(10, 4).round(half: :down).should == 2

- Rational(10, 4).round(half: :even).should == 2

- Rational(-10, 4).round(half: nil).should == -3

- Rational(-10, 4).round(half: :up).should == -3

- Rational(-10, 4).round(half: :down).should == -2

- Rational(-10, 4).round(half: :even).should == -2

- end

-

- it "returns a Rational when the precision is greater than 0" do

- Rational(25, 100).round(1, half: nil).should == Rational(3, 10)

- Rational(25, 100).round(1, half: :up).should == Rational(3, 10)

- Rational(25, 100).round(1, half: :down).should == Rational(1, 5)

- Rational(25, 100).round(1, half: :even).should == Rational(1, 5)

- Rational(35, 100).round(1, half: nil).should == Rational(2, 5)

- Rational(35, 100).round(1, half: :up).should == Rational(2, 5)

- Rational(35, 100).round(1, half: :down).should == Rational(3, 10)

- Rational(35, 100).round(1, half: :even).should == Rational(2, 5)

- Rational(-25, 100).round(1, half: nil).should == Rational(-3, 10)

- Rational(-25, 100).round(1, half: :up).should == Rational(-3, 10)

- Rational(-25, 100).round(1, half: :down).should == Rational(-1, 5)

- Rational(-25, 100).round(1, half: :even).should == Rational(-1, 5)

- end

-

- it "raise for a non-existent round mode" do

- -> { Rational(10, 4).round(half: :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode: nonsense")

- end

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_to_f, shared: true do

- it "returns self converted to a Float" do

- Rational(3, 4).to_f.should eql(0.75)

- Rational(3, -4).to_f.should eql(-0.75)

- Rational(-1, 4).to_f.should eql(-0.25)

- Rational(-1, -4).to_f.should eql(0.25)

- end

-

- it "converts to a Float for large numerator and denominator" do

- num = 1000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146009

- den = 2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

- Rational(num, den).to_f.should == 500.0

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_to_i, shared: true do

- it "converts self to an Integer by truncation" do

- Rational(7, 4).to_i.should eql(1)

- Rational(11, 4).to_i.should eql(2)

- end

-

- it "converts self to an Integer by truncation" do

- Rational(-7, 4).to_i.should eql(-1)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_to_r, shared: true do

- it "returns self" do

- a = Rational(3, 4)

- a.to_r.should equal(a)

-

- a = Rational(bignum_value, 4)

- a.to_r.should equal(a)

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_to_s, shared: true do

- it "returns a string representation of self" do

- # Guard against the Mathn library

- guard -> { !defined?(Math.rsqrt) } do

- Rational(1, 1).to_s.should == "1/1"

- Rational(2, 1).to_s.should == "2/1"

- end

- Rational(1, 2).to_s.should == "1/2"

- Rational(-1, 3).to_s.should == "-1/3"

- Rational(1, -3).to_s.should == "-1/3"

- end

-end

-require_relative '../../spec_helper'

-

-describe :rational_truncate, shared: true do

- before do

- @rational = Rational(2200, 7)

- end

-

- describe "with no arguments (precision = 0)" do

- it "returns an integer" do

- @rational.truncate.should be_kind_of(Integer)

- end

-

- it "returns the truncated value toward 0" do

- @rational.truncate.should == 314

- Rational(1, 2).truncate.should == 0

- Rational(-1, 2).truncate.should == 0

- end

- end

-

- describe "with an explicit precision = 0" do

- it "returns an integer" do

- @rational.truncate(0).should be_kind_of(Integer)

- end

-

- it "returns the truncated value toward 0" do

- @rational.truncate(0).should == 314

- Rational(1, 2).truncate(0).should == 0

- Rational(-1, 2).truncate(0).should == 0

- end

- end

-

- describe "with a precision < 0" do

- it "returns an integer" do

- @rational.truncate(-2).should be_kind_of(Integer)

- @rational.truncate(-1).should be_kind_of(Integer)

- end

-

- it "moves the truncation point n decimal places left" do

- @rational.truncate(-3).should == 0

- @rational.truncate(-2).should == 300

- @rational.truncate(-1).should == 310

- end

- end

-

- describe "with a precision > 0" do

- it "returns a Rational" do

- @rational.truncate(1).should be_kind_of(Rational)

- @rational.truncate(2).should be_kind_of(Rational)

- end

-

- it "moves the truncation point n decimal places right" do

- @rational.truncate(1).should == Rational(1571, 5)

- @rational.truncate(2).should == Rational(7857, 25)

- @rational.truncate(3).should == Rational(62857, 200)

- end

- end

-

- describe "with an invalid value for precision" do

- it "raises a TypeError" do

- -> { @rational.truncate(nil) }.should raise_error(TypeError, "not an integer")

- -> { @rational.truncate(1.0) }.should raise_error(TypeError, "not an integer")

- -> { @rational.truncate('') }.should raise_error(TypeError, "not an integer")

- end

-

- it "does not call to_int on the argument" do

- object = Object.new

- object.should_not_receive(:to_int)

- -> { @rational.truncate(object) }.should raise_error(TypeError, "not an integer")

- end

- end

-end