Skip to content

Commit 1d5050b

Browse files
JeffBezansonJeffBezanson
committed
get numbers test passing with checked integer conversions and type-stable arithmetic
1 parent effff39 commit 1d5050b

File tree

7 files changed

+66
-83
lines changed

7 files changed

+66
-83
lines changed

‎base/char.jl

+4
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,10 @@ char(x::FloatingPoint) = char(iround(x))
33

44
integer(x::Char) = int(x)
55

6+
convert(::Type{Char}, x::Float16) = char(convert(Uint32, x))
7+
convert(::Type{Char}, x::Float32) = char(convert(Uint32, x))
8+
convert(::Type{Char}, x::Float64) = char(convert(Uint32, x))
9+
610
## char promotions ##
711

812
promote_rule(::Type{Char}, ::Type{Int8}) = Int32

‎base/float.jl

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
11
## conversions to floating-point ##
22

3-
convert(::Type{Float32}, x::Int128) = float32(uint128(abs(x)))*(1-2(x<0))
4-
convert(::Type{Float32}, x::Uint128) = float32(uint64(x)) + ldexp(float32(uint64(x>>>64)),64)
3+
convert(::Type{Float32}, x::Int128) = float32(reinterpret(Uint128,abs(x)))*(1-2(x<0))
4+
convert(::Type{Float32}, x::Uint128) = float32(uint64(x&0xffffffffffffffff)) + ldexp(float32(uint64(x>>>64)),64)
55
promote_rule(::Type{Float32}, ::Type{Int128} ) = Float32
66
promote_rule(::Type{Float32}, ::Type{Uint128}) = Float32
77

8-
convert(::Type{Float64}, x::Int128) = float64(uint128(abs(x)))*(1-2(x<0))
9-
convert(::Type{Float64}, x::Uint128) = float64(uint64(x)) + ldexp(float64(uint64(x>>>64)),64)
8+
convert(::Type{Float64}, x::Int128) = float64(reinterpret(Uint128,abs(x)))*(1-2(x<0))
9+
convert(::Type{Float64}, x::Uint128) = float64(uint64(x&0xffffffffffffffff)) + ldexp(float64(uint64(x>>>64)),64)
1010
promote_rule(::Type{Float64}, ::Type{Int128} ) = Float64
1111
promote_rule(::Type{Float64}, ::Type{Uint128}) = Float64
1212

13-
convert(::Type{Float16}, x::Union(Signed,Unsigned)) = convert(Float16, convert(Float32,x))
13+
convert(::Type{Float16}, x::Integer) = convert(Float16, convert(Float32,x))
1414
for t in (Bool,Char,Int8,Int16,Int32,Int64,Uint8,Uint16,Uint32,Uint64)
1515
@eval promote_rule(::Type{Float16}, ::Type{$t}) = Float32
1616
end

‎base/int.jl

+34-63
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,3 @@
1-
## type aliases ##
2-
3-
if Int === Int32
4-
typealias SmallSigned Union(Int8,Int16)
5-
typealias SmallUnsigned Union(Uint8,Uint16)
6-
else
7-
typealias SmallSigned Union(Int8,Int16,Int32)
8-
typealias SmallUnsigned Union(Uint8,Uint16,Uint32)
9-
end
10-
111
## integer arithmetic ##
122

133
const IntTypes = (Int8, Uint8, Int16, Uint16, Int32, Uint32,
@@ -34,11 +24,10 @@ iseven(n::Integer) = !isodd(n)
3424
signbit(x::Integer) = x < 0
3525
signbit(x::Unsigned) = false
3626

37-
flipsign(x::Int, y::Int) = box(Int,flipsign_int(unbox(Int,x),unbox(Int,y)))
38-
flipsign(x::Int64, y::Int64) = box(Int64,flipsign_int(unbox(Int64,x),unbox(Int64,y)))
39-
flipsign(x::Int128, y::Int128) = box(Int128,flipsign_int(unbox(Int128,x),unbox(Int128,y)))
27+
for T in (Int8,Int16,Int32,Int64,Int128)
28+
@eval flipsign(x::$T, y::$T) = box($T,flipsign_int(unbox($T,x),unbox($T,y)))
29+
end
4030

41-
flipsign{T<:Signed}(x::T,y::T) = flipsign(int(x),int(y))
4231
flipsign(x::Signed, y::Signed) = flipsign(promote(x,y)...)
4332
flipsign(x::Signed, y::Float32) = flipsign(x, reinterpret(Int32,y))
4433
flipsign(x::Signed, y::Float64) = flipsign(x, reinterpret(Int64,y))
@@ -100,9 +89,13 @@ for T in IntTypes
10089
($)(x::$T, y::$T) = box($T,xor_int(unbox($T,x),unbox($T,y)))
10190

10291
<<(x::$T, y::Int32) = box($T, shl_int(unbox($T,x),unbox(Int32,y)))
103-
>>(x::$T, y::Int32) = box($T,ashr_int(unbox($T,x),unbox(Int32,y)))
10492
>>>(x::$T, y::Int32) = box($T,lshr_int(unbox($T,x),unbox(Int32,y)))
10593
end
94+
if issubtype(T,Unsigned)
95+
@eval >>(x::$T, y::Int32) = box($T,lshr_int(unbox($T,x),unbox(Int32,y)))
96+
else
97+
@eval >>(x::$T, y::Int32) = box($T,ashr_int(unbox($T,x),unbox(Int32,y)))
98+
end
10699
end
107100

108101
bswap(x::Int8) = x
@@ -129,29 +122,15 @@ trailing_ones(x::Integer) = trailing_zeros(~x)
129122

130123
## integer comparisons ##
131124

132-
<(x::Int8, y::Int8) = slt_int(unbox(Int8,x),unbox(Int8,y))
133-
<(x::Int16, y::Int16) = slt_int(unbox(Int16,x),unbox(Int16,y))
134-
<(x::Int32, y::Int32) = slt_int(unbox(Int32,x),unbox(Int32,y))
135-
<(x::Int64, y::Int64) = slt_int(unbox(Int64,x),unbox(Int64,y))
136-
<(x::Int128, y::Int128) = slt_int(unbox(Int128,x),unbox(Int128,y))
137-
138-
<(x::Uint8, y::Uint8) = ult_int(unbox(Uint8,x),unbox(Uint8,y))
139-
<(x::Uint16, y::Uint16) = ult_int(unbox(Uint16,x),unbox(Uint16,y))
140-
<(x::Uint32, y::Uint32) = ult_int(unbox(Uint32,x),unbox(Uint32,y))
141-
<(x::Uint64, y::Uint64) = ult_int(unbox(Uint64,x),unbox(Uint64,y))
142-
<(x::Uint128, y::Uint128) = ult_int(unbox(Uint128,x),unbox(Uint128,y))
143-
144-
<=(x::Int8, y::Int8) = sle_int(unbox(Int8,x),unbox(Int8,y))
145-
<=(x::Int16, y::Int16) = sle_int(unbox(Int16,x),unbox(Int16,y))
146-
<=(x::Int32, y::Int32) = sle_int(unbox(Int32,x),unbox(Int32,y))
147-
<=(x::Int64, y::Int64) = sle_int(unbox(Int64,x),unbox(Int64,y))
148-
<=(x::Int128, y::Int128) = sle_int(unbox(Int128,x),unbox(Int128,y))
149-
150-
<=(x::Uint8, y::Uint8) = ule_int(unbox(Uint8,x),unbox(Uint8,y))
151-
<=(x::Uint16, y::Uint16) = ule_int(unbox(Uint16,x),unbox(Uint16,y))
152-
<=(x::Uint32, y::Uint32) = ule_int(unbox(Uint32,x),unbox(Uint32,y))
153-
<=(x::Uint64, y::Uint64) = ule_int(unbox(Uint64,x),unbox(Uint64,y))
154-
<=(x::Uint128, y::Uint128) = ule_int(unbox(Uint128,x),unbox(Uint128,y))
125+
for T in IntTypes
126+
if issubtype(T,Signed)
127+
@eval <( x::$T, y::$T) = slt_int(unbox($T,x),unbox($T,y))
128+
@eval <=(x::$T, y::$T) = sle_int(unbox($T,x),unbox($T,y))
129+
else
130+
@eval <( x::$T, y::$T) = ult_int(unbox($T,x),unbox($T,y))
131+
@eval <=(x::$T, y::$T) = ule_int(unbox($T,x),unbox($T,y))
132+
end
133+
end
155134

156135
==(x::Signed, y::Unsigned) = (x >= 0) & (unsigned(x) == y)
157136
==(x::Unsigned, y::Signed ) = (y >= 0) & (x == unsigned(y))
@@ -162,11 +141,8 @@ trailing_ones(x::Integer) = trailing_zeros(~x)
162141

163142
## integer conversions ##
164143

165-
const _inttypes = (Bool, Int8, Uint8, Int16, Uint16, Int32, Uint32, Char,
166-
Int64, Uint64, Int128, Uint128)
167-
168-
for to in _inttypes, from in _inttypes
169-
if !(to === from) && !(to === Bool)
144+
for to in tuple(IntTypes...,Char), from in tuple(IntTypes...,Char,Bool)
145+
if !(to === from)
170146
if to.size < from.size
171147
if issubtype(to, Signed)
172148
@eval convert(::Type{$to}, x::($from)) = box($to,checked_trunc_sint($to,unbox($from,x)))
@@ -218,21 +194,18 @@ function convert(::Type{Uint128}, x::FloatingPoint)
218194
end
219195
convert(::Type{Uint128}, x::Float32) = convert(Uint128, float64(x))
220196

221-
convert(::Type{Char}, x::Float32) = char(convert(Int, x))
222-
convert(::Type{Char}, x::Float64) = char(convert(Int, x))
223-
224-
convert(::Type{Signed}, x::Uint8 ) = convert(Int,x)
225-
convert(::Type{Signed}, x::Uint16 ) = convert(Int,x)
226-
convert(::Type{Signed}, x::Uint32 ) = convert(Int,x)
197+
convert(::Type{Signed}, x::Uint8 ) = convert(Int8,x)
198+
convert(::Type{Signed}, x::Uint16 ) = convert(Int16,x)
199+
convert(::Type{Signed}, x::Uint32 ) = convert(Int32,x)
227200
convert(::Type{Signed}, x::Uint64 ) = convert(Int64,x)
228201
convert(::Type{Signed}, x::Uint128) = convert(Int128,x)
229202
convert(::Type{Signed}, x::Float32) = convert(Int,x)
230203
convert(::Type{Signed}, x::Float64) = convert(Int,x)
231204
convert(::Type{Signed}, x::Char) = convert(Int,x)
232205

233-
convert(::Type{Unsigned}, x::Int8 ) = convert(Uint,x)
234-
convert(::Type{Unsigned}, x::Int16 ) = convert(Uint,x)
235-
convert(::Type{Unsigned}, x::Int32 ) = convert(Uint,x)
206+
convert(::Type{Unsigned}, x::Int8 ) = convert(Uint8,x)
207+
convert(::Type{Unsigned}, x::Int16 ) = convert(Uint16,x)
208+
convert(::Type{Unsigned}, x::Int32 ) = convert(Uint32,x)
236209
convert(::Type{Unsigned}, x::Int64 ) = convert(Uint64,x)
237210
convert(::Type{Unsigned}, x::Int128 ) = convert(Uint128,x)
238211
convert(::Type{Unsigned}, x::Float32) = convert(Uint,x)
@@ -372,12 +345,12 @@ typemax(::Type{Uint64}) = 0xffffffffffffffff
372345
typemax(::Type{Int128} ) = $(int128((uint128(-1))>>int32(1)))
373346
end
374347

375-
widen(::Type{Int8}) = Int
376-
widen(::Type{Int16}) = Int
348+
widen(::Type{Int8}) = Int16
349+
widen(::Type{Int16}) = Int32
377350
widen(::Type{Int32}) = Int64
378351
widen(::Type{Int64}) = Int128
379-
widen(::Type{Uint8}) = Uint
380-
widen(::Type{Uint16}) = Uint
352+
widen(::Type{Uint8}) = Uint16
353+
widen(::Type{Uint16}) = Uint32
381354
widen(::Type{Uint32}) = Uint64
382355
widen(::Type{Uint64}) = Uint128
383356

@@ -506,20 +479,18 @@ end
506479

507480
for T in (Int8,Uint8)
508481
@eval function checked_mul(x::$T, y::$T)
509-
xy = x*y
510-
xy8 = convert($T,xy)
511-
xy == xy8 || throw(OverflowError())
512-
return xy8
482+
xy = widemul(x,y)
483+
(typemin($T) <= xy <= typemax($T)) || throw(OverflowError())
484+
return itrunc($T,xy)
513485
end
514486
end
515487

516488
if WORD_SIZE == 32
517489
for T in (Int64,Uint64)
518490
@eval function checked_mul(x::$T, y::$T)
519491
xy = int128(x)*int128(y)
520-
xy64 = convert($T,xy)
521-
xy == xy64 || throw(OverflowError())
522-
return xy64
492+
(typemin($T) <= xy <= typemax($T)) || throw(OverflowError())
493+
return itrunc($T,xy)
523494
end
524495
end
525496
else

‎base/random.jl

+7-7
Original file line numberDiff line numberDiff line change
@@ -104,17 +104,17 @@ rand(r::MersenneTwister) = dsfmt_genrand_close_open(r.state)
104104
dsfmt_randui32() = dsfmt_gv_genrand_uint32()
105105
dsfmt_randui64() = uint64(dsfmt_randui32()) | (uint64(dsfmt_randui32())<<32)
106106

107-
rand(::Type{Uint8}) = uint8(rand(Uint32))
108-
rand(::Type{Uint16}) = uint16(rand(Uint32))
107+
rand(::Type{Uint8}) = itrunc(Uint8,rand(Uint32))
108+
rand(::Type{Uint16}) = itrunc(Uint16,rand(Uint32))
109109
rand(::Type{Uint32}) = dsfmt_randui32()
110110
rand(::Type{Uint64}) = dsfmt_randui64()
111111
rand(::Type{Uint128}) = uint128(rand(Uint64))<<64 | rand(Uint64)
112112

113-
rand(::Type{Int8}) = int8(rand(Uint8))
114-
rand(::Type{Int16}) = int16(rand(Uint16))
115-
rand(::Type{Int32}) = int32(rand(Uint32))
116-
rand(::Type{Int64}) = int64(rand(Uint64))
117-
rand(::Type{Int128}) = int128(rand(Uint128))
113+
rand(::Type{Int8}) = itrunc(Int8,rand(Uint32))
114+
rand(::Type{Int16}) = itrunc(Int16,rand(Uint32))
115+
rand(::Type{Int32}) = reinterpret(Int32,rand(Uint32))
116+
rand(::Type{Int64}) = reinterpret(Int64,rand(Uint64))
117+
rand(::Type{Int128}) = reinterpret(Int128,rand(Uint128))
118118

119119
# Arrays of random numbers
120120

‎base/reducedim.jl

+8
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,14 @@ reducedim_init(f, op::OrFun, A::AbstractArray, region) = reducedim_initarray(A,
101101

102102
# specialize to make initialization more efficient for common cases
103103

104+
if Int === Int32
105+
typealias SmallSigned Union(Int8,Int16)
106+
typealias SmallUnsigned Union(Uint8,Uint16)
107+
else
108+
typealias SmallSigned Union(Int8,Int16,Int32)
109+
typealias SmallUnsigned Union(Uint8,Uint16,Uint32)
110+
end
111+
104112
typealias CommonReduceResult Union(Uint64,Uint128,Int64,Int128,Float32,Float64)
105113

106114
for (IT, RT) in ((CommonReduceResult, :(eltype(A))), (SmallSigned, :Int), (SmallUnsigned, :Uint))

‎doc/stdlib/base.rst

+4-4
Original file line numberDiff line numberDiff line change
@@ -3090,9 +3090,9 @@ Mathematical Functions
30903090

30913091
Returns the nearest integral value of the same type as ``x`` not greater in magnitude than ``x``. ``digits`` and ``base`` work as above.
30923092

3093-
.. function:: iround(x) -> Integer
3093+
.. function:: iround([T,]x) -> Integer
30943094

3095-
Returns the nearest integer to ``x``.
3095+
Returns the nearest integer to ``x``, converted to an integer type, optionally passed as the first argument.
30963096

30973097
.. function:: iceil(x) -> Integer
30983098

@@ -3102,9 +3102,9 @@ Mathematical Functions
31023102

31033103
Returns the nearest integer not greater than ``x``.
31043104

3105-
.. function:: itrunc(x) -> Integer
3105+
.. function:: itrunc([T,]x) -> Integer
31063106

3107-
Returns the nearest integer not greater in magnitude than ``x``.
3107+
Returns the nearest integer not greater in magnitude than ``x``, converted to an integer type, optionally passed as the first argument.
31083108

31093109
.. function:: signif(x, digits, [base])
31103110

‎test/numbers.jl

+4-4
Original file line numberDiff line numberDiff line change
@@ -1459,7 +1459,7 @@ end
14591459
@test -0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 ==
14601460
-(0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001)
14611461

1462-
@test isa(-0x00,Uint)
1462+
@test isa(-0x00,Uint8)
14631463
@test isa(-0x0000000000000000,Uint64)
14641464
@test isa(-0x00000000000000000,Uint128)
14651465
@test isa(-0x00000000000000000000000000000000,Uint128)
@@ -1901,9 +1901,9 @@ end
19011901

19021902
for T = (Uint8,Int8,Uint16,Int16,Uint32,Int32,Uint64,Int64,Uint128,Int128)
19031903
for n = 1:2:1000
1904-
@test convert(T,n*(n^typemax(T))) == one(T)
1904+
@test n*(n^typemax(T)) & typemax(T) == 1
19051905
n = rand(T) | one(T)
1906-
@test convert(T,n*(n^typemax(T))) == one(T)
1906+
@test n*(n^typemax(T)) == 1
19071907
end
19081908
end
19091909

@@ -1931,7 +1931,7 @@ end
19311931
# widen
19321932
@test widen(1.5f0) === 1.5
19331933
@test widen(int32(42)) === int64(42)
1934-
@test widen(Int8) === Int
1934+
@test widen(Int8) === Int16
19351935
@test widen(Float32) === Float64
19361936
## Note: this should change to e.g. Float128 at some point
19371937
@test widen(Float64) === BigFloat

0 commit comments

Comments
 (0)