Skip to content

Implement Base.parse for Rational #44550

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 10 commits into from
Jun 17, 2022
Merged

Implement Base.parse for Rational #44550

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
5b1c044
Implement `Base.parse` for Rational
henriquebecker91 Mar 10, 2022
e2c2758
Rational parse restricted to '/', '//', or no den.
henriquebecker91 Mar 10, 2022
98a4c8f
Apply adequate suggestions from code review.
henriquebecker91 Mar 11, 2022
4e7d2fa
Simplify `parse(Rational{T}, ...)`
henriquebecker91 Mar 11, 2022
4a1fd78
Use `@inbounds` in `Base.parse(Rational{T}, ...)`
henriquebecker91 Mar 11, 2022
aed1e71
Add tests for parse(Rational{T}, s).
henriquebecker91 Mar 11, 2022
1a20a15
Reduced/improved parse rational tests. Removed whitespace.
henriquebecker91 Mar 16, 2022
64b72c2
Apply @Liozou suggestions to the rational parse tests
henriquebecker91 Mar 17, 2022
2864c88
Removed all unnecessary calls to Int constructor.
henriquebecker91 Mar 17, 2022
a2f3358
Merge branch 'master' into patch-5
oscardssmith Jun 17, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 14 additions & 0 deletions base/rational.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -95,6 +95,20 @@ end
function write(s::IO, z::Rational)
write(s,numerator(z),denominator(z))
end
function parse(::Type{Rational{T}}, s::AbstractString) where T<:Integer
ss = split(s, '/'; limit = 2)
if isone(length(ss))
return Rational{T}(parse(T, s))
end
@inbounds ns, ds = ss[1], ss[2]
if startswith(ds, '/')
ds = chop(ds; head = 1, tail = 0)
end
n = parse(T, ns)
d = parse(T, ds)
return n//d
end


function Rational{T}(x::Rational) where T<:Integer
unsafe_rational(T, convert(T, x.num), convert(T, x.den))
Expand Down
82 changes: 82 additions & 0 deletions test/rational.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -265,6 +265,88 @@ end
@test read(io2, typeof(rational2)) == rational2
end
end
@testset "parse" begin
# Non-negative Int in which parsing is expected to work
@test parse(Rational{Int}, string(10)) == 10 // 1
@test parse(Rational{Int}, "100/10" ) == 10 // 1
@test parse(Rational{Int}, "100 / 10") == 10 // 1
@test parse(Rational{Int}, "0 / 10") == 0 // 1
@test parse(Rational{Int}, "100//10" ) == 10 // 1
@test parse(Rational{Int}, "100 // 10") == 10 // 1
@test parse(Rational{Int}, "0 // 10") == 0 // 1

# Variations of the separator that should throw errors
@test_throws ArgumentError parse(Rational{Int}, "100\\10" )
@test_throws ArgumentError parse(Rational{Int}, "100 \\ 10")
@test_throws ArgumentError parse(Rational{Int}, "100\\\\10" )
@test_throws ArgumentError parse(Rational{Int}, "100 \\\\ 10")
@test_throws ArgumentError parse(Rational{Int}, "100/ /10" )
@test_throws ArgumentError parse(Rational{Int}, "100 / / 10")
@test_throws ArgumentError parse(Rational{Int}, "100// /10" )
@test_throws ArgumentError parse(Rational{Int}, "100 // / 10")
@test_throws ArgumentError parse(Rational{Int}, "100///10" )
@test_throws ArgumentError parse(Rational{Int}, "100 /// 10")
@test_throws ArgumentError parse(Rational{Int}, "100÷10" )
@test_throws ArgumentError parse(Rational{Int}, "100 ÷ 10")
@test_throws ArgumentError parse(Rational{Int}, "100 10" )
@test_throws ArgumentError parse(Rational{Int}, "100 10")

# Zero denominator, negative denominator, and double negative
@test_throws ArgumentError parse(Rational{Int}, "0//0")
@test parse(Rational{Int}, "1000//-100") == -10 // 1
@test parse(Rational{Int}, "-1000//-100") == 10 // 1

# Negative Int tests in which parsing is expected to work
@test parse(Rational{Int}, string(-10)) == -10 // 1
@test parse(Rational{Int}, "-100/10" ) == -10 // 1
@test parse(Rational{Int}, "-100 / 10") == -10 // 1
@test parse(Rational{Int}, "-100//10" ) == -10 // 1

# Variations of the separator that should throw errors (negative version)
@test_throws ArgumentError parse(Rational{Int}, "-100\\10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 \\ 10")
@test_throws ArgumentError parse(Rational{Int}, "-100\\\\10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 \\\\ 10")
@test_throws ArgumentError parse(Rational{Int}, "-100/ /10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 / / 10")
@test_throws ArgumentError parse(Rational{Int}, "-100// /10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 // / 10")
@test_throws ArgumentError parse(Rational{Int}, "-100///10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 /// 10")
@test_throws ArgumentError parse(Rational{Int}, "-100÷10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 ÷ 10")
@test_throws ArgumentError parse(Rational{Int}, "-100 10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 10")
@test_throws ArgumentError parse(Rational{Int}, "-100 -10" )
@test_throws ArgumentError parse(Rational{Int}, "-100 -10")
@test_throws ArgumentError parse(Rational{Int}, "100 -10" )
@test_throws ArgumentError parse(Rational{Int}, "100 -10")
try # issue 44570
parse(Rational{BigInt}, "100 10")
@test_broken false
catch
@test_broken true
end

# A few tests for other Integer types
@test parse(Rational{Bool}, "true") == true // true
@test parse(Rational{UInt8}, "0xff/0xf") == UInt8(17) // UInt8(1)
@test parse(Rational{Int8}, "-0x7e/0xf") == Int8(-126) // Int8(15)
@test parse(Rational{BigInt}, "$(big(typemax(Int))*16)/8") == (big(typemax(Int))*2) // big(1)
# Mixed notations
@test parse(Rational{UInt8}, "0x64//28") == UInt8(25) // UInt8(7)
@test parse(Rational{UInt8}, "100//0x1c") == UInt8(25) // UInt8(7)

# Out of the bounds tests
# 0x100 is 256, Int test works for both Int32 and Int64
# The error must be throw even if the canonicalized fraction fits
# (i.e., would be less than typemax after divided by 2 in examples below,
# both over typemax values are even).
@test_throws OverflowError parse(Rational{UInt8}, "0x100/0x1")
@test_throws OverflowError parse(Rational{UInt8}, "0x100/0x2")
@test_throws OverflowError parse(Rational{Int}, "$(big(typemax(Int)) + 1)/1")
@test_throws OverflowError parse(Rational{Int}, "$(big(typemax(Int)) + 1)/2")
end # parse

@testset "round" begin
@test round(11//2) == round(11//2, RoundNearest) == 6//1 # rounds to closest _even_ integer
Expand Down