From 8d4949a3930a48a261ee40fb6ab7e43dc4408d20 Mon Sep 17 00:00:00 2001 From: Tobias Knopp Date: Sat, 16 Aug 2014 22:41:29 +0200 Subject: [PATCH 1/5] Preserve type on integer arithmetic --- base/int.jl | 91 +++++++++++++++++++++++------------------------ base/reducedim.jl | 4 +-- test/numbers.jl | 2 +- test/reduce.jl | 16 ++++----- 4 files changed, 56 insertions(+), 57 deletions(-) diff --git a/base/int.jl b/base/int.jl index 3a761b3072b18..c6e451b83d53c 100644 --- a/base/int.jl +++ b/base/int.jl @@ -1,49 +1,46 @@ ## type aliases ## -if Int === Int32 -typealias SmallSigned Union(Int8,Int16) -typealias SmallUnsigned Union(Uint8,Uint16) -else -typealias SmallSigned Union(Int8,Int16,Int32) -typealias SmallUnsigned Union(Uint8,Uint16,Uint32) -end - ## integer arithmetic ## --(x::SmallSigned) = -int(x) --(x::SmallUnsigned) = -uint(x) - -+{T<:SmallSigned}(x::T, y::T) = int(x) + int(y) --{T<:SmallSigned}(x::T, y::T) = int(x) - int(y) -*{T<:SmallSigned}(x::T, y::T) = int(x) * int(y) - -+{T<:SmallUnsigned}(x::T, y::T) = uint(x) + uint(y) --{T<:SmallUnsigned}(x::T, y::T) = uint(x) - uint(y) -*{T<:SmallUnsigned}(x::T, y::T) = uint(x) * uint(y) - --(x::Int) = box(Int,neg_int(unbox(Int,x))) --(x::Uint) = box(Uint,neg_int(unbox(Uint,x))) +-(x::Int8) = box(Int8,neg_int(unbox(Int8,x))) +-(x::Uint8) = box(Uint8,neg_int(unbox(Uint8,x))) +-(x::Int16) = box(Int16,neg_int(unbox(Int16,x))) +-(x::Uint16) = box(Uint16,neg_int(unbox(Uint16,x))) +-(x::Int32) = box(Int32,neg_int(unbox(Int32,x))) +-(x::Uint32) = box(Uint32,neg_int(unbox(Uint32,x))) -(x::Int64) = box(Int64,neg_int(unbox(Int64,x))) -(x::Uint64) = box(Uint64,neg_int(unbox(Uint64,x))) -(x::Int128) = box(Int128,neg_int(unbox(Int128,x))) -(x::Uint128) = box(Uint128,neg_int(unbox(Uint128,x))) -+(x::Int, y::Int) = box(Int,add_int(unbox(Int,x),unbox(Int,y))) -+(x::Uint, y::Uint) = box(Uint,add_int(unbox(Uint,x),unbox(Uint,y))) ++(x::Int8, y::Int8) = box(Int8,add_int(unbox(Int8,x),unbox(Int8,y))) ++(x::Uint8, y::Uint8) = box(Uint8,add_int(unbox(Uint8,x),unbox(Uint8,y))) ++(x::Int16, y::Int16) = box(Int16,add_int(unbox(Int16,x),unbox(Int16,y))) ++(x::Uint16, y::Uint16) = box(Uint16,add_int(unbox(Uint16,x),unbox(Uint16,y))) ++(x::Int32, y::Int32) = box(Int32,add_int(unbox(Int,x),unbox(Int32,y))) ++(x::Uint32, y::Uint32) = box(Uint32,add_int(unbox(Uint,x),unbox(Uint32,y))) +(x::Int64, y::Int64) = box(Int64,add_int(unbox(Int64,x),unbox(Int64,y))) +(x::Uint64, y::Uint64) = box(Uint64,add_int(unbox(Uint64,x),unbox(Uint64,y))) +(x::Int128, y::Int128) = box(Int128,add_int(unbox(Int128,x),unbox(Int128,y))) +(x::Uint128, y::Uint128) = box(Uint128,add_int(unbox(Uint128,x),unbox(Uint128,y))) --(x::Int, y::Int) = box(Int,sub_int(unbox(Int,x),unbox(Int,y))) --(x::Uint, y::Uint) = box(Uint,sub_int(unbox(Uint,x),unbox(Uint,y))) +-(x::Int8, y::Int8) = box(Int8,sub_int(unbox(Int8,x),unbox(Int8,y))) +-(x::Uint8, y::Uint8) = box(Uint8,sub_int(unbox(Uint8,x),unbox(Uint8,y))) +-(x::Int16, y::Int16) = box(Int16,sub_int(unbox(Int16,x),unbox(Int16,y))) +-(x::Uint16, y::Uint16) = box(Uint16,sub_int(unbox(Uint16,x),unbox(Uint16,y))) +-(x::Int32, y::Int32) = box(Int32,sub_int(unbox(Int,x),unbox(Int32,y))) +-(x::Uint32, y::Uint32) = box(Uint32,sub_int(unbox(Uint,x),unbox(Uint32,y))) -(x::Int64, y::Int64) = box(Int64,sub_int(unbox(Int64,x),unbox(Int64,y))) -(x::Uint64, y::Uint64) = box(Uint64,sub_int(unbox(Uint64,x),unbox(Uint64,y))) -(x::Int128, y::Int128) = box(Int128,sub_int(unbox(Int128,x),unbox(Int128,y))) -(x::Uint128, y::Uint128) = box(Uint128,sub_int(unbox(Uint128,x),unbox(Uint128,y))) -*(x::Int, y::Int) = box(Int,mul_int(unbox(Int,x),unbox(Int,y))) -*(x::Uint, y::Uint) = box(Uint,mul_int(unbox(Uint,x),unbox(Uint,y))) +*(x::Int8, y::Int8) = box(Int8,mul_int(unbox(Int8,x),unbox(Int8,y))) +*(x::Uint8, y::Uint8) = box(Uint8,mul_int(unbox(Uint8,x),unbox(Uint8,y))) +*(x::Int16, y::Int16) = box(Int16,mul_int(unbox(Int16,x),unbox(Int16,y))) +*(x::Uint16, y::Uint16) = box(Uint16,mul_int(unbox(Uint16,x),unbox(Uint16,y))) +*(x::Int32, y::Int32) = box(Int32,mul_int(unbox(Int,x),unbox(Int32,y))) +*(x::Uint32, y::Uint32) = box(Uint32,mul_int(unbox(Uint,x),unbox(Uint32,y))) *(x::Int64, y::Int64) = box(Int64,mul_int(unbox(Int64,x),unbox(Int64,y))) *(x::Uint64, y::Uint64) = box(Uint64,mul_int(unbox(Uint64,x),unbox(Uint64,y))) @@ -56,7 +53,9 @@ iseven(n::Integer) = !isodd(n) signbit(x::Integer) = x < 0 signbit(x::Unsigned) = false -flipsign(x::Int, y::Int) = box(Int,flipsign_int(unbox(Int,x),unbox(Int,y))) +flipsign(x::Int8, y::Int8) = box(Int8,flipsign_int(unbox(Int8,x),unbox(Int8,y))) +flipsign(x::Int16, y::Int16) = box(Int16,flipsign_int(unbox(Int16,x),unbox(Int16,y))) +flipsign(x::Int32, y::Int32) = box(Int32,flipsign_int(unbox(Int32,x),unbox(Int32,y))) flipsign(x::Int64, y::Int64) = box(Int64,flipsign_int(unbox(Int64,x),unbox(Int64,y))) flipsign(x::Int128, y::Int128) = box(Int128,flipsign_int(unbox(Int128,x),unbox(Int128,y))) @@ -328,18 +327,18 @@ convert(::Type{Uint128}, x::Float32) = convert(Uint128, float64(x)) convert(::Type{Char}, x::Float32) = char(convert(Int, x)) convert(::Type{Char}, x::Float64) = char(convert(Int, x)) -convert(::Type{Signed}, x::Uint8 ) = convert(Int,x) -convert(::Type{Signed}, x::Uint16 ) = convert(Int,x) -convert(::Type{Signed}, x::Uint32 ) = convert(Int,x) +convert(::Type{Signed}, x::Uint8 ) = convert(Int8,x) +convert(::Type{Signed}, x::Uint16 ) = convert(Int16,x) +convert(::Type{Signed}, x::Uint32 ) = convert(Int32,x) convert(::Type{Signed}, x::Uint64 ) = convert(Int64,x) convert(::Type{Signed}, x::Uint128) = convert(Int128,x) convert(::Type{Signed}, x::Float32) = convert(Int,x) convert(::Type{Signed}, x::Float64) = convert(Int,x) convert(::Type{Signed}, x::Char) = convert(Int,x) -convert(::Type{Unsigned}, x::Int8 ) = convert(Uint,x) -convert(::Type{Unsigned}, x::Int16 ) = convert(Uint,x) -convert(::Type{Unsigned}, x::Int32 ) = convert(Uint,x) +convert(::Type{Unsigned}, x::Int8 ) = convert(Uint8,x) +convert(::Type{Unsigned}, x::Int16 ) = convert(Uint16,x) +convert(::Type{Unsigned}, x::Int32 ) = convert(Uint32,x) convert(::Type{Unsigned}, x::Int64 ) = convert(Uint64,x) convert(::Type{Unsigned}, x::Int128 ) = convert(Uint128,x) convert(::Type{Unsigned}, x::Float32) = convert(Uint,x) @@ -396,9 +395,9 @@ const WORD_SIZE = int(Int.size)*8 ## integer promotions ## -promote_rule(::Type{Int16}, ::Type{Int8} ) = Int -promote_rule(::Type{Int32}, ::Type{Int8} ) = Int -promote_rule(::Type{Int32}, ::Type{Int16}) = Int +promote_rule(::Type{Int16}, ::Type{Int8} ) = Int16 +promote_rule(::Type{Int32}, ::Type{Int8} ) = Int32 +promote_rule(::Type{Int32}, ::Type{Int16}) = Int32 promote_rule(::Type{Int64}, ::Type{Int8} ) = Int64 promote_rule(::Type{Int64}, ::Type{Int16}) = Int64 promote_rule(::Type{Int64}, ::Type{Int32}) = Int64 @@ -407,9 +406,9 @@ promote_rule(::Type{Int128}, ::Type{Int16}) = Int128 promote_rule(::Type{Int128}, ::Type{Int32}) = Int128 promote_rule(::Type{Int128}, ::Type{Int64}) = Int128 -promote_rule(::Type{Uint16}, ::Type{Uint8} ) = Uint -promote_rule(::Type{Uint32}, ::Type{Uint8} ) = Uint -promote_rule(::Type{Uint32}, ::Type{Uint16}) = Uint +promote_rule(::Type{Uint16}, ::Type{Uint8} ) = Uint16 +promote_rule(::Type{Uint32}, ::Type{Uint8} ) = Uint32 +promote_rule(::Type{Uint32}, ::Type{Uint16}) = Uint32 promote_rule(::Type{Uint64}, ::Type{Uint8} ) = Uint64 promote_rule(::Type{Uint64}, ::Type{Uint16}) = Uint64 promote_rule(::Type{Uint64}, ::Type{Uint32}) = Uint64 @@ -418,15 +417,15 @@ promote_rule(::Type{Uint128}, ::Type{Uint16}) = Uint128 promote_rule(::Type{Uint128}, ::Type{Uint32}) = Uint128 promote_rule(::Type{Uint128}, ::Type{Uint64}) = Uint128 -promote_rule(::Type{Uint8}, ::Type{Int8} ) = Int -promote_rule(::Type{Uint8}, ::Type{Int16} ) = Int -promote_rule(::Type{Uint8}, ::Type{Int32} ) = Int +promote_rule(::Type{Uint8}, ::Type{Int8} ) = Int8 +promote_rule(::Type{Uint8}, ::Type{Int16} ) = Int16 +promote_rule(::Type{Uint8}, ::Type{Int32} ) = Int32 promote_rule(::Type{Uint8}, ::Type{Int64} ) = Int64 promote_rule(::Type{Uint8}, ::Type{Int128}) = Int128 -promote_rule(::Type{Uint16}, ::Type{Int8} ) = Int -promote_rule(::Type{Uint16}, ::Type{Int16} ) = Int -promote_rule(::Type{Uint16}, ::Type{Int32} ) = Int +promote_rule(::Type{Uint16}, ::Type{Int8} ) = Int16 +promote_rule(::Type{Uint16}, ::Type{Int16} ) = Int16 +promote_rule(::Type{Uint16}, ::Type{Int32} ) = Int32 promote_rule(::Type{Uint16}, ::Type{Int64} ) = Int64 promote_rule(::Type{Uint16}, ::Type{Int128}) = Int128 diff --git a/base/reducedim.jl b/base/reducedim.jl index 23b0950298174..d595d4838d2fb 100644 --- a/base/reducedim.jl +++ b/base/reducedim.jl @@ -101,9 +101,9 @@ reducedim_init(f, op::OrFun, A::AbstractArray, region) = reducedim_initarray(A, # specialize to make initialization more efficient for common cases -typealias CommonReduceResult Union(Uint64,Uint128,Int64,Int128,Float32,Float64) +typealias CommonReduceResult Union(Int8,Uint8,Int16,Uint16,Int32,Uint32,Uint64,Uint128,Int64,Int128,Float32,Float64) -for (IT, RT) in ((CommonReduceResult, :(eltype(A))), (SmallSigned, :Int), (SmallUnsigned, :Uint)) +for (IT, RT) in ((CommonReduceResult, :(eltype(A))),) T = Union([AbstractArray{t} for t in IT.types]..., [AbstractArray{Complex{t}} for t in IT.types]...) @eval begin reducedim_init(f::IdFun, op::AddFun, A::$T, region) = diff --git a/test/numbers.jl b/test/numbers.jl index 7e4f8103a4c48..ecabdd295d4fb 100644 --- a/test/numbers.jl +++ b/test/numbers.jl @@ -1341,7 +1341,7 @@ end @test -0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 == -(0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001) -@test isa(-0x00,Uint) +@test isa(-0x00,Uint8) @test isa(-0x0000000000000000,Uint64) @test isa(-0x00000000000000000,Uint128) @test isa(-0x00000000000000000000000000000000,Uint128) diff --git a/test/reduce.jl b/test/reduce.jl index 1799cc9176d39..dbbd94b652d8b 100644 --- a/test/reduce.jl +++ b/test/reduce.jl @@ -22,7 +22,7 @@ # sum -@test sum(Int8[]) === 0 +@test sum(Int8[]) === int8(0) @test sum(Int[]) === 0 @test sum(Float64[]) === 0.0 @@ -30,7 +30,7 @@ @test sum(3) === 3 @test sum(3.0) === 3.0 -@test sum([int8(3)]) === 3 +@test sum([int8(3)]) === int8(3) @test sum([3]) === 3 @test sum([3.0]) === 3.0 @@ -49,14 +49,14 @@ fz = float(z) a = randn(32) # need >16 elements to trigger BLAS code path b = complex(randn(32), randn(32)) @test sumabs(Float64[]) === 0.0 -@test sumabs([int8(-2)]) === 2 +@test sumabs([int8(-2)]) === int8(2) @test sumabs(z) === 14 @test sumabs(fz) === 14.0 @test_approx_eq sumabs(a) sum(abs(a)) @test_approx_eq sumabs(b) sum(abs(b)) @test sumabs2(Float64[]) === 0.0 -@test sumabs2([int8(-2)]) === 4 +@test sumabs2([int8(-2)]) === int8(4) @test sumabs2(z) === 54 @test sumabs2(fz) === 54.0 @test_approx_eq sumabs2(a) sum(abs2(a)) @@ -91,11 +91,11 @@ end # prod prod(Int[]) === 0 -prod(Int8[]) === 0 +prod(Int8[]) === int8(0) prod(Float64[]) === 0.0 prod([3]) === 0 -prod([int8(3)]) === 0 +prod([int8(3)]) === int8(0) prod([3.0]) === 0.0 prod(z) === 120 @@ -105,8 +105,8 @@ prod(fz) === 120.0 prod2(itr) = invoke(prod, (Any,), itr) @test prod(Int[]) === prod2(Int[]) === 1 @test prod(Int[7]) === prod2(Int[7]) === 7 -@test typeof(prod(Int8[])) == typeof(prod(Int8[1])) == typeof(prod(Int8[1, 7])) == Int -@test typeof(prod2(Int8[])) == typeof(prod2(Int8[1])) == typeof(prod2(Int8[1 7])) == Int +@test typeof(prod(Int8[])) == typeof(prod(Int8[1])) == typeof(prod(Int8[1, 7])) == Int8 +@test typeof(prod2(Int8[])) == typeof(prod2(Int8[1])) == typeof(prod2(Int8[1 7])) == Int8 # maximum & minimum & extrema From b054afd22015068f4c895136561941d23a70b9d9 Mon Sep 17 00:00:00 2001 From: Tobias Knopp Date: Sun, 17 Aug 2014 09:03:08 +0200 Subject: [PATCH 2/5] Implement integer functions in a generic way --- base/int.jl | 213 ++++++---------------------------------------------- 1 file changed, 25 insertions(+), 188 deletions(-) diff --git a/base/int.jl b/base/int.jl index c6e451b83d53c..4c83ae549b14f 100644 --- a/base/int.jl +++ b/base/int.jl @@ -1,48 +1,15 @@ ## type aliases ## +typealias Signed64 Union(Int8,Int16,Int32,Int64) +typealias Unsigned64 Union(Uint8,Uint16,Uint32,Uint64) +typealias Integer64 Union(Signed64,Unsigned64) + ## integer arithmetic ## --(x::Int8) = box(Int8,neg_int(unbox(Int8,x))) --(x::Uint8) = box(Uint8,neg_int(unbox(Uint8,x))) --(x::Int16) = box(Int16,neg_int(unbox(Int16,x))) --(x::Uint16) = box(Uint16,neg_int(unbox(Uint16,x))) --(x::Int32) = box(Int32,neg_int(unbox(Int32,x))) --(x::Uint32) = box(Uint32,neg_int(unbox(Uint32,x))) --(x::Int64) = box(Int64,neg_int(unbox(Int64,x))) --(x::Uint64) = box(Uint64,neg_int(unbox(Uint64,x))) --(x::Int128) = box(Int128,neg_int(unbox(Int128,x))) --(x::Uint128) = box(Uint128,neg_int(unbox(Uint128,x))) - -+(x::Int8, y::Int8) = box(Int8,add_int(unbox(Int8,x),unbox(Int8,y))) -+(x::Uint8, y::Uint8) = box(Uint8,add_int(unbox(Uint8,x),unbox(Uint8,y))) -+(x::Int16, y::Int16) = box(Int16,add_int(unbox(Int16,x),unbox(Int16,y))) -+(x::Uint16, y::Uint16) = box(Uint16,add_int(unbox(Uint16,x),unbox(Uint16,y))) -+(x::Int32, y::Int32) = box(Int32,add_int(unbox(Int,x),unbox(Int32,y))) -+(x::Uint32, y::Uint32) = box(Uint32,add_int(unbox(Uint,x),unbox(Uint32,y))) -+(x::Int64, y::Int64) = box(Int64,add_int(unbox(Int64,x),unbox(Int64,y))) -+(x::Uint64, y::Uint64) = box(Uint64,add_int(unbox(Uint64,x),unbox(Uint64,y))) -+(x::Int128, y::Int128) = box(Int128,add_int(unbox(Int128,x),unbox(Int128,y))) -+(x::Uint128, y::Uint128) = box(Uint128,add_int(unbox(Uint128,x),unbox(Uint128,y))) - --(x::Int8, y::Int8) = box(Int8,sub_int(unbox(Int8,x),unbox(Int8,y))) --(x::Uint8, y::Uint8) = box(Uint8,sub_int(unbox(Uint8,x),unbox(Uint8,y))) --(x::Int16, y::Int16) = box(Int16,sub_int(unbox(Int16,x),unbox(Int16,y))) --(x::Uint16, y::Uint16) = box(Uint16,sub_int(unbox(Uint16,x),unbox(Uint16,y))) --(x::Int32, y::Int32) = box(Int32,sub_int(unbox(Int,x),unbox(Int32,y))) --(x::Uint32, y::Uint32) = box(Uint32,sub_int(unbox(Uint,x),unbox(Uint32,y))) --(x::Int64, y::Int64) = box(Int64,sub_int(unbox(Int64,x),unbox(Int64,y))) --(x::Uint64, y::Uint64) = box(Uint64,sub_int(unbox(Uint64,x),unbox(Uint64,y))) --(x::Int128, y::Int128) = box(Int128,sub_int(unbox(Int128,x),unbox(Int128,y))) --(x::Uint128, y::Uint128) = box(Uint128,sub_int(unbox(Uint128,x),unbox(Uint128,y))) - -*(x::Int8, y::Int8) = box(Int8,mul_int(unbox(Int8,x),unbox(Int8,y))) -*(x::Uint8, y::Uint8) = box(Uint8,mul_int(unbox(Uint8,x),unbox(Uint8,y))) -*(x::Int16, y::Int16) = box(Int16,mul_int(unbox(Int16,x),unbox(Int16,y))) -*(x::Uint16, y::Uint16) = box(Uint16,mul_int(unbox(Uint16,x),unbox(Uint16,y))) -*(x::Int32, y::Int32) = box(Int32,mul_int(unbox(Int,x),unbox(Int32,y))) -*(x::Uint32, y::Uint32) = box(Uint32,mul_int(unbox(Uint,x),unbox(Uint32,y))) -*(x::Int64, y::Int64) = box(Int64,mul_int(unbox(Int64,x),unbox(Int64,y))) -*(x::Uint64, y::Uint64) = box(Uint64,mul_int(unbox(Uint64,x),unbox(Uint64,y))) +-{T<:Integer}(x::T) = box(T,neg_int(unbox(T,x))) ++{T<:Integer}(x::T, y::T) = box(T,add_int(unbox(T,x),unbox(T,y))) +-{T<:Integer}(x::T, y::T) = box(T,sub_int(unbox(T,x),unbox(T,y))) +*{T<:Integer64}(x::T, y::T) = box(T,mul_int(unbox(T,x),unbox(T,y))) /(x::Integer, y::Integer) = float(x)/float(y) inv(x::Integer) = float(one(x))/float(x) @@ -53,13 +20,8 @@ iseven(n::Integer) = !isodd(n) signbit(x::Integer) = x < 0 signbit(x::Unsigned) = false -flipsign(x::Int8, y::Int8) = box(Int8,flipsign_int(unbox(Int8,x),unbox(Int8,y))) -flipsign(x::Int16, y::Int16) = box(Int16,flipsign_int(unbox(Int16,x),unbox(Int16,y))) -flipsign(x::Int32, y::Int32) = box(Int32,flipsign_int(unbox(Int32,x),unbox(Int32,y))) -flipsign(x::Int64, y::Int64) = box(Int64,flipsign_int(unbox(Int64,x),unbox(Int64,y))) -flipsign(x::Int128, y::Int128) = box(Int128,flipsign_int(unbox(Int128,x),unbox(Int128,y))) +flipsign{T<:Signed}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y))) -flipsign{T<:Signed}(x::T,y::T) = flipsign(int(x),int(y)) flipsign(x::Signed, y::Signed) = flipsign(promote(x,y)...) flipsign(x::Signed, y::Float32) = flipsign(x, reinterpret(Int32,y)) flipsign(x::Signed, y::Float64) = flipsign(x, reinterpret(Int64,y)) @@ -89,9 +51,6 @@ mod(x::Unsigned, y::Signed) = rem(y+signed(rem(x,y)),y) # Don't promote integers for div/rem/mod since there no danger of overflow, # while there is a substantial performance penalty to 64-bit promotion. -typealias Signed64 Union(Int8,Int16,Int32,Int64) -typealias Unsigned64 Union(Uint8,Uint16,Uint32,Uint64) -typealias Integer64 Union(Signed64,Unsigned64) div{T<:Signed64} (x::T, y::T) = box(T,sdiv_int(unbox(T,x),unbox(T,y))) div{T<:Unsigned64}(x::T, y::T) = box(T,udiv_int(unbox(T,x),unbox(T,y))) @@ -106,89 +65,15 @@ fld{T<:Integer }(x::T, y::T) = div(x,y)-(signbit(x$y)&(rem(x,y)!=0)) ## integer bitwise operations ## -~(x::Int8 ) = box(Int8,not_int(unbox(Int8,x))) -~(x::Int16) = box(Int16,not_int(unbox(Int16,x))) -~(x::Int32) = box(Int32,not_int(unbox(Int32,x))) -~(x::Int64) = box(Int64,not_int(unbox(Int64,x))) -~(x::Int128) = box(Int128,not_int(unbox(Int128,x))) - -~(x::Uint8 ) = box(Uint8,not_int(unbox(Uint8,x))) -~(x::Uint16) = box(Uint16,not_int(unbox(Uint16,x))) -~(x::Uint32) = box(Uint32,not_int(unbox(Uint32,x))) -~(x::Uint64) = box(Uint64,not_int(unbox(Uint64,x))) -~(x::Uint128) = box(Uint128,not_int(unbox(Uint128,x))) - -(&)(x::Int8, y::Int8 ) = box(Int8,and_int(unbox(Int8,x),unbox(Int8,y))) -(&)(x::Int16, y::Int16) = box(Int16,and_int(unbox(Int16,x),unbox(Int16,y))) -(&)(x::Int32, y::Int32) = box(Int32,and_int(unbox(Int32,x),unbox(Int32,y))) -(&)(x::Int64, y::Int64) = box(Int64,and_int(unbox(Int64,x),unbox(Int64,y))) -(&)(x::Int128, y::Int128) = box(Int128,and_int(unbox(Int128,x),unbox(Int128,y))) - -(&)(x::Uint8, y::Uint8 ) = box(Uint8,and_int(unbox(Uint8,x),unbox(Uint8,y))) -(&)(x::Uint16, y::Uint16) = box(Uint16,and_int(unbox(Uint16,x),unbox(Uint16,y))) -(&)(x::Uint32, y::Uint32) = box(Uint32,and_int(unbox(Uint32,x),unbox(Uint32,y))) -(&)(x::Uint64, y::Uint64) = box(Uint64,and_int(unbox(Uint64,x),unbox(Uint64,y))) -(&)(x::Uint128, y::Uint128) = box(Uint128,and_int(unbox(Uint128,x),unbox(Uint128,y))) - -|(x::Int8, y::Int8) = box(Int8,or_int(unbox(Int8,x),unbox(Int8,y))) -|(x::Int16, y::Int16) = box(Int16,or_int(unbox(Int16,x),unbox(Int16,y))) -|(x::Int32, y::Int32) = box(Int32,or_int(unbox(Int32,x),unbox(Int32,y))) -|(x::Int64, y::Int64) = box(Int64,or_int(unbox(Int64,x),unbox(Int64,y))) -|(x::Int128, y::Int128) = box(Int128,or_int(unbox(Int128,x),unbox(Int128,y))) - -|(x::Uint8, y::Uint8) = box(Uint8,or_int(unbox(Uint8,x),unbox(Uint8,y))) -|(x::Uint16, y::Uint16) = box(Uint16,or_int(unbox(Uint16,x),unbox(Uint16,y))) -|(x::Uint32, y::Uint32) = box(Uint32,or_int(unbox(Uint32,x),unbox(Uint32,y))) -|(x::Uint64, y::Uint64) = box(Uint64,or_int(unbox(Uint64,x),unbox(Uint64,y))) -|(x::Uint128, y::Uint128) = box(Uint128,or_int(unbox(Uint128,x),unbox(Uint128,y))) - -($)(x::Int8, y::Int8) = box(Int8,xor_int(unbox(Int8,x),unbox(Int8,y))) -($)(x::Int16, y::Int16) = box(Int16,xor_int(unbox(Int16,x),unbox(Int16,y))) -($)(x::Int32, y::Int32) = box(Int32,xor_int(unbox(Int32,x),unbox(Int32,y))) -($)(x::Int64, y::Int64) = box(Int64,xor_int(unbox(Int64,x),unbox(Int64,y))) -($)(x::Int128, y::Int128) = box(Int128,xor_int(unbox(Int128,x),unbox(Int128,y))) - -($)(x::Uint8, y::Uint8) = box(Uint8,xor_int(unbox(Uint8,x),unbox(Uint8,y))) -($)(x::Uint16, y::Uint16) = box(Uint16,xor_int(unbox(Uint16,x),unbox(Uint16,y))) -($)(x::Uint32, y::Uint32) = box(Uint32,xor_int(unbox(Uint32,x),unbox(Uint32,y))) -($)(x::Uint64, y::Uint64) = box(Uint64,xor_int(unbox(Uint64,x),unbox(Uint64,y))) -($)(x::Uint128, y::Uint128) = box(Uint128,xor_int(unbox(Uint128,x),unbox(Uint128,y))) - -<<(x::Int8, y::Int32) = box(Int8,shl_int(unbox(Int8,x),unbox(Int32,y))) -<<(x::Int16, y::Int32) = box(Int16,shl_int(unbox(Int16,x),unbox(Int32,y))) -<<(x::Int32, y::Int32) = box(Int32,shl_int(unbox(Int32,x),unbox(Int32,y))) -<<(x::Int64, y::Int32) = box(Int64,shl_int(unbox(Int64,x),unbox(Int32,y))) -<<(x::Int128, y::Int32) = box(Int128,shl_int(unbox(Int128,x),unbox(Int32,y))) - -<<(x::Uint8, y::Int32) = box(Uint8,shl_int(unbox(Uint8,x),unbox(Int32,y))) -<<(x::Uint16, y::Int32) = box(Uint16,shl_int(unbox(Uint16,x),unbox(Int32,y))) -<<(x::Uint32, y::Int32) = box(Uint32,shl_int(unbox(Int32,x),unbox(Uint32,y))) -<<(x::Uint64, y::Int32) = box(Uint64,shl_int(unbox(Uint64,x),unbox(Int32,y))) -<<(x::Uint128, y::Int32) = box(Uint128,shl_int(unbox(Uint128,x),unbox(Int32,y))) - ->>(x::Int8, y::Int32) = box(Int8,ashr_int(unbox(Int8,x),unbox(Int32,y))) ->>(x::Int16, y::Int32) = box(Int16,ashr_int(unbox(Int16,x),unbox(Int32,y))) ->>(x::Int32, y::Int32) = box(Int32,ashr_int(unbox(Int32,x),unbox(Int32,y))) ->>(x::Int64, y::Int32) = box(Int64,ashr_int(unbox(Int64,x),unbox(Int32,y))) ->>(x::Int128, y::Int32) = box(Int128,ashr_int(unbox(Int128,x),unbox(Int32,y))) - ->>(x::Uint8, y::Int32) = box(Uint8,lshr_int(unbox(Uint8,x),unbox(Int32,y))) ->>(x::Uint16, y::Int32) = box(Uint16,lshr_int(unbox(Uint16,x),unbox(Int32,y))) ->>(x::Uint32, y::Int32) = box(Uint32,lshr_int(unbox(Int32,x),unbox(Uint32,y))) ->>(x::Uint64, y::Int32) = box(Uint64,lshr_int(unbox(Uint64,x),unbox(Int32,y))) ->>(x::Uint128, y::Int32) = box(Uint128,lshr_int(unbox(Uint128,x),unbox(Int32,y))) - ->>>(x::Int8, y::Int32) = box(Int8,lshr_int(unbox(Int8,x),unbox(Int32,y))) ->>>(x::Int16, y::Int32) = box(Int16,lshr_int(unbox(Int16,x),unbox(Int32,y))) ->>>(x::Int32, y::Int32) = box(Int32,lshr_int(unbox(Int32,x),unbox(Int32,y))) ->>>(x::Int64, y::Int32) = box(Int64,lshr_int(unbox(Int64,x),unbox(Int32,y))) ->>>(x::Int128, y::Int32) = box(Int128,lshr_int(unbox(Int128,x),unbox(Int32,y))) - ->>>(x::Uint8, y::Int32) = box(Uint8,lshr_int(unbox(Uint8,x),unbox(Int32,y))) ->>>(x::Uint16, y::Int32) = box(Uint16,lshr_int(unbox(Uint16,x),unbox(Int32,y))) ->>>(x::Uint32, y::Int32) = box(Uint32,lshr_int(unbox(Int32,x),unbox(Uint32,y))) ->>>(x::Uint64, y::Int32) = box(Uint64,lshr_int(unbox(Uint64,x),unbox(Int32,y))) ->>>(x::Uint128, y::Int32) = box(Uint128,lshr_int(unbox(Uint128,x),unbox(Int32,y))) +~{T<:Integer}(x::T) = box(T,not_int(unbox(T,x))) +(&){T<:Integer}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y))) +(|){T<:Integer}(x::T, y::T) = box(T,or_int(unbox(T,x),unbox(T,y))) +($){T<:Integer}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y))) + +<<{T<:Integer}(x::T, y::Int32) = box(T,shl_int(unbox(T,x),unbox(Int32,y))) +>>{T<:Signed}(x::T, y::Int32) = box(T,ashr_int(unbox(T,x),unbox(Int32,y))) +>>{T<:Unsigned}(x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) +>>>{T<:Integer} (x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) bswap(x::Int8) = x bswap(x::Uint8) = x @@ -201,38 +86,9 @@ bswap(x::Uint64) = box(Uint64,bswap_int(unbox(Uint64,x))) bswap(x::Int128) = box(Int128,bswap_int(unbox(Int128,x))) bswap(x::Uint128) = box(Uint128,bswap_int(unbox(Uint128,x))) -count_ones(x::Int8) = int(box(Int8,ctpop_int(unbox(Int8,x)))) -count_ones(x::Uint8) = int(box(Uint8,ctpop_int(unbox(Uint8,x)))) -count_ones(x::Int16) = int(box(Int16,ctpop_int(unbox(Int16,x)))) -count_ones(x::Uint16) = int(box(Uint16,ctpop_int(unbox(Uint16,x)))) -count_ones(x::Int32) = int(box(Int32,ctpop_int(unbox(Int32,x)))) -count_ones(x::Uint32) = int(box(Uint32,ctpop_int(unbox(Uint32,x)))) -count_ones(x::Int64) = int(box(Int64,ctpop_int(unbox(Int64,x)))) -count_ones(x::Uint64) = int(box(Uint64,ctpop_int(unbox(Uint64,x)))) -count_ones(x::Int128) = int(box(Int128,ctpop_int(unbox(Int128,x)))) -count_ones(x::Uint128) = int(box(Uint128,ctpop_int(unbox(Uint128,x)))) - -leading_zeros(x::Int8) = int(box(Int8,ctlz_int(unbox(Int8,x)))) -leading_zeros(x::Uint8) = int(box(Uint8,ctlz_int(unbox(Uint8,x)))) -leading_zeros(x::Int16) = int(box(Int16,ctlz_int(unbox(Int16,x)))) -leading_zeros(x::Uint16) = int(box(Uint16,ctlz_int(unbox(Uint16,x)))) -leading_zeros(x::Int32) = int(box(Int32,ctlz_int(unbox(Int32,x)))) -leading_zeros(x::Uint32) = int(box(Uint32,ctlz_int(unbox(Uint32,x)))) -leading_zeros(x::Int64) = int(box(Int64,ctlz_int(unbox(Int64,x)))) -leading_zeros(x::Uint64) = int(box(Uint64,ctlz_int(unbox(Uint64,x)))) -leading_zeros(x::Int128) = int(box(Int128,ctlz_int(unbox(Int128,x)))) -leading_zeros(x::Uint128) = int(box(Uint128,ctlz_int(unbox(Uint128,x)))) - -trailing_zeros(x::Int8) = int(box(Int8,cttz_int(unbox(Int8,x)))) -trailing_zeros(x::Uint8) = int(box(Uint8,cttz_int(unbox(Uint8,x)))) -trailing_zeros(x::Int16) = int(box(Int16,cttz_int(unbox(Int16,x)))) -trailing_zeros(x::Uint16) = int(box(Uint16,cttz_int(unbox(Uint16,x)))) -trailing_zeros(x::Int32) = int(box(Int32,cttz_int(unbox(Int32,x)))) -trailing_zeros(x::Uint32) = int(box(Uint32,cttz_int(unbox(Uint32,x)))) -trailing_zeros(x::Int64) = int(box(Int64,cttz_int(unbox(Int64,x)))) -trailing_zeros(x::Uint64) = int(box(Uint64,cttz_int(unbox(Uint64,x)))) -trailing_zeros(x::Int128) = int(box(Int128,cttz_int(unbox(Int128,x)))) -trailing_zeros(x::Uint128) = int(box(Uint128,cttz_int(unbox(Uint128,x)))) +count_ones{T<:Integer}(x::T) = int(box(T,ctpop_int(unbox(T,x)))) +leading_zeros{T<:Integer}(x::T) = int(box(T,ctlz_int(unbox(T,x)))) +trailing_zeros{T<:Integer}(x::T) = int(box(T,cttz_int(unbox(T,x)))) count_zeros (x::Integer) = count_ones(~x) leading_ones (x::Integer) = leading_zeros(~x) @@ -240,29 +96,10 @@ trailing_ones(x::Integer) = trailing_zeros(~x) ## integer comparisons ## -<(x::Int8, y::Int8) = slt_int(unbox(Int8,x),unbox(Int8,y)) -<(x::Int16, y::Int16) = slt_int(unbox(Int16,x),unbox(Int16,y)) -<(x::Int32, y::Int32) = slt_int(unbox(Int32,x),unbox(Int32,y)) -<(x::Int64, y::Int64) = slt_int(unbox(Int64,x),unbox(Int64,y)) -<(x::Int128, y::Int128) = slt_int(unbox(Int128,x),unbox(Int128,y)) - -<(x::Uint8, y::Uint8) = ult_int(unbox(Uint8,x),unbox(Uint8,y)) -<(x::Uint16, y::Uint16) = ult_int(unbox(Uint16,x),unbox(Uint16,y)) -<(x::Uint32, y::Uint32) = ult_int(unbox(Uint32,x),unbox(Uint32,y)) -<(x::Uint64, y::Uint64) = ult_int(unbox(Uint64,x),unbox(Uint64,y)) -<(x::Uint128, y::Uint128) = ult_int(unbox(Uint128,x),unbox(Uint128,y)) - -<=(x::Int8, y::Int8) = sle_int(unbox(Int8,x),unbox(Int8,y)) -<=(x::Int16, y::Int16) = sle_int(unbox(Int16,x),unbox(Int16,y)) -<=(x::Int32, y::Int32) = sle_int(unbox(Int32,x),unbox(Int32,y)) -<=(x::Int64, y::Int64) = sle_int(unbox(Int64,x),unbox(Int64,y)) -<=(x::Int128, y::Int128) = sle_int(unbox(Int128,x),unbox(Int128,y)) - -<=(x::Uint8, y::Uint8) = ule_int(unbox(Uint8,x),unbox(Uint8,y)) -<=(x::Uint16, y::Uint16) = ule_int(unbox(Uint16,x),unbox(Uint16,y)) -<=(x::Uint32, y::Uint32) = ule_int(unbox(Uint32,x),unbox(Uint32,y)) -<=(x::Uint64, y::Uint64) = ule_int(unbox(Uint64,x),unbox(Uint64,y)) -<=(x::Uint128, y::Uint128) = ule_int(unbox(Uint128,x),unbox(Uint128,y)) +<{T<:Signed}(x::T, y::T) = slt_int(unbox(T,x),unbox(T,y)) +<{T<:Unsigned}(x::T, y::T) = ult_int(unbox(T,x),unbox(T,y)) +<={T<:Signed}(x::T, y::T) = sle_int(unbox(T,x),unbox(T,y)) +<={T<:Unsigned}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y)) ==(x::Signed, y::Unsigned) = (x >= 0) & (unsigned(x) == y) ==(x::Unsigned, y::Signed ) = (y >= 0) & (x == unsigned(y)) From 9ed2efa61ae0d3c80f3bab55b9c0f743e32ddb26 Mon Sep 17 00:00:00 2001 From: Tobias Knopp Date: Sun, 17 Aug 2014 14:54:50 +0200 Subject: [PATCH 3/5] fix utf16 code and introduce Integer128 type --- base/int.jl | 71 ++++++++++++++++++++++----------------------------- base/utf16.jl | 2 +- 2 files changed, 31 insertions(+), 42 deletions(-) diff --git a/base/int.jl b/base/int.jl index 4c83ae549b14f..0ea2ac17538cd 100644 --- a/base/int.jl +++ b/base/int.jl @@ -4,11 +4,15 @@ typealias Signed64 Union(Int8,Int16,Int32,Int64) typealias Unsigned64 Union(Uint8,Uint16,Uint32,Uint64) typealias Integer64 Union(Signed64,Unsigned64) +typealias Signed128 Union(Signed64,Int128) +typealias Unsigned128 Union(Unsigned64,Uint128) +typealias Integer128 Union(Signed128,Unsigned128) + ## integer arithmetic ## --{T<:Integer}(x::T) = box(T,neg_int(unbox(T,x))) -+{T<:Integer}(x::T, y::T) = box(T,add_int(unbox(T,x),unbox(T,y))) --{T<:Integer}(x::T, y::T) = box(T,sub_int(unbox(T,x),unbox(T,y))) +-{T<:Integer128}(x::T) = box(T,neg_int(unbox(T,x))) ++{T<:Integer128}(x::T, y::T) = box(T,add_int(unbox(T,x),unbox(T,y))) +-{T<:Integer128}(x::T, y::T) = box(T,sub_int(unbox(T,x),unbox(T,y))) *{T<:Integer64}(x::T, y::T) = box(T,mul_int(unbox(T,x),unbox(T,y))) /(x::Integer, y::Integer) = float(x)/float(y) @@ -20,7 +24,7 @@ iseven(n::Integer) = !isodd(n) signbit(x::Integer) = x < 0 signbit(x::Unsigned) = false -flipsign{T<:Signed}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y))) +flipsign{T<:Signed128}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y))) flipsign(x::Signed, y::Signed) = flipsign(promote(x,y)...) flipsign(x::Signed, y::Float32) = flipsign(x, reinterpret(Int32,y)) @@ -65,30 +69,24 @@ fld{T<:Integer }(x::T, y::T) = div(x,y)-(signbit(x$y)&(rem(x,y)!=0)) ## integer bitwise operations ## -~{T<:Integer}(x::T) = box(T,not_int(unbox(T,x))) -(&){T<:Integer}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y))) -(|){T<:Integer}(x::T, y::T) = box(T,or_int(unbox(T,x),unbox(T,y))) -($){T<:Integer}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y))) +~{T<:Integer128}(x::T) = box(T,not_int(unbox(T,x))) +(&){T<:Integer128}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y))) +(|){T<:Integer128}(x::T, y::T) = box(T,or_int(unbox(T,x),unbox(T,y))) +($){T<:Integer128}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y))) -<<{T<:Integer}(x::T, y::Int32) = box(T,shl_int(unbox(T,x),unbox(Int32,y))) ->>{T<:Signed}(x::T, y::Int32) = box(T,ashr_int(unbox(T,x),unbox(Int32,y))) ->>{T<:Unsigned}(x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) ->>>{T<:Integer} (x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) +<<{T<:Integer128}(x::T, y::Int32) = box(T,shl_int(unbox(T,x),unbox(Int32,y))) +>>{T<:Signed128}(x::T, y::Int32) = box(T,ashr_int(unbox(T,x),unbox(Int32,y))) +>>{T<:Unsigned128}(x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) +>>>{T<:Integer128} (x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) bswap(x::Int8) = x bswap(x::Uint8) = x -bswap(x::Int16) = box(Int16,bswap_int(unbox(Int16,x))) -bswap(x::Uint16) = box(Uint16,bswap_int(unbox(Uint16,x))) -bswap(x::Int32) = box(Int32,bswap_int(unbox(Int32,x))) -bswap(x::Uint32) = box(Uint32,bswap_int(unbox(Uint32,x))) -bswap(x::Int64) = box(Int64,bswap_int(unbox(Int64,x))) -bswap(x::Uint64) = box(Uint64,bswap_int(unbox(Uint64,x))) -bswap(x::Int128) = box(Int128,bswap_int(unbox(Int128,x))) -bswap(x::Uint128) = box(Uint128,bswap_int(unbox(Uint128,x))) - -count_ones{T<:Integer}(x::T) = int(box(T,ctpop_int(unbox(T,x)))) -leading_zeros{T<:Integer}(x::T) = int(box(T,ctlz_int(unbox(T,x)))) -trailing_zeros{T<:Integer}(x::T) = int(box(T,cttz_int(unbox(T,x)))) +typealias ByteSwapIntegers Union(Int16, Uint16, Int32, Uint32, Int64, Uint64, Int128, Uint128) +bswap{T<:ByteSwapIntegers}(x::T) = box(T,bswap_int(unbox(T,x))) + +count_ones{T<:Integer128}(x::T) = int(box(T,ctpop_int(unbox(T,x)))) +leading_zeros{T<:Integer128}(x::T) = int(box(T,ctlz_int(unbox(T,x)))) +trailing_zeros{T<:Integer128}(x::T) = int(box(T,cttz_int(unbox(T,x)))) count_zeros (x::Integer) = count_ones(~x) leading_ones (x::Integer) = leading_zeros(~x) @@ -96,10 +94,10 @@ trailing_ones(x::Integer) = trailing_zeros(~x) ## integer comparisons ## -<{T<:Signed}(x::T, y::T) = slt_int(unbox(T,x),unbox(T,y)) -<{T<:Unsigned}(x::T, y::T) = ult_int(unbox(T,x),unbox(T,y)) -<={T<:Signed}(x::T, y::T) = sle_int(unbox(T,x),unbox(T,y)) -<={T<:Unsigned}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y)) +<{T<:Signed128}(x::T, y::T) = slt_int(unbox(T,x),unbox(T,y)) +<{T<:Unsigned128}(x::T, y::T) = ult_int(unbox(T,x),unbox(T,y)) +<={T<:Signed128}(x::T, y::T) = sle_int(unbox(T,x),unbox(T,y)) +<={T<:Unsigned128}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y)) ==(x::Signed, y::Unsigned) = (x >= 0) & (unsigned(x) == y) ==(x::Unsigned, y::Signed ) = (y >= 0) & (x == unsigned(y)) @@ -129,19 +127,10 @@ for to in _inttypes, from in _inttypes end end -for to in (Int8, Int16, Int32, Int64) - @eval begin - convert(::Type{$to}, x::Float32) = box($to,checked_fptosi($to,unbox(Float32,x))) - convert(::Type{$to}, x::Float64) = box($to,checked_fptosi($to,unbox(Float64,x))) - end -end - -for to in (Uint8, Uint16, Uint32, Uint64) - @eval begin - convert(::Type{$to}, x::Float32) = box($to,checked_fptoui($to,unbox(Float32,x))) - convert(::Type{$to}, x::Float64) = box($to,checked_fptoui($to,unbox(Float64,x))) - end -end +convert{T<:Signed64}(::Type{T}, x::Float32) = box(T,checked_fptosi(T,unbox(Float32,x))) +convert{T<:Signed64}(::Type{T}, x::Float64) = box(T,checked_fptosi(T,unbox(Float64,x))) +convert{T<:Unsigned64}(::Type{T}, x::Float32) = box(T,checked_fptoui(T,unbox(Float32,x))) +convert{T<:Unsigned64}(::Type{T}, x::Float64) = box(T,checked_fptoui(T,unbox(Float64,x))) function convert(::Type{Int128}, x::FloatingPoint) ax = abs(x) diff --git a/base/utf16.jl b/base/utf16.jl index 29c496dca7f6e..0c7638e879c20 100644 --- a/base/utf16.jl +++ b/base/utf16.jl @@ -11,7 +11,7 @@ end utf16_is_lead(c::Uint16) = (c & 0xfc00) == 0xd800 utf16_is_trail(c::Uint16) = (c & 0xfc00) == 0xdc00 utf16_is_surrogate(c::Uint16) = (c & 0xf800) == 0xd800 -utf16_get_supplementary(lead::Uint16, trail::Uint16) = char((lead-0xd7f7)<<10 + trail) +utf16_get_supplementary(lead::Uint16, trail::Uint16) = char((int32(lead)-0xd7f7)<<10 + trail) function endof(s::UTF16String) d = s.data From 4f24e828b02213692415dbab8910d18a722f355b Mon Sep 17 00:00:00 2001 From: Tobias Knopp Date: Thu, 21 Aug 2014 11:17:23 +0200 Subject: [PATCH 4/5] Rename union types to use ...Upto... for clarity --- base/int.jl | 70 ++++++++++++++++++++++++++--------------------------- 1 file changed, 35 insertions(+), 35 deletions(-) diff --git a/base/int.jl b/base/int.jl index 0ea2ac17538cd..2cd3e809eddbd 100644 --- a/base/int.jl +++ b/base/int.jl @@ -1,19 +1,19 @@ ## type aliases ## -typealias Signed64 Union(Int8,Int16,Int32,Int64) -typealias Unsigned64 Union(Uint8,Uint16,Uint32,Uint64) -typealias Integer64 Union(Signed64,Unsigned64) +typealias SignedUpto64 Union(Int8,Int16,Int32,Int64) +typealias UnsignedUpto64 Union(Uint8,Uint16,Uint32,Uint64) +typealias IntegerUpto64 Union(SignedUpto64,UnsignedUpto64) -typealias Signed128 Union(Signed64,Int128) -typealias Unsigned128 Union(Unsigned64,Uint128) -typealias Integer128 Union(Signed128,Unsigned128) +typealias SignedUpto128 Union(SignedUpto64,Int128) +typealias UnsignedUpto128 Union(UnsignedUpto64,Uint128) +typealias IntegerUpto128 Union(SignedUpto128,UnsignedUpto128) ## integer arithmetic ## --{T<:Integer128}(x::T) = box(T,neg_int(unbox(T,x))) -+{T<:Integer128}(x::T, y::T) = box(T,add_int(unbox(T,x),unbox(T,y))) --{T<:Integer128}(x::T, y::T) = box(T,sub_int(unbox(T,x),unbox(T,y))) -*{T<:Integer64}(x::T, y::T) = box(T,mul_int(unbox(T,x),unbox(T,y))) +-{T<:IntegerUpto128}(x::T) = box(T,neg_int(unbox(T,x))) ++{T<:IntegerUpto128}(x::T, y::T) = box(T,add_int(unbox(T,x),unbox(T,y))) +-{T<:IntegerUpto128}(x::T, y::T) = box(T,sub_int(unbox(T,x),unbox(T,y))) +*{T<:IntegerUpto64}(x::T, y::T) = box(T,mul_int(unbox(T,x),unbox(T,y))) /(x::Integer, y::Integer) = float(x)/float(y) inv(x::Integer) = float(one(x))/float(x) @@ -24,7 +24,7 @@ iseven(n::Integer) = !isodd(n) signbit(x::Integer) = x < 0 signbit(x::Unsigned) = false -flipsign{T<:Signed128}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y))) +flipsign{T<:SignedUpto128}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y))) flipsign(x::Signed, y::Signed) = flipsign(promote(x,y)...) flipsign(x::Signed, y::Float32) = flipsign(x, reinterpret(Int32,y)) @@ -56,11 +56,11 @@ mod(x::Unsigned, y::Signed) = rem(y+signed(rem(x,y)),y) # Don't promote integers for div/rem/mod since there no danger of overflow, # while there is a substantial performance penalty to 64-bit promotion. -div{T<:Signed64} (x::T, y::T) = box(T,sdiv_int(unbox(T,x),unbox(T,y))) -div{T<:Unsigned64}(x::T, y::T) = box(T,udiv_int(unbox(T,x),unbox(T,y))) -rem{T<:Signed64} (x::T, y::T) = box(T,srem_int(unbox(T,x),unbox(T,y))) -rem{T<:Unsigned64}(x::T, y::T) = box(T,urem_int(unbox(T,x),unbox(T,y))) -mod{T<:Signed64} (x::T, y::T) = box(T,smod_int(unbox(T,x),unbox(T,y))) +div{T<:SignedUpto64} (x::T, y::T) = box(T,sdiv_int(unbox(T,x),unbox(T,y))) +div{T<:UnsignedUpto64}(x::T, y::T) = box(T,udiv_int(unbox(T,x),unbox(T,y))) +rem{T<:SignedUpto64} (x::T, y::T) = box(T,srem_int(unbox(T,x),unbox(T,y))) +rem{T<:UnsignedUpto64}(x::T, y::T) = box(T,urem_int(unbox(T,x),unbox(T,y))) +mod{T<:SignedUpto64} (x::T, y::T) = box(T,smod_int(unbox(T,x),unbox(T,y))) mod{T<:Unsigned}(x::T, y::T) = rem(x,y) @@ -69,24 +69,24 @@ fld{T<:Integer }(x::T, y::T) = div(x,y)-(signbit(x$y)&(rem(x,y)!=0)) ## integer bitwise operations ## -~{T<:Integer128}(x::T) = box(T,not_int(unbox(T,x))) -(&){T<:Integer128}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y))) -(|){T<:Integer128}(x::T, y::T) = box(T,or_int(unbox(T,x),unbox(T,y))) -($){T<:Integer128}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y))) +~{T<:IntegerUpto128}(x::T) = box(T,not_int(unbox(T,x))) +(&){T<:IntegerUpto128}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y))) +(|){T<:IntegerUpto128}(x::T, y::T) = box(T,or_int(unbox(T,x),unbox(T,y))) +($){T<:IntegerUpto128}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y))) -<<{T<:Integer128}(x::T, y::Int32) = box(T,shl_int(unbox(T,x),unbox(Int32,y))) ->>{T<:Signed128}(x::T, y::Int32) = box(T,ashr_int(unbox(T,x),unbox(Int32,y))) ->>{T<:Unsigned128}(x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) ->>>{T<:Integer128} (x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) +<<{T<:IntegerUpto128}(x::T, y::Int32) = box(T,shl_int(unbox(T,x),unbox(Int32,y))) +>>{T<:SignedUpto128}(x::T, y::Int32) = box(T,ashr_int(unbox(T,x),unbox(Int32,y))) +>>{T<:UnsignedUpto128}(x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) +>>>{T<:IntegerUpto128} (x::T, y::Int32) = box(T,lshr_int(unbox(T,x),unbox(Int32,y))) bswap(x::Int8) = x bswap(x::Uint8) = x typealias ByteSwapIntegers Union(Int16, Uint16, Int32, Uint32, Int64, Uint64, Int128, Uint128) bswap{T<:ByteSwapIntegers}(x::T) = box(T,bswap_int(unbox(T,x))) -count_ones{T<:Integer128}(x::T) = int(box(T,ctpop_int(unbox(T,x)))) -leading_zeros{T<:Integer128}(x::T) = int(box(T,ctlz_int(unbox(T,x)))) -trailing_zeros{T<:Integer128}(x::T) = int(box(T,cttz_int(unbox(T,x)))) +count_ones{T<:IntegerUpto128}(x::T) = int(box(T,ctpop_int(unbox(T,x)))) +leading_zeros{T<:IntegerUpto128}(x::T) = int(box(T,ctlz_int(unbox(T,x)))) +trailing_zeros{T<:IntegerUpto128}(x::T) = int(box(T,cttz_int(unbox(T,x)))) count_zeros (x::Integer) = count_ones(~x) leading_ones (x::Integer) = leading_zeros(~x) @@ -94,10 +94,10 @@ trailing_ones(x::Integer) = trailing_zeros(~x) ## integer comparisons ## -<{T<:Signed128}(x::T, y::T) = slt_int(unbox(T,x),unbox(T,y)) -<{T<:Unsigned128}(x::T, y::T) = ult_int(unbox(T,x),unbox(T,y)) -<={T<:Signed128}(x::T, y::T) = sle_int(unbox(T,x),unbox(T,y)) -<={T<:Unsigned128}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y)) +<{T<:SignedUpto128}(x::T, y::T) = slt_int(unbox(T,x),unbox(T,y)) +<{T<:UnsignedUpto128}(x::T, y::T) = ult_int(unbox(T,x),unbox(T,y)) +<={T<:SignedUpto128}(x::T, y::T) = sle_int(unbox(T,x),unbox(T,y)) +<={T<:UnsignedUpto128}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y)) ==(x::Signed, y::Unsigned) = (x >= 0) & (unsigned(x) == y) ==(x::Unsigned, y::Signed ) = (y >= 0) & (x == unsigned(y)) @@ -127,10 +127,10 @@ for to in _inttypes, from in _inttypes end end -convert{T<:Signed64}(::Type{T}, x::Float32) = box(T,checked_fptosi(T,unbox(Float32,x))) -convert{T<:Signed64}(::Type{T}, x::Float64) = box(T,checked_fptosi(T,unbox(Float64,x))) -convert{T<:Unsigned64}(::Type{T}, x::Float32) = box(T,checked_fptoui(T,unbox(Float32,x))) -convert{T<:Unsigned64}(::Type{T}, x::Float64) = box(T,checked_fptoui(T,unbox(Float64,x))) +convert{T<:SignedUpto64}(::Type{T}, x::Float32) = box(T,checked_fptosi(T,unbox(Float32,x))) +convert{T<:SignedUpto64}(::Type{T}, x::Float64) = box(T,checked_fptosi(T,unbox(Float64,x))) +convert{T<:UnsignedUpto64}(::Type{T}, x::Float32) = box(T,checked_fptoui(T,unbox(Float32,x))) +convert{T<:UnsignedUpto64}(::Type{T}, x::Float64) = box(T,checked_fptoui(T,unbox(Float64,x))) function convert(::Type{Int128}, x::FloatingPoint) ax = abs(x) From 2921e30c6471512347617129a5b91414bbcfe5a0 Mon Sep 17 00:00:00 2001 From: Tobias Knopp Date: Thu, 21 Aug 2014 11:57:40 +0200 Subject: [PATCH 5/5] Fix missing renames --- base/abstractarray.jl | 4 ++-- base/hashing2.jl | 2 +- base/printf.jl | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/base/abstractarray.jl b/base/abstractarray.jl index cdfa0abe14e6c..1163e0c3994b9 100644 --- a/base/abstractarray.jl +++ b/base/abstractarray.jl @@ -320,8 +320,8 @@ end float{T<:FloatingPoint}(x::AbstractArray{T}) = x complex{T<:Complex}(x::AbstractArray{T}) = x -float{T<:Integer64}(x::AbstractArray{T}) = convert(AbstractArray{typeof(float(zero(T)))}, x) -complex{T<:Union(Integer64,Float64,Float32,Float16)}(x::AbstractArray{T}) = +float{T<:IntegerUpto64}(x::AbstractArray{T}) = convert(AbstractArray{typeof(float(zero(T)))}, x) +complex{T<:Union(IntegerUpto64,Float64,Float32,Float16)}(x::AbstractArray{T}) = convert(AbstractArray{typeof(complex(zero(T)))}, x) function float(A::AbstractArray) diff --git a/base/hashing2.jl b/base/hashing2.jl index 342e2dc6c8a93..7d640a885307b 100644 --- a/base/hashing2.jl +++ b/base/hashing2.jl @@ -129,7 +129,7 @@ end ## streamlined hashing for smallish rational types ## -function hash{T<:Integer64}(x::Rational{T}, h::Uint) +function hash{T<:IntegerUpto64}(x::Rational{T}, h::Uint) num, den = Base.num(x), Base.den(x) den == 1 && return hash(num, h) den == 0 && return hash(ifelse(num > 0, Inf, -Inf), h) diff --git a/base/printf.jl b/base/printf.jl index b19483795714b..27d823ac5fbde 100644 --- a/base/printf.jl +++ b/base/printf.jl @@ -4,7 +4,7 @@ export @printf, @sprintf ### printf formatter generation ### const SmallFloatingPoint = Union(Float64,Float32,Float16) -const SmallNumber = Union(SmallFloatingPoint,Base.Signed64,Base.Unsigned64,Uint128,Int128) +const SmallNumber = Union(SmallFloatingPoint,Base.SignedUpto128,Base.UnsignedUpto128) function gen(s::String) args = {}