# Vector conversion mixed rational integers

Yes, I am quite familiar with mathematical questions. But naively I thought that in julia it was done differently and I tried to do something like you suggest.
But I tried with a monster like `Vector {Union {Rational, Int}}[ ]` that julia didn’t digest Fyi, there is this past post from the boss that might still be valid.

1 Like

You were near!

``````@show Union{Real,Int}[0, 1//2, 1, 3//2, 4//2]
@show Union{Rational,Int}[0, 1//2, 1, 3//2, 4//2]
``````

yields

``````Union{Real, Int}[0, 1 // 2, 1, 3 // 2, 4 // 2] = Real[0, 1//2, 1, 3//2, 2//1]
Union{Rational, Int}[0, 1 // 2, 1, 3 // 2, 4 // 2] = Union{Int64, Rational}[0, 1//2, 1, 3//2, 2//1]
``````
1 Like

That is a very good point from Stefan. But, yet, I kinda expected an `AbstractRational` which `Integer` inherits, but the concrete `Rational` only is defined after `Int` is defined. The conventionally identified with this subset, they are not the same as this subset still holds however.

To stay at the problem Y, why ther are two differente types of rational?

``````julia> Rational{Int}===Rational
false
``````

What is the meaning of the first type (Rational {Int})?

``````
siwp(n,d)=if isinteger(n//d) string(Int(n/d)) else string(n,"/",d) end
``````

Instead of converting floats, it is better to use proper integer division: `div(n, d)` or `n÷d`.

3 Likes

Some reasonably different types of rational

``````julia> Rational !- Rational{Int}, Rational{Int} != Rational{BigInt}
(true, true)

julia> typeof(Rational(1, 2)), typeof(Rational(big"1", big"2"))
(Rational{Int64}, Rational{BigInt})

julia> sizeof(Rational(1, 2)), sizeof(Rational(Int16(1), Int16(2)))
(16, 4)

julia> typeof(Rational), Rational.body
UnionAll, Rational{T<:Integer}
``````
1 Like

This is the definition of `Rational`:

``````"""
Rational{T<:Integer} <: Real

Rational number type, with numerator and denominator of type `T`.
Rationals are checked for overflow.
"""
struct Rational{T<:Integer} <: Real
num::T
den::T

# Unexported inner constructor of Rational that bypasses all checks
global unsafe_rational(::Type{T}, num, den) where {T} = new{T}(num, den)
end
``````

So, `Rational{Int}` stores the numerator and denominator as `Int`, while `Rational{BigInt}` (for example) uses `BigInt` (and it is therefore an “infinite” precision rational).

1 Like

I think the whole tread is related to the issue of the default printing of Rationals which is not I think the best possible. I proposed display of `Rational`s in containers · Issue #42626 · JuliaLang/julia · GitHub
which was rather well received but no action followed…

1 Like

out of curiosity I made these tests:

``````julia> 3//true
3//1

julia> false//5
0//1

julia> typeof(false//5)
Rational{Int64}
``````

The type of the numerator and the denominator needs to be the same. So it gets automatically converted to the largest between the two. You can, however, do:

``````julia> false // true
false//true

julia> typeof(false // true)
Rational{Bool}

``````

`true` and `false` are integer (sub)types and when mixed with `Int64` get converted to `Int64` and:

``````false//5 == 0//5 == 0//1     # Rational{Int64}
``````

If instead we mix Bool with `UInt8` integers we get:

``````false//UInt8(10)    #  Rational{UInt8}
``````
1 Like

Yup. I know.
For this reason I was certain when I tested that the input would be accepted.

what can be done with rationals {boolean} is another matter entirely.