mollusk 0e4acfb8f2 fix incorrect folder name for julia-0.6.x
Former-commit-id: ef2c7401e0876f22d2f7762d182cfbcd5a7d9c70
2018-06-11 03:28:36 -07:00

2978 lines
99 KiB
Julia
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# This file is a part of Julia. License is MIT: https://julialang.org/license
const = isequal # convenient for comparing NaNs
# basic booleans
@test true
@test !false
@test !!true
@test !!!false
@test true == true
@test false == false
@test true != false
@test false != true
@test ~true == false
@test ~false == true
@test false & false == false
@test true & false == false
@test false & true == false
@test true & true == true
@test false | false == false
@test true | false == true
@test false | true == true
@test true | true == true
@test false false == false
@test true false == true
@test false true == true
@test true true == false
@test xor(false, false) == false
@test xor(true, false) == true
@test xor(false, true) == true
@test xor(true, true) == false
# the bool operator
@test Bool(false) == false
@test Bool(true) == true
@test Bool(0) == false
@test Bool(1) == true
@test_throws InexactError Bool(-1)
@test Bool(0.0) == false
@test Bool(1.0) == true
@test_throws InexactError Bool(0.1)
@test_throws InexactError Bool(-1.0)
@test Bool(Complex(0,0)) == false
@test Bool(Complex(1,0)) == true
@test_throws InexactError Bool(Complex(0,1))
@test Bool(0//1) == false
@test Bool(1//1) == true
@test_throws InexactError Bool(1//2)
@test iszero(false) && !iszero(true)
# basic arithmetic
@test 2 + 3 == 5
@test 2.0 + 3.0 == 5.
@test 2 * 3 == 6
@test 2.0 * 3 == 6
@test 2.0 * 3.0 == 6.
@test min(1.0,1) == 1
# min, max and minmax
@test min(1) === 1
@test max(1) === 1
@test minmax(1) === (1, 1)
@test minmax(5, 3) == (3, 5)
@test minmax(3., 5.) == (3., 5.)
@test minmax(5., 3.) == (3., 5.)
@test minmax(3., NaN) (NaN, NaN)
@test minmax(NaN, 3) (NaN, NaN)
@test minmax(Inf, NaN) (NaN, NaN)
@test minmax(NaN, Inf) (NaN, NaN)
@test minmax(-Inf, NaN) (NaN, NaN)
@test minmax(NaN, -Inf) (NaN, NaN)
@test minmax(NaN, NaN) (NaN, NaN)
@test min(-0.0,0.0) === min(0.0,-0.0)
@test max(-0.0,0.0) === max(0.0,-0.0)
@test minmax(-0.0,0.0) === minmax(0.0,-0.0)
@test max(-3.2, 5.1) == max(5.1, -3.2) == 5.1
@test min(-3.2, 5.1) == min(5.1, -3.2) == -3.2
@test max(-3.2, Inf) == max(Inf, -3.2) == Inf
@test max(-3.2, NaN) max(NaN, -3.2) NaN
@test min(5.1, Inf) == min(Inf, 5.1) == 5.1
@test min(5.1, -Inf) == min(-Inf, 5.1) == -Inf
@test min(5.1, NaN) min(NaN, 5.1) NaN
@test min(5.1, -NaN) min(-NaN, 5.1) NaN
@test minmax(-3.2, 5.1) == (min(-3.2, 5.1), max(-3.2, 5.1))
@test minmax(-3.2, Inf) == (min(-3.2, Inf), max(-3.2, Inf))
@test minmax(-3.2, NaN) (min(-3.2, NaN), max(-3.2, NaN))
@test (max(Inf,NaN), max(-Inf,NaN), max(Inf,-NaN), max(-Inf,-NaN)) (NaN,NaN,NaN,NaN)
@test (max(NaN,Inf), max(NaN,-Inf), max(-NaN,Inf), max(-NaN,-Inf)) (NaN,NaN,NaN,NaN)
@test (min(Inf,NaN), min(-Inf,NaN), min(Inf,-NaN), min(-Inf,-NaN)) (NaN,NaN,NaN,NaN)
@test (min(NaN,Inf), min(NaN,-Inf), min(-NaN,Inf), min(-NaN,-Inf)) (NaN,NaN,NaN,NaN)
@test minmax(-Inf,NaN) (min(-Inf,NaN), max(-Inf,NaN))
# fma
let x = Int64(7)^7
@test fma(x-1, x-2, x-3) == (x-1) * (x-2) + (x-3)
@test (fma((x-1)//(x-2), (x-3)//(x-4), (x-5)//(x-6)) ==
(x-1)//(x-2) * (x-3)//(x-4) + (x-5)//(x-6))
end
let x = BigInt(7)^77
@test fma(x-1, x-2, x-3) == (x-1) * (x-2) + (x-3)
@test (fma((x-1)//(x-2), (x-3)//(x-4), (x-5)//(x-6)) ==
(x-1)//(x-2) * (x-3)//(x-4) + (x-5)//(x-6))
end
let eps = 1//BigInt(2)^30, one_eps = 1+eps,
eps64 = Float64(eps), one_eps64 = Float64(one_eps)
@test eps64 == Float64(eps)
@test rationalize(BigInt, eps64, tol=0) == eps
@test one_eps64 == Float64(one_eps)
@test rationalize(BigInt, one_eps64, tol=0) == one_eps
@test one_eps64 * one_eps64 - 1 != Float64(one_eps * one_eps - 1)
@test fma(one_eps64, one_eps64, -1) == Float64(one_eps * one_eps - 1)
end
let eps = 1//BigInt(2)^15, one_eps = 1+eps,
eps32 = Float32(eps), one_eps32 = Float32(one_eps)
@test eps32 == Float32(eps)
@test rationalize(BigInt, eps32, tol=0) == eps
@test one_eps32 == Float32(one_eps)
@test rationalize(BigInt, one_eps32, tol=0) == one_eps
@test one_eps32 * one_eps32 - 1 != Float32(one_eps * one_eps - 1)
@test fma(one_eps32, one_eps32, -1) == Float32(one_eps * one_eps - 1)
end
let eps = 1//BigInt(2)^7, one_eps = 1+eps,
eps16 = Float16(Float32(eps)), one_eps16 = Float16(Float32(one_eps))
@test eps16 == Float16(Float32(eps))
@test rationalize(BigInt, eps16, tol=0) == eps
@test one_eps16 == Float16(Float32(one_eps))
@test rationalize(BigInt, one_eps16, tol=0) == one_eps
@test one_eps16 * one_eps16 - 1 != Float16(Float32(one_eps * one_eps - 1))
@test (fma(one_eps16, one_eps16, -1) ==
Float16(Float32(one_eps * one_eps - 1)))
end
let eps = 1//BigInt(2)^200, one_eps = 1+eps,
eps256 = BigFloat(eps), one_eps256 = BigFloat(one_eps)
@test eps256 == BigFloat(eps)
@test rationalize(BigInt, eps256, tol=0) == eps
@test one_eps256 == BigFloat(one_eps)
@test rationalize(BigInt, one_eps256, tol=0) == one_eps
@test one_eps256 * one_eps256 - 1 != BigFloat(one_eps * one_eps - 1)
@test fma(one_eps256, one_eps256, -1) == BigFloat(one_eps * one_eps - 1)
end
# muladd
let eps = 1//BigInt(2)^30, one_eps = 1+eps,
eps64 = Float64(eps), one_eps64 = Float64(one_eps)
@test eps64 == Float64(eps)
@test one_eps64 == Float64(one_eps)
@test one_eps64 * one_eps64 - 1 != Float64(one_eps * one_eps - 1)
@test muladd(one_eps64, one_eps64, -1) Float64(one_eps * one_eps - 1)
end
let eps = 1//BigInt(2)^15, one_eps = 1+eps,
eps32 = Float32(eps), one_eps32 = Float32(one_eps)
@test eps32 == Float32(eps)
@test one_eps32 == Float32(one_eps)
@test one_eps32 * one_eps32 - 1 != Float32(one_eps * one_eps - 1)
@test muladd(one_eps32, one_eps32, -1) Float32(one_eps * one_eps - 1)
end
let eps = 1//BigInt(2)^7, one_eps = 1+eps,
eps16 = Float16(Float32(eps)), one_eps16 = Float16(Float32(one_eps))
@test eps16 == Float16(Float32(eps))
@test one_eps16 == Float16(Float32(one_eps))
@test one_eps16 * one_eps16 - 1 != Float16(Float32(one_eps * one_eps - 1))
@test muladd(one_eps16, one_eps16, -1) Float16(Float32(one_eps * one_eps - 1))
end
@test muladd(1,2,3) == 1*2+3
@test muladd(big(1),2,3) == big(1)*2+3
@test muladd(UInt(1),2,3) == UInt(1)*2+3
@test muladd(1//1,2,3) == (1//1)*2+3
@test muladd(big(1//1),2,3) == big(1//1)*2+3
@test muladd(1.0,2,3) == 1.0*2+3
@test muladd(big(1.0),2,3) == big(1.0)*2+3
# lexing typemin(Int64)
@test (-9223372036854775808)^1 == -9223372036854775808
@test [1 -1 -9223372036854775808] == [1 -1 typemin(Int64)]
# large integer literals
@test isa(-170141183460469231731687303715884105729,BigInt)
@test isa(-170141183460469231731687303715884105728,Int128)
@test isa(-9223372036854775809,Int128)
@test isa(-9223372036854775808,Int64)
@test isa(9223372036854775807,Int64)
@test isa(9223372036854775808,Int128)
@test isa(170141183460469231731687303715884105727,Int128)
@test isa(170141183460469231731687303715884105728,BigInt)
@test isa(0170141183460469231731687303715884105728,BigInt)
# exponentiating with a negative base
@test -3^2 == -9
@test -9223372036854775808^2 == -(9223372036854775808^2)
@test -10000000000000000000^2 == -(10000000000000000000^2)
@test -170141183460469231731687303715884105728^2 ==
-(170141183460469231731687303715884105728^2)
# numeric literal coefficients
let x = 10
@test 2x == 20
@test 9223372036854775808x == 92233720368547758080
@test 170141183460469231731687303715884105728x ==
1701411834604692317316873037158841057280
end
@test 2(10) == 20
@test 9223372036854775808(10) == 92233720368547758080
@test 170141183460469231731687303715884105728(10) ==
1701411834604692317316873037158841057280
# definition and printing of extreme integers
@test bin(typemin(UInt8)) == "0"
@test bin(typemax(UInt8)) == "1"^8
@test oct(typemin(UInt8)) == "0"
@test oct(typemax(UInt8)) == "377"
@test dec(typemin(UInt8)) == "0"
@test dec(typemax(UInt8)) == "255"
@test hex(typemin(UInt8)) == "0"
@test hex(typemax(UInt8)) == "ff"
@test repr(typemin(UInt8)) == "0x00"
@test string(typemin(UInt8)) == "0"
@test repr(typemax(UInt8)) == "0xff"
@test string(typemax(UInt8)) == "255"
@test base(3,typemin(UInt8)) == "0"
@test base(3,typemax(UInt8)) == "100110"
@test base(12,typemin(UInt8)) == "0"
@test base(12,typemax(UInt8)) == "193"
@test bin(typemin(UInt16)) == "0"
@test bin(typemax(UInt16)) == "1"^16
@test oct(typemin(UInt16)) == "0"
@test oct(typemax(UInt16)) == "177777"
@test dec(typemin(UInt16)) == "0"
@test dec(typemax(UInt16)) == "65535"
@test hex(typemin(UInt16)) == "0"
@test hex(typemax(UInt16)) == "ffff"
@test repr(typemin(UInt16)) == "0x0000"
@test string(typemin(UInt16)) == "0"
@test repr(typemax(UInt16)) == "0xffff"
@test string(typemax(UInt16)) == "65535"
@test base(3,typemin(UInt16)) == "0"
@test base(3,typemax(UInt16)) == "10022220020"
@test base(12,typemin(UInt16)) == "0"
@test base(12,typemax(UInt16)) == "31b13"
@test bin(typemin(UInt32)) == "0"
@test bin(typemax(UInt32)) == "1"^32
@test oct(typemin(UInt32)) == "0"
@test oct(typemax(UInt32)) == "37777777777"
@test dec(typemin(UInt32)) == "0"
@test dec(typemax(UInt32)) == "4294967295"
@test hex(typemin(UInt32)) == "0"
@test hex(typemax(UInt32)) == "ffffffff"
@test repr(typemin(UInt32)) == "0x00000000"
@test string(typemin(UInt32)) == "0"
@test repr(typemax(UInt32)) == "0xffffffff"
@test string(typemax(UInt32)) == "4294967295"
@test base(3,typemin(UInt32)) == "0"
@test base(3,typemax(UInt32)) == "102002022201221111210"
@test base(12,typemin(UInt32)) == "0"
@test base(12,typemax(UInt32)) == "9ba461593"
@test bin(typemin(UInt64)) == "0"
@test bin(typemax(UInt64)) == "1"^64
@test oct(typemin(UInt64)) == "0"
@test oct(typemax(UInt64)) == "1777777777777777777777"
@test dec(typemin(UInt64)) == "0"
@test dec(typemax(UInt64)) == "18446744073709551615"
@test hex(typemin(UInt64)) == "0"
@test hex(typemax(UInt64)) == "ffffffffffffffff"
@test repr(typemin(UInt64)) == "0x0000000000000000"
@test string(typemin(UInt64)) == "0"
@test repr(typemax(UInt64)) == "0xffffffffffffffff"
@test string(typemax(UInt64)) == "18446744073709551615"
@test base(3,typemin(UInt64)) == "0"
@test base(3,typemax(UInt64)) == "11112220022122120101211020120210210211220"
@test base(12,typemin(UInt64)) == "0"
@test base(12,typemax(UInt64)) == "839365134a2a240713"
@test bin(typemin(UInt128)) == "0"
@test bin(typemax(UInt128)) == "1"^128
@test oct(typemin(UInt128)) == "0"
@test oct(typemax(UInt128)) == "3777777777777777777777777777777777777777777"
@test hex(typemin(UInt128)) == "0"
@test hex(typemax(UInt128)) == "ffffffffffffffffffffffffffffffff"
@test repr(typemin(UInt128)) == "0x00000000000000000000000000000000"
@test string(typemin(UInt128)) == "0"
@test repr(typemax(UInt128)) == "0xffffffffffffffffffffffffffffffff"
@test string(typemax(UInt128)) == "340282366920938463463374607431768211455"
@test dec(typemin(UInt128)) == "0"
@test dec(typemax(UInt128)) == "340282366920938463463374607431768211455"
@test base(3,typemin(UInt128)) == "0"
@test base(3,typemax(UInt128)) ==
"202201102121002021012000211012011021221022212021111001022110211020010021100121010"
@test base(12,typemin(UInt128)) == "0"
@test base(12,typemax(UInt128)) == "5916b64b41143526a777873841863a6a6993"
@test bin(typemin(Int8)) == "-1"*"0"^7
@test bin(typemax(Int8)) == "1"^7
@test oct(typemin(Int8)) == "-200"
@test oct(typemax(Int8)) == "177"
@test dec(typemin(Int8)) == "-128"
@test dec(typemax(Int8)) == "127"
@test hex(typemin(Int8)) == "-80"
@test hex(typemax(Int8)) == "7f"
@test string(typemin(Int8)) == "-128"
@test string(typemax(Int8)) == "127"
@test base(3,typemin(Int8)) == "-11202"
@test base(3,typemax(Int8)) == "11201"
@test base(12,typemin(Int8)) == "-a8"
@test base(12,typemax(Int8)) == "a7"
@test bin(typemin(Int16)) == "-1"*"0"^15
@test bin(typemax(Int16)) == "1"^15
@test oct(typemin(Int16)) == "-100000"
@test oct(typemax(Int16)) == "77777"
@test dec(typemin(Int16)) == "-32768"
@test dec(typemax(Int16)) == "32767"
@test hex(typemin(Int16)) == "-8000"
@test hex(typemax(Int16)) == "7fff"
@test string(typemin(Int16)) == "-32768"
@test string(typemax(Int16)) == "32767"
@test base(3,typemin(Int16)) == "-1122221122"
@test base(3,typemax(Int16)) == "1122221121"
@test base(12,typemin(Int16)) == "-16b68"
@test base(12,typemax(Int16)) == "16b67"
@test bin(typemin(Int32)) == "-1"*"0"^31
@test bin(typemax(Int32)) == "1"^31
@test oct(typemin(Int32)) == "-20000000000"
@test oct(typemax(Int32)) == "17777777777"
@test dec(typemin(Int32)) == "-2147483648"
@test dec(typemax(Int32)) == "2147483647"
@test hex(typemin(Int32)) == "-80000000"
@test hex(typemax(Int32)) == "7fffffff"
@test string(typemin(Int32)) == "-2147483648"
@test string(typemax(Int32)) == "2147483647"
@test base(3,typemin(Int32)) == "-12112122212110202102"
@test base(3,typemax(Int32)) == "12112122212110202101"
@test base(12,typemin(Int32)) == "-4bb2308a8"
@test base(12,typemax(Int32)) == "4bb2308a7"
@test bin(typemin(Int64)) == "-1"*"0"^63
@test bin(typemax(Int64)) == "1"^63
@test oct(typemin(Int64)) == "-1000000000000000000000"
@test oct(typemax(Int64)) == "777777777777777777777"
@test dec(typemin(Int64)) == "-9223372036854775808"
@test dec(typemax(Int64)) == "9223372036854775807"
@test hex(typemin(Int64)) == "-8000000000000000"
@test hex(typemax(Int64)) == "7fffffffffffffff"
@test string(typemin(Int64)) == "-9223372036854775808"
@test string(typemax(Int64)) == "9223372036854775807"
@test base(3,typemin(Int64)) == "-2021110011022210012102010021220101220222"
@test base(3,typemax(Int64)) == "2021110011022210012102010021220101220221"
@test base(12,typemin(Int64)) == "-41a792678515120368"
@test base(12,typemax(Int64)) == "41a792678515120367"
@test bin(typemin(Int128)) == "-1"*"0"^127
@test bin(typemax(Int128)) == "1"^127
@test oct(typemin(Int128)) == "-2000000000000000000000000000000000000000000"
@test oct(typemax(Int128)) == "1777777777777777777777777777777777777777777"
@test hex(typemin(Int128)) == "-80000000000000000000000000000000"
@test hex(typemax(Int128)) == "7fffffffffffffffffffffffffffffff"
@test dec(typemin(Int128)) == "-170141183460469231731687303715884105728"
@test dec(typemax(Int128)) == "170141183460469231731687303715884105727"
@test string(typemin(Int128)) == "-170141183460469231731687303715884105728"
@test string(typemax(Int128)) == "170141183460469231731687303715884105727"
@test base(3,typemin(Int128)) ==
"-101100201022001010121000102002120122110122221010202000122201220121120010200022002"
@test base(3,typemax(Int128)) ==
"101100201022001010121000102002120122110122221010202000122201220121120010200022001"
@test base(12,typemin(Int128)) == "-2a695925806818735399a37a20a31b3534a8"
@test base(12,typemax(Int128)) == "2a695925806818735399a37a20a31b3534a7"
@test hex2num("3ff0000000000000") == 1.
@test hex2num("bff0000000000000") == -1.
@test hex2num("4000000000000000") == 2.
@test hex2num("7ff0000000000000") == Inf
@test hex2num("fff0000000000000") == -Inf
@test isnan(hex2num("7ff8000000000000"))
@test isnan(hex2num("fff8000000000000"))
@test hex2num("3f800000") == 1.0f0
@test hex2num("bf800000") == -1.0f0
@test hex2num("7f800000") == Inf32
@test hex2num("ff800000") == -Inf32
@test isnan(hex2num("7fc00000"))
@test isnan(hex2num("ffc00000"))
# floating-point printing
@test repr(1.0) == "1.0"
@test repr(-1.0) == "-1.0"
@test repr(0.0) == "0.0"
@test repr(-0.0) == "-0.0"
@test repr(0.1) == "0.1"
@test repr(0.2) == "0.2"
@test repr(0.3) == "0.3"
@test repr(0.1+0.2) != "0.3"
@test repr(Inf) == "Inf"
@test repr(-Inf) == "-Inf"
@test repr(NaN) == "NaN"
@test repr(-NaN) == "NaN"
@test repr(Float64(pi)) == "3.141592653589793"
# issue 6608
@test sprint(showcompact, 666666.6) == "6.66667e5"
@test sprint(showcompact, 666666.049) == "666666.0"
@test sprint(showcompact, 666665.951) == "666666.0"
@test sprint(showcompact, 66.66666) == "66.6667"
@test sprint(showcompact, -666666.6) == "-6.66667e5"
@test sprint(showcompact, -666666.049) == "-666666.0"
@test sprint(showcompact, -666665.951) == "-666666.0"
@test sprint(showcompact, -66.66666) == "-66.6667"
@test repr(1.0f0) == "1.0f0"
@test repr(-1.0f0) == "-1.0f0"
@test repr(0.0f0) == "0.0f0"
@test repr(-0.0f0) == "-0.0f0"
@test repr(0.1f0) == "0.1f0"
@test repr(0.2f0) == "0.2f0"
@test repr(0.3f0) == "0.3f0"
@test repr(0.1f0+0.2f0) == "0.3f0"
@test repr(Inf32) == "Inf32"
@test repr(-Inf32) == "-Inf32"
@test repr(NaN32) == "NaN32"
@test repr(-NaN32) == "NaN32"
@test repr(Float32(pi)) == "3.1415927f0"
# signs
@test sign(1) == 1
@test sign(-1) == -1
@test sign(0) == 0
@test sign(1.0) == 1
@test sign(-1.0) == -1
@test sign(0.0) == 0
@test sign(-0.0) == 0
@test sign( 1.0/0.0) == 1
@test sign(-1.0/0.0) == -1
@test sign(Inf) == 1
@test sign(-Inf) == -1
@test isequal(sign(NaN), NaN)
@test isequal(sign(-NaN), NaN)
@test sign(2//3) == 1
@test sign(-2//3) == -1
@test sign(0//1) == 0
@test sign(-0//1) == 0
@test sign(1//0) == 1
@test sign(-1//0) == -1
@test isa(sign(2//3), Rational{Int})
@test isa(2//3 + 2//3im, Complex{Rational{Int}})
@test isa(sign(2//3 + 2//3im), Complex{Float64})
@test sign(one(UInt)) == 1
@test sign(zero(UInt)) == 0
@test signbit(1) == 0
@test signbit(0) == 0
@test signbit(-1) == 1
@test signbit(1.0) == 0
@test signbit(0.0) == 0
@test signbit(-0.0) == 1
@test signbit(-1.0) == 1
@test signbit(1.0/0.0) == 0
@test signbit(-1.0/0.0) == 1
@test signbit(Inf) == 0
@test signbit(-Inf) == 1
@test signbit(NaN) == 0
@test signbit(-NaN) == 1
@test signbit(2//3) == 0
@test signbit(-2//3) == 1
@test signbit(0//1) == 0
@test signbit(-0//1) == 0
@test signbit(1//0) == 0
@test signbit(-1//0) == 1
@test copysign(big(1.0),big(-2.0)) == big(-1.0)
#copysign
@test copysign(-1,1) == 1
@test copysign(1,-1) == -1
@test copysign(-1,1.0) == 1
@test copysign(1,-1.0) == -1
@test copysign(-1,1//2) == 1
@test copysign(1,-1//2) == -1
@test copysign(1.0,-1) == -1.0
@test copysign(-1.0,1) == 1.0
@test copysign(1.0,-1.0) == -1.0
@test copysign(-1.0,1.0) == 1.0
@test copysign(1.0,-1//2) == -1.0
@test copysign(-1.0,1//2) == 1.0
@test copysign(1//2,-1) == -1//2
@test copysign(-1//2,1) == 1//2
@test copysign(1//2,-1//2) == -1//2
@test copysign(-1//2,1//2) == 1//2
@test copysign(1//2,-1.0) == -1//2
@test copysign(-1//2,1.0) == 1//2
# verify type stability with integer (x is negative)
@test eltype(copysign(-1,1)) <: Integer
@test eltype(copysign(-1,BigInt(1))) <: Integer
@test eltype(copysign(-1,1.0)) <: Integer
@test eltype(copysign(-1,1//2)) <: Integer
@test eltype(copysign(-BigInt(1),1)) <: Integer
@test eltype(copysign(-BigInt(1),1.0)) <: Integer
@test eltype(copysign(-BigInt(1),1//2)) <: Integer
@test eltype(copysign(-BigInt(1),BigInt(1))) <: Integer
@test eltype(copysign(-1,-1)) <: Integer
@test eltype(copysign(-1,-BigInt(1))) <: Integer
@test eltype(copysign(-1,-1.0)) <: Integer
@test eltype(copysign(-1,-1//2)) <: Integer
@test eltype(copysign(-BigInt(1),-1)) <: Integer
@test eltype(copysign(-BigInt(1),-1.0)) <: Integer
@test eltype(copysign(-BigInt(1),-1//2)) <: Integer
@test eltype(copysign(-BigInt(1),-BigInt(1))) <: Integer
# verify type stability with integer (x is positive)
@test eltype(copysign(1,1)) <: Integer
@test eltype(copysign(1,BigInt(1))) <: Integer
@test eltype(copysign(1,1.0)) <: Integer
@test eltype(copysign(1,1//2)) <: Integer
@test eltype(copysign(BigInt(1),1)) <: Integer
@test eltype(copysign(BigInt(1),1.0)) <: Integer
@test eltype(copysign(BigInt(1),1//2)) <: Integer
@test eltype(copysign(BigInt(1),BigInt(1))) <: Integer
@test eltype(copysign(1,-1)) <: Integer
@test eltype(copysign(1,-BigInt(1))) <: Integer
@test eltype(copysign(1,-1.0)) <: Integer
@test eltype(copysign(1,-1//2)) <: Integer
@test eltype(copysign(BigInt(1),-1)) <: Integer
@test eltype(copysign(BigInt(1),-1.0)) <: Integer
@test eltype(copysign(BigInt(1),-1//2)) <: Integer
@test eltype(copysign(BigInt(1),-BigInt(1))) <: Integer
# verify type stability with real (x is negative)
@test eltype(copysign(-1.0,1)) <: Real
@test eltype(copysign(-1.0,BigInt(1))) <: Real
@test eltype(copysign(-1.0,1.0)) <: Real
@test eltype(copysign(-1.0,1//2)) <: Real
@test eltype(copysign(-1.0,-1)) <: Real
@test eltype(copysign(-1.0,-BigInt(1))) <: Real
@test eltype(copysign(-1.0,-1.0)) <: Real
@test eltype(copysign(-1.0,-1//2)) <: Real
# Verify type stability with real (x is positive)
@test eltype(copysign(1.0,1)) <: Real
@test eltype(copysign(1.0,BigInt(1))) <: Real
@test eltype(copysign(1.0,1.0)) <: Real
@test eltype(copysign(1.0,1//2)) <: Real
@test eltype(copysign(1.0,-1)) <: Real
@test eltype(copysign(1.0,-BigInt(1))) <: Real
@test eltype(copysign(1.0,-1.0)) <: Real
@test eltype(copysign(1.0,-1//2)) <: Real
# Verify type stability with rational (x is negative)
@test eltype(copysign(-1//2,1)) <: Rational
@test eltype(copysign(-1//2,BigInt(1))) <: Rational
@test eltype(copysign(-1//2,1.0)) <: Rational
@test eltype(copysign(-1//2,1//2)) <: Rational
@test eltype(copysign(-1//2,-1)) <: Rational
@test eltype(copysign(-1//2,-BigInt(1))) <: Rational
@test eltype(copysign(-1//2,-1.0)) <: Rational
@test eltype(copysign(-1//2,-1//2)) <: Rational
# Verify type stability with rational (x is positive)
@test eltype(copysign(-1//2,1)) <: Rational
@test eltype(copysign(-1//2,BigInt(1))) <: Rational
@test eltype(copysign(-1//2,1.0)) <: Rational
@test eltype(copysign(-1//2,1//2)) <: Rational
@test eltype(copysign(-1//2,-1)) <: Rational
@test eltype(copysign(-1//2,-BigInt(1))) <: Rational
@test eltype(copysign(-1//2,-1.0)) <: Rational
@test eltype(copysign(-1//2,-1//2)) <: Rational
# test x = NaN
@test isnan(copysign(0/0,1))
@test isnan(copysign(0/0,-1))
# test x = Inf
@test isinf(copysign(1/0,1))
@test isinf(copysign(1/0,-1))
@test isnan(1) == false
@test isnan(1.0) == false
@test isnan(-1.0) == false
@test isnan(Inf) == false
@test isnan(-Inf) == false
@test isnan(NaN) == true
@test isnan(1//2) == false
@test isnan(-2//3) == false
@test isnan(5//0) == false
@test isnan(-3//0) == false
@test isinf(1) == false
@test isinf(1.0) == false
@test isinf(-1.0) == false
@test isinf(Inf) == true
@test isinf(-Inf) == true
@test isinf(NaN) == false
@test isinf(1//2) == false
@test isinf(-2//3) == false
@test isinf(5//0) == true
@test isinf(-3//0) == true
@test isfinite(1) == true
@test isfinite(1.0) == true
@test isfinite(-1.0) == true
@test isfinite(Inf) == false
@test isfinite(-Inf) == false
@test isfinite(NaN) == false
@test isfinite(1//2) == true
@test isfinite(-2//3) == true
@test isfinite(5//0) == false
@test isfinite(-3//0) == false
@test isfinite(pi) == true
@test isequal(-Inf,-Inf)
@test isequal(-1.0,-1.0)
@test isequal(-0.0,-0.0)
@test isequal(+0.0,+0.0)
@test isequal(+1.0,+1.0)
@test isequal(+Inf,+Inf)
@test isequal(-NaN,-NaN)
@test isequal(-NaN,+NaN)
@test isequal(+NaN,-NaN)
@test isequal(+NaN,+NaN)
@test !isequal(-Inf,+Inf)
@test !isequal(-1.0,+1.0)
@test !isequal(-0.0,+0.0)
@test !isequal(+0.0,-0.0)
@test !isequal(+1.0,-1.0)
@test !isequal(+Inf,-Inf)
@test isequal(-0.0f0,-0.0)
@test isequal( 0.0f0, 0.0)
@test !isequal(-0.0f0, 0.0)
@test !isequal(0.0f0 ,-0.0)
@test !isless(-Inf,-Inf)
@test isless(-Inf,-1.0)
@test isless(-Inf,-0.0)
@test isless(-Inf,+0.0)
@test isless(-Inf,+1.0)
@test isless(-Inf,+Inf)
@test isless(-Inf,-NaN)
@test isless(-Inf,+NaN)
@test !isless(-1.0,-Inf)
@test !isless(-1.0,-1.0)
@test isless(-1.0,-0.0)
@test isless(-1.0,+0.0)
@test isless(-1.0,+1.0)
@test isless(-1.0,+Inf)
@test isless(-1.0,-NaN)
@test isless(-1.0,+NaN)
@test !isless(-0.0,-Inf)
@test !isless(-0.0,-1.0)
@test !isless(-0.0,-0.0)
@test isless(-0.0,+0.0)
@test isless(-0.0,+1.0)
@test isless(-0.0,+Inf)
@test isless(-0.0,-NaN)
@test isless(-0.0,+NaN)
@test !isless(+0.0,-Inf)
@test !isless(+0.0,-1.0)
@test !isless(+0.0,-0.0)
@test !isless(+0.0,+0.0)
@test isless(+0.0,+1.0)
@test isless(+0.0,+Inf)
@test isless(+0.0,-NaN)
@test isless(+0.0,+NaN)
@test !isless(+1.0,-Inf)
@test !isless(+1.0,-1.0)
@test !isless(+1.0,-0.0)
@test !isless(+1.0,+0.0)
@test !isless(+1.0,+1.0)
@test isless(+1.0,+Inf)
@test isless(+1.0,-NaN)
@test isless(+1.0,+NaN)
@test !isless(+Inf,-Inf)
@test !isless(+Inf,-1.0)
@test !isless(+Inf,-0.0)
@test !isless(+Inf,+0.0)
@test !isless(+Inf,+1.0)
@test !isless(+Inf,+Inf)
@test isless(+Inf,-NaN)
@test isless(+Inf,+NaN)
@test !isless(-NaN,-Inf)
@test !isless(-NaN,-1.0)
@test !isless(-NaN,-0.0)
@test !isless(-NaN,+0.0)
@test !isless(-NaN,+1.0)
@test !isless(-NaN,+Inf)
@test !isless(-NaN,-NaN)
@test !isless(-NaN,+NaN)
@test !isless(+NaN,-Inf)
@test !isless(+NaN,-1.0)
@test !isless(+NaN,-0.0)
@test !isless(+NaN,+0.0)
@test !isless(+NaN,+1.0)
@test !isless(+NaN,+Inf)
@test !isless(+NaN,-NaN)
@test !isless(+NaN,+NaN)
@test isequal( 0, 0.0)
@test isequal( 0.0, 0)
@test !isequal( 0,-0.0)
@test !isequal(-0.0, 0)
@test isless(-0.0, 0)
@test !isless( 0,-0.0)
@test isless(-0.0, 0.0f0)
@test lexcmp(-0.0, 0.0f0) == -1
@test lexcmp(0.0, -0.0f0) == 1
@test lexcmp(NaN, 1) == 1
@test lexcmp(1, NaN) == -1
@test lexcmp(NaN, NaN) == 0
for x=-5:5, y=-5:5
@test (x==y)==(Float64(x)==Int64(y))
@test (x!=y)==(Float64(x)!=Int64(y))
@test (x< y)==(Float64(x)< Int64(y))
@test (x> y)==(Float64(x)> Int64(y))
@test (x<=y)==(Float64(x)<=Int64(y))
@test (x>=y)==(Float64(x)>=Int64(y))
@test (x==y)==(Int64(x)==Float64(y))
@test (x!=y)==(Int64(x)!=Float64(y))
@test (x< y)==(Int64(x)< Float64(y))
@test (x> y)==(Int64(x)> Float64(y))
@test (x<=y)==(Int64(x)<=Float64(y))
@test (x>=y)==(Int64(x)>=Float64(y))
if x >= 0
@test (x==y)==(UInt64(x)==Float64(y))
@test (x!=y)==(UInt64(x)!=Float64(y))
@test (x< y)==(UInt64(x)< Float64(y))
@test (x> y)==(UInt64(x)> Float64(y))
@test (x<=y)==(UInt64(x)<=Float64(y))
@test (x>=y)==(UInt64(x)>=Float64(y))
end
if y >= 0
@test (x==y)==(Float64(x)==UInt64(y))
@test (x!=y)==(Float64(x)!=UInt64(y))
@test (x< y)==(Float64(x)< UInt64(y))
@test (x> y)==(Float64(x)> UInt64(y))
@test (x<=y)==(Float64(x)<=UInt64(y))
@test (x>=y)==(Float64(x)>=UInt64(y))
end
end
function _cmp_(x::Union{Int64,UInt64}, y::Float64)
if x==Int64(2)^53-2 && y==2.0^53-2; return 0; end
if x==Int64(2)^53-2 && y==2.0^53-1; return -1; end
if x==Int64(2)^53-2 && y==2.0^53 ; return -1; end
if x==Int64(2)^53-2 && y==2.0^53+2; return -1; end
if x==Int64(2)^53-2 && y==2.0^53+3; return -1; end
if x==Int64(2)^53-2 && y==2.0^53+4; return -1; end
if x==Int64(2)^53-1 && y==2.0^53-2; return +1; end
if x==Int64(2)^53-1 && y==2.0^53-1; return 0; end
if x==Int64(2)^53-1 && y==2.0^53 ; return -1; end
if x==Int64(2)^53-1 && y==2.0^53+2; return -1; end
if x==Int64(2)^53-1 && y==2.0^53+3; return -1; end
if x==Int64(2)^53-1 && y==2.0^53+4; return -1; end
if x==Int64(2)^53 && y==2.0^53-2; return +1; end
if x==Int64(2)^53 && y==2.0^53-1; return +1; end
if x==Int64(2)^53 && y==2.0^53 ; return 0; end
if x==Int64(2)^53 && y==2.0^53+2; return -1; end
if x==Int64(2)^53 && y==2.0^53+4; return -1; end
if x==Int64(2)^53+1 && y==2.0^53-2; return +1; end
if x==Int64(2)^53+1 && y==2.0^53-1; return +1; end
if x==Int64(2)^53+1 && y==2.0^53 ; return +1; end
if x==Int64(2)^53+1 && y==2.0^53+2; return -1; end
if x==Int64(2)^53+1 && y==2.0^53+4; return -1; end
if x==Int64(2)^53+2 && y==2.0^53-2; return +1; end
if x==Int64(2)^53+2 && y==2.0^53-1; return +1; end
if x==Int64(2)^53+2 && y==2.0^53 ; return +1; end
if x==Int64(2)^53+2 && y==2.0^53+2; return 0; end
if x==Int64(2)^53+2 && y==2.0^53+4; return -1; end
if x==Int64(2)^53+3 && y==2.0^53-2; return +1; end
if x==Int64(2)^53+3 && y==2.0^53-1; return +1; end
if x==Int64(2)^53+3 && y==2.0^53 ; return +1; end
if x==Int64(2)^53+3 && y==2.0^53+2; return +1; end
if x==Int64(2)^53+3 && y==2.0^53+4; return -1; end
if x==Int64(2)^53+4 && y==2.0^53-2; return +1; end
if x==Int64(2)^53+4 && y==2.0^53-1; return +1; end
if x==Int64(2)^53+4 && y==2.0^53 ; return +1; end
if x==Int64(2)^53+4 && y==2.0^53+2; return +1; end
if x==Int64(2)^53+4 && y==2.0^53+4; return 0; end
if x==Int64(2)^53+5 && y==2.0^53-2; return +1; end
if x==Int64(2)^53+5 && y==2.0^53-1; return +1; end
if x==Int64(2)^53+5 && y==2.0^53 ; return +1; end
if x==Int64(2)^53+5 && y==2.0^53+2; return +1; end
if x==Int64(2)^53+5 && y==2.0^53+4; return +1; end
error("invalid: _cmp_($x,$y)")
end
for x=Int64(2)^53-2:Int64(2)^53+5,
y=[2.0^53-2 2.0^53-1 2.0^53 2.0^53+2 2.0^53+4]
u = UInt64(x)
@test y == Float64(trunc(Int64,y))
@test (x==y)==(y==x)
@test (x!=y)==!(x==y)
@test (-x==-y)==(-y==-x)
@test (-x!=-y)==!(-x==-y)
@test (x<y)==(x<=y)&(x!=y)
@test (x<=y)==(x<y)|(x==y)
@test (x==y)==(x<=y)&!(x<y)
@test -x != x
@test -y != y
@test -x != y
@test -y != x
@test -x < x
@test -y < y
@test -x < y
@test -y < x
@test -x <= x
@test -y <= y
@test -x <= y
@test -y <= x
@test -y != u
@test -y < u
@test -y <= u
c = _cmp_(x,y)
if c < 0
@test !(x == y)
@test (x < y)
@test !(y < x)
@test (x <= y)
@test !(y <= x)
@test !(u == y)
@test (u < y)
@test !(y < u)
@test (u <= y)
@test !(y <= u)
@test !(-x == -y)
@test !(-x < -y)
@test (-y < -x)
@test !(-x <= -y)
@test (-y <= -x)
elseif c > 0
@test !(x == y)
@test !(x < y)
@test (y < x)
@test !(x <= y)
@test (y <= x)
@test !(u == y)
@test !(u < y)
@test (y < u)
@test !(u <= y)
@test (y <= u)
@test !(-x == -y)
@test (-x < -y)
@test !(-y < -x)
@test (-x <= -y)
@test !(-y <= -x)
else
@test (x == y)
@test !(x < y)
@test !(y < x)
@test (x <= y)
@test (y <= x)
@test (u == y)
@test !(u < y)
@test !(y < u)
@test (u <= y)
@test (y <= u)
@test (-x == -y)
@test !(-x < -y)
@test !(-y < -x)
@test (-x <= -y)
@test (-y <= -x)
end
end
@test Int64(2)^62-1 != 2.0^62
@test Int64(2)^62 == 2.0^62
@test Int64(2)^62+1 != 2.0^62
@test 2.0^62 != Int64(2)^62-1
@test 2.0^62 == Int64(2)^62
@test 2.0^62 != Int64(2)^62+1
@test typemax(Int64) != +2.0^63
@test typemin(Int64) == -2.0^63
@test typemin(Int64)+1 != -2.0^63
@test UInt64(2)^60-1 != 2.0^60
@test UInt64(2)^60 == 2.0^60
@test UInt64(2)^60+1 != 2.0^60
@test 2.0^60 != UInt64(2)^60-1
@test 2.0^60 == UInt64(2)^60
@test 2.0^60 != UInt64(2)^60+1
@test UInt64(2)^63-1 != 2.0^63
@test UInt64(2)^63 == 2.0^63
@test UInt64(2)^63+1 != 2.0^63
@test 2.0^63 != UInt64(2)^63-1
@test 2.0^63 == UInt64(2)^63
@test 2.0^63 != UInt64(2)^63+1
@test typemax(UInt64) != 2.0^64
# issue #9085
f9085() = typemax(UInt64) != 2.0^64
@test f9085()
@test typemax(UInt64) < Float64(typemax(UInt64))
@test typemax(Int64) < Float64(typemax(Int64))
@test typemax(UInt64) <= Float64(typemax(UInt64))
@test typemax(Int64) <= Float64(typemax(Int64))
@test Float64(typemax(UInt64)) > typemax(UInt64)
@test Float64(typemax(Int64)) > typemax(Int64)
@test Float64(typemax(UInt64)) >= typemax(UInt64)
@test Float64(typemax(Int64)) >= typemax(Int64)
@test Float64(Int128(0)) == 0.0
@test Float32(Int128(0)) == 0.0f0
@test Float64(Int128(-1)) == -1.0
@test Float32(Int128(-1)) == -1.0f0
@test Float64(Int128(3)) == 3.0
@test Float32(Int128(3)) == 3.0f0
@test Float64(UInt128(10121)) == 10121.0
@test Float32(UInt128(10121)) == 10121.0f0
@test Float64(typemin(Int128)) == -2.0^127
@test Float32(typemin(Int128)) == -2.0f0^127
@test Float64(typemax(Int128)) == 2.0^127
@test Float32(typemax(Int128)) == 2.0f0^127
@test Float64(typemin(UInt128)) == 0.0
@test Float32(typemin(UInt128)) == 0.0f0
@test Float64(typemax(UInt128)) == 2.0^128
@test Float32(typemax(UInt128)) == 2.0f0^128
# check for double rounding in conversion
@test Float64(10633823966279328163822077199654060032) == 1.0633823966279327e37 #0x1p123
@test Float64(10633823966279328163822077199654060033) == 1.063382396627933e37 #nextfloat(0x1p123)
@test Float64(-10633823966279328163822077199654060032) == -1.0633823966279327e37
@test Float64(-10633823966279328163822077199654060033) == -1.063382396627933e37
# check Float vs Int128 comparisons
@test Int128(1e30) == 1e30
@test Int128(1e30)+1 > 1e30
@test Int128(-2.0^127) == typemin(Int128)
@test Float64(UInt128(3.7e19)) == 3.7e19
@test Float64(UInt128(3.7e30)) == 3.7e30
@test !(NaN <= 1)
@test !(NaN >= 1)
@test !(NaN < 1)
@test !(NaN > 1)
@test !(1 <= NaN)
@test !(1 >= NaN)
@test !(1 < NaN)
@test !(1 > NaN)
@test 1//1 == 1
@test 2//2 == 1
@test 1//1 == 1//1
@test 2//2 == 1//1
@test 2//4 == 3//6
@test 1//2 + 1//2 == 1
@test (-1)//3 == -(1//3)
@test 1//2 + 3//4 == 5//4
@test 1//3 * 3//4 == 1//4
@test 1//2 / 3//4 == 2//3
@test 1//0 == 1//0
@test 5//0 == 1//0
@test -1//0 == -1//0
@test -7//0 == -1//0
@test_throws OverflowError -(0x01//0x0f)
@test_throws OverflowError -(typemin(Int)//1)
@test_throws OverflowError (typemax(Int)//3) + 1
@test_throws OverflowError (typemax(Int)//3) * 2
@test (typemax(Int)//1) * (1//typemax(Int)) == 1
@test (typemax(Int)//1) / (typemax(Int)//1) == 1
@test (1//typemax(Int)) / (1//typemax(Int)) == 1
@test_throws OverflowError (1//2)^63
@test @inferred(rationalize(Int, 3.0, 0.0)) === 3//1
@test @inferred(rationalize(Int, 3.0, 0)) === 3//1
@test_throws ArgumentError rationalize(Int, big(3.0), -1.)
for a = -5:5, b = -5:5
if a == b == 0; continue; end
if ispow2(b)
@test a//b == a/b
@test convert(Rational,a/b) == a//b
end
@test rationalize(a/b) == a//b
@test a//b == a//b
if b == 0
@test_throws DivideError round(Integer,a//b) == round(Integer,a/b)
else
@test round(Integer,a//b) == round(Integer,a/b)
end
for c = -5:5
@test (a//b == c) == (a/b == c)
@test (a//b != c) == (a/b != c)
@test (a//b <= c) == (a/b <= c)
@test (a//b < c) == (a/b < c)
@test (a//b >= c) == (a/b >= c)
@test (a//b > c) == (a/b > c)
for d = -5:5
if c == d == 0; continue; end
@test (a//b == c//d) == (a/b == c/d)
@test (a//b != c//d) == (a/b != c/d)
@test (a//b <= c//d) == (a/b <= c/d)
@test (a//b < c//d) == (a/b < c/d)
@test (a//b >= c//d) == (a/b >= c/d)
@test (a//b > c//d) == (a/b > c/d)
end
end
end
@test 0.5 == 1//2
@test 0.1 != 1//10
@test 0.1 == 3602879701896397//36028797018963968
@test Inf == 1//0 == 2//0 == typemax(Int)//0
@test -Inf == -1//0 == -2//0 == -typemax(Int)//0
@test realmin() != 1//(BigInt(2)^1022+1)
@test realmin() == 1//(BigInt(2)^1022)
@test realmin() != 1//(BigInt(2)^1022-1)
@test realmin()/2 != 1//(BigInt(2)^1023+1)
@test realmin()/2 == 1//(BigInt(2)^1023)
@test realmin()/2 != 1//(BigInt(2)^1023-1)
@test nextfloat(0.0) != 1//(BigInt(2)^1074+1)
@test nextfloat(0.0) == 1//(BigInt(2)^1074)
@test nextfloat(0.0) != 1//(BigInt(2)^1074-1)
@test 1/3 < 1//3
@test !(1//3 < 1/3)
@test -1/3 < 1//3
@test -1/3 > -1//3
@test 1/3 > -1//3
@test 1/5 > 1//5
@test 1//3 < Inf
@test 0//1 < Inf
@test 1//0 == Inf
@test -1//0 == -Inf
@test -1//0 != Inf
@test 1//0 != -Inf
@test !(1//0 < Inf)
@test !(1//3 < NaN)
@test !(1//3 == NaN)
@test !(1//3 > NaN)
@test Float64(pi,RoundDown) < pi
@test Float64(pi,RoundUp) > pi
@test !(Float64(pi,RoundDown) > pi)
@test !(Float64(pi,RoundUp) < pi)
@test Float64(pi,RoundDown) <= pi
@test Float64(pi,RoundUp) >= pi
@test Float64(pi,RoundDown) != pi
@test Float64(pi,RoundUp) != pi
@test Float32(pi,RoundDown) < pi
@test Float32(pi,RoundUp) > pi
@test !(Float32(pi,RoundDown) > pi)
@test !(Float32(pi,RoundUp) < pi)
# issue #6365
for T in (Float32, Float64)
for i = 9007199254740992:9007199254740996
@test T(i) == T(BigFloat(i))
@test T(-i) == T(BigFloat(-i))
for r in (RoundNearest,RoundUp,RoundDown,RoundToZero)
@test T(i,r) == T(BigFloat(i),r)
@test T(-i,r) == T(BigFloat(-i),r)
end
end
end
@test prevfloat(big(pi)) < pi
@test nextfloat(big(pi)) > pi
@test !(prevfloat(big(pi)) > pi)
@test !(nextfloat(big(pi)) < pi)
@test 2646693125139304345//842468587426513207 < pi
@test !(2646693125139304345//842468587426513207 > pi)
@test 2646693125139304345//842468587426513207 != pi
@test sqrt(2) == 1.4142135623730951
@test 1+1.5 == 2.5
@test 1.5+1 == 2.5
@test 1+1.5+2 == 4.5
@test isa(convert(Complex{Int16},1), Complex{Int16})
@test Complex(1,2)+1 == Complex(2,2)
@test Complex(1,2)+1.5 == Complex(2.5,2.0)
@test 1/Complex(2,2) == Complex(.25,-.25)
@test Complex(1.5,1.0) + 1//2 == Complex(2.0,1.0)
@test real(Complex(1//2,2//3)) == 1//2
@test imag(Complex(1//2,2//3)) == 2//3
@test Complex(1,2) + 1//2 == Complex(3//2,2//1)
@test Complex(1,2) + 1//2 * 0.5 == Complex(1.25,2.0)
@test (Complex(1,2) + 1//2) * 0.5 == Complex(0.75,1.0)
@test (Complex(1,2)/Complex(2.5,3.0))*Complex(2.5,3.0) Complex(1,2)
@test 0.7 < real(sqrt(Complex(0,1))) < 0.707107
for T in Base.BitSigned_types
@test abs(typemin(T)) == -typemin(T)
#for x in (typemin(T),convert(T,-1),zero(T),one(T),typemax(T))
# @test signed(unsigned(x)) == x
#end
end
#for T in (UInt8,UInt16,UInt32,UInt64,UInt128)
# x in (typemin(T),one(T),typemax(T))
# @test unsigned(signed(x)) == x
#end
for S = Base.BitSigned64_types,
U = Base.BitUnsigned64_types
@test !(-one(S) == typemax(U))
@test -one(S) != typemax(U)
@test -one(S) < typemax(U)
@test !(typemax(U) <= -one(S))
end
# check type of constructed rationals
int_types = Base.BitInteger64_types
for N = int_types, D = int_types
T = promote_type(N,D)
@test typeof(convert(N,2)//convert(D,3)) <: Rational{T}
end
# issue #7564
@test typeof(convert(Rational{Integer},1)) === Rational{Integer}
# check type of constructed complexes
real_types = [Base.BitInteger64_types...,
[Rational{T} for T in Base.BitInteger64_types]...,
Float32, Float64]
for A = real_types, B = real_types
T = promote_type(A,B)
@test typeof(Complex(convert(A,2),convert(B,3))) <: Complex{T}
end
# comparison should fail on complex
@test_throws MethodError complex(1,2) > 0
@test_throws MethodError complex(1,2) > complex(0,0)
# div, fld, cld, rem, mod
for yr = Any[
1:6,
0.25:0.25:6.0,
1//4:1//4:6//1
], xr = Any[
0:6,
0.0:0.25:6.0,
0//1:1//4:6//1
]
for y = yr, x = xr
# check basic div functionality
if 0 <= x < 1y
@test div(+x,+y) == 0
@test div(+x,-y) == 0
@test div(-x,+y) == 0
@test div(-x,-y) == 0
end
if 1y <= x < 2y
@test div(+x,+y) == +1
@test div(+x,-y) == -1
@test div(-x,+y) == -1
@test div(-x,-y) == +1
end
if 2y <= x < 3y
@test div(+x,+y) == +2
@test div(+x,-y) == -2
@test div(-x,+y) == -2
@test div(-x,-y) == +2
end
# check basic fld functionality
if 0 == x
@test fld(+x,+y) == 0
@test fld(+x,-y) == 0
@test fld(-x,+y) == 0
@test fld(-x,-y) == 0
end
if 0 < x < 1y
@test fld(+x,+y) == +0
@test fld(+x,-y) == -1
@test fld(-x,+y) == -1
@test fld(-x,-y) == +0
end
if 1y == x
@test fld(+x,+y) == +1
@test fld(+x,-y) == -1
@test fld(-x,+y) == -1
@test fld(-x,-y) == +1
end
if 1y < x < 2y
@test fld(+x,+y) == +1
@test fld(+x,-y) == -2
@test fld(-x,+y) == -2
@test fld(-x,-y) == +1
end
if 2y == x
@test fld(+x,+y) == +2
@test fld(+x,-y) == -2
@test fld(-x,+y) == -2
@test fld(-x,-y) == +2
end
if 2y < x < 3y
@test fld(+x,+y) == +2
@test fld(+x,-y) == -3
@test fld(-x,+y) == -3
@test fld(-x,-y) == +2
end
# check basic cld functionality
if 0 == x
@test cld(+x,+y) == 0
@test cld(+x,-y) == 0
@test cld(-x,+y) == 0
@test cld(-x,-y) == 0
end
if 0 < x < 1y
@test cld(+x,+y) == +1
@test cld(+x,-y) == +0
@test cld(-x,+y) == +0
@test cld(-x,-y) == +1
end
if 1y == x
@test cld(+x,+y) == +1
@test cld(+x,-y) == -1
@test cld(-x,+y) == -1
@test cld(-x,-y) == +1
end
if 1y < x < 2y
@test cld(+x,+y) == +2
@test cld(+x,-y) == -1
@test cld(-x,+y) == -1
@test cld(-x,-y) == +2
end
if 2y == x
@test cld(+x,+y) == +2
@test cld(+x,-y) == -2
@test cld(-x,+y) == -2
@test cld(-x,-y) == +2
end
if 2y < x < 3y
@test cld(+x,+y) == +3
@test cld(+x,-y) == -2
@test cld(-x,+y) == -2
@test cld(-x,-y) == +3
end
# check everything else in terms of div, fld, cld
d = div(x,y)
f = fld(x,y)
c = cld(x,y)
r = rem(x,y)
m = mod(x,y)
d2, r2 = divrem(x,y)
f2, m2 = fldmod(x,y)
t1 = isa(x,Rational) && isa(y,Rational) ?
promote_type(typeof(numerator(x)),typeof(numerator(y))) :
isa(x,Rational) ? promote_type(typeof(numerator(x)),typeof(y)) :
isa(y,Rational) ? promote_type(typeof(x),typeof(numerator(y))) :
promote_type(typeof(x),typeof(y))
t2 = promote_type(typeof(x),typeof(y))
@test typeof(d) <: t1
@test typeof(f) <: t1
@test typeof(c) <: t1
@test typeof(r) <: t2
@test typeof(m) <: t2
@test d == f
@test c == f + (m == 0 ? 0 : 1)
@test r == m
@test 0 <= r < y
@test x == y*d + r
@test typeof(d2) == typeof(d)
@test typeof(r2) == typeof(r)
@test typeof(f2) == typeof(f)
@test typeof(m2) == typeof(m)
@test d2 == d
@test r2 == r
@test f2 == f
@test m2 == m
for X=[-1,1], Y=[-1,1]
sx = X*x
sy = Y*y
sd = div(sx,sy)
sf = fld(sx,sy)
sc = cld(sx,sy)
sr = rem(sx,sy)
sm = mod(sx,sy)
sd2, sr2 = divrem(sx,sy)
sf2, sm2 = fldmod(sx,sy)
@test typeof(sd) <: t1
@test typeof(sf) <: t1
@test typeof(sc) <: t1
@test typeof(sr) <: t2
@test typeof(sm) <: t2
@test sx < 0 ? -y < sr <= 0 : 0 <= sr < +y
@test sy < 0 ? -y < sm <= 0 : 0 <= sm < +y
@test sx == sy*sd + sr
@test sx == sy*sf + sm
@test typeof(sd2) == typeof(sd)
@test typeof(sr2) == typeof(sr)
@test typeof(sf2) == typeof(sf)
@test typeof(sm2) == typeof(sm)
@test sd2 == sd
@test sr2 == sr
@test sf2 == sf
@test sm2 == sm
end
end
end
@test div(typemax(Int64) , 1) == 9223372036854775807
@test div(typemax(Int64) , 2) == 4611686018427387903
@test div(typemax(Int64) , 7) == 1317624576693539401
@test div(typemax(Int64) ,-1) == -9223372036854775807
@test div(typemax(Int64) ,-2) == -4611686018427387903
@test div(typemax(Int64) ,-7) == -1317624576693539401
@test div(typemax(Int64)-1, 1) == 9223372036854775806
@test div(typemax(Int64)-1, 2) == 4611686018427387903
@test div(typemax(Int64)-1, 7) == 1317624576693539400
@test div(typemax(Int64)-1,-1) == -9223372036854775806
@test div(typemax(Int64)-1,-2) == -4611686018427387903
@test div(typemax(Int64)-1,-7) == -1317624576693539400
@test div(typemax(Int64)-2, 1) == 9223372036854775805
@test div(typemax(Int64)-2, 2) == 4611686018427387902
@test div(typemax(Int64)-2, 7) == 1317624576693539400
@test div(typemax(Int64)-2,-1) == -9223372036854775805
@test div(typemax(Int64)-2,-2) == -4611686018427387902
@test div(typemax(Int64)-2,-7) == -1317624576693539400
@test div(typemin(Int64) , 1) == -9223372036854775807-1
@test div(typemin(Int64) , 2) == -4611686018427387904
@test div(typemin(Int64) , 7) == -1317624576693539401
@test div(typemin(Int64) ,-2) == 4611686018427387904
@test div(typemin(Int64) ,-7) == 1317624576693539401
@test div(typemin(Int64)+1, 1) == -9223372036854775807
@test div(typemin(Int64)+1, 2) == -4611686018427387903
@test div(typemin(Int64)+1, 7) == -1317624576693539401
@test div(typemin(Int64)+1,-1) == 9223372036854775807
@test div(typemin(Int64)+1,-2) == 4611686018427387903
@test div(typemin(Int64)+1,-7) == 1317624576693539401
@test div(typemin(Int64)+2, 1) == -9223372036854775806
@test div(typemin(Int64)+2, 2) == -4611686018427387903
@test div(typemin(Int64)+2, 7) == -1317624576693539400
@test div(typemin(Int64)+2,-1) == 9223372036854775806
@test div(typemin(Int64)+2,-2) == 4611686018427387903
@test div(typemin(Int64)+2,-7) == 1317624576693539400
@test div(typemin(Int64)+3, 1) == -9223372036854775805
@test div(typemin(Int64)+3, 2) == -4611686018427387902
@test div(typemin(Int64)+3, 7) == -1317624576693539400
@test div(typemin(Int64)+3,-1) == 9223372036854775805
@test div(typemin(Int64)+3,-2) == 4611686018427387902
@test div(typemin(Int64)+3,-7) == 1317624576693539400
@test fld(typemax(Int64) , 1) == 9223372036854775807
@test fld(typemax(Int64) , 2) == 4611686018427387903
@test fld(typemax(Int64) , 7) == 1317624576693539401
@test fld(typemax(Int64) ,-1) == -9223372036854775807
@test fld(typemax(Int64) ,-2) == -4611686018427387904
@test fld(typemax(Int64) ,-7) == -1317624576693539401
@test fld(typemax(Int64)-1, 1) == 9223372036854775806
@test fld(typemax(Int64)-1, 2) == 4611686018427387903
@test fld(typemax(Int64)-1, 7) == 1317624576693539400
@test fld(typemax(Int64)-1,-1) == -9223372036854775806
@test fld(typemax(Int64)-1,-2) == -4611686018427387903
@test fld(typemax(Int64)-1,-7) == -1317624576693539401
@test fld(typemax(Int64)-2, 1) == 9223372036854775805
@test fld(typemax(Int64)-2, 2) == 4611686018427387902
@test fld(typemax(Int64)-2, 7) == 1317624576693539400
@test fld(typemax(Int64)-2,-1) == -9223372036854775805
@test fld(typemax(Int64)-2,-2) == -4611686018427387903
@test fld(typemax(Int64)-2,-7) == -1317624576693539401
@test fld(typemin(Int64) , 1) == -9223372036854775807-1
@test fld(typemin(Int64) , 2) == -4611686018427387904
@test fld(typemin(Int64) , 7) == -1317624576693539402
@test fld(typemin(Int64) ,-2) == 4611686018427387904
@test fld(typemin(Int64) ,-7) == 1317624576693539401
@test fld(typemin(Int64)+1, 1) == -9223372036854775807
@test fld(typemin(Int64)+1, 2) == -4611686018427387904
@test fld(typemin(Int64)+1, 7) == -1317624576693539401
@test fld(typemin(Int64)+1,-1) == 9223372036854775807
@test fld(typemin(Int64)+1,-2) == 4611686018427387903
@test fld(typemin(Int64)+1,-7) == 1317624576693539401
@test fld(typemin(Int64)+2, 1) == -9223372036854775806
@test fld(typemin(Int64)+2, 2) == -4611686018427387903
@test fld(typemin(Int64)+2, 7) == -1317624576693539401
@test fld(typemin(Int64)+2,-1) == 9223372036854775806
@test fld(typemin(Int64)+2,-2) == 4611686018427387903
@test fld(typemin(Int64)+2,-7) == 1317624576693539400
@test fld(typemin(Int64)+3, 1) == -9223372036854775805
@test fld(typemin(Int64)+3, 2) == -4611686018427387903
@test fld(typemin(Int64)+3, 7) == -1317624576693539401
@test fld(typemin(Int64)+3,-1) == 9223372036854775805
@test fld(typemin(Int64)+3,-2) == 4611686018427387902
@test fld(typemin(Int64)+3,-7) == 1317624576693539400
@test cld(typemax(Int64) , 1) == 9223372036854775807
@test cld(typemax(Int64) , 2) == 4611686018427387904
@test cld(typemax(Int64) , 7) == 1317624576693539401
@test cld(typemax(Int64) ,-1) == -9223372036854775807
@test cld(typemax(Int64) ,-2) == -4611686018427387903
@test cld(typemax(Int64) ,-7) == -1317624576693539401
@test cld(typemax(Int64)-1, 1) == 9223372036854775806
@test cld(typemax(Int64)-1, 2) == 4611686018427387903
@test cld(typemax(Int64)-1, 7) == 1317624576693539401
@test cld(typemax(Int64)-1,-1) == -9223372036854775806
@test cld(typemax(Int64)-1,-2) == -4611686018427387903
@test cld(typemax(Int64)-1,-7) == -1317624576693539400
@test cld(typemax(Int64)-2, 1) == 9223372036854775805
@test cld(typemax(Int64)-2, 2) == 4611686018427387903
@test cld(typemax(Int64)-2, 7) == 1317624576693539401
@test cld(typemax(Int64)-2,-1) == -9223372036854775805
@test cld(typemax(Int64)-2,-2) == -4611686018427387902
@test cld(typemax(Int64)-2,-7) == -1317624576693539400
@test cld(typemin(Int64) , 1) == -9223372036854775807-1
@test cld(typemin(Int64) , 2) == -4611686018427387904
@test cld(typemin(Int64) , 7) == -1317624576693539401
@test cld(typemin(Int64) ,-2) == 4611686018427387904
@test cld(typemin(Int64) ,-7) == 1317624576693539402
@test cld(typemin(Int64)+1, 1) == -9223372036854775807
@test cld(typemin(Int64)+1, 2) == -4611686018427387903
@test cld(typemin(Int64)+1, 7) == -1317624576693539401
@test cld(typemin(Int64)+1,-1) == 9223372036854775807
@test cld(typemin(Int64)+1,-2) == 4611686018427387904
@test cld(typemin(Int64)+1,-7) == 1317624576693539401
@test cld(typemin(Int64)+2, 1) == -9223372036854775806
@test cld(typemin(Int64)+2, 2) == -4611686018427387903
@test cld(typemin(Int64)+2, 7) == -1317624576693539400
@test cld(typemin(Int64)+2,-1) == 9223372036854775806
@test cld(typemin(Int64)+2,-2) == 4611686018427387903
@test cld(typemin(Int64)+2,-7) == 1317624576693539401
@test cld(typemin(Int64)+3, 1) == -9223372036854775805
@test cld(typemin(Int64)+3, 2) == -4611686018427387902
@test cld(typemin(Int64)+3, 7) == -1317624576693539400
@test cld(typemin(Int64)+3,-1) == 9223372036854775805
@test cld(typemin(Int64)+3,-2) == 4611686018427387903
@test cld(typemin(Int64)+3,-7) == 1317624576693539401
for x=Any[typemin(Int64), -typemax(Int64), -typemax(Int64)+1, -typemax(Int64)+2,
typemax(Int64)-2, typemax(Int64)-1, typemax(Int64),
typemax(UInt64)-1, typemax(UInt64)-2, typemax(UInt64)],
y=[-7,-2,-1,1,2,7]
if x >= 0
@test div(unsigned(x),y) == unsigned(div(x,y))
@test fld(unsigned(x),y) == unsigned(fld(x,y))
@test cld(unsigned(x),y) == unsigned(cld(x,y))
end
if isa(x,Signed) && y >= 0
@test div(x,unsigned(y)) == div(x,y)
@test fld(x,unsigned(y)) == fld(x,y)
@test cld(x,unsigned(y)) == cld(x,y)
end
end
for x=0:5, y=1:5
@test div(UInt(x),UInt(y)) == div(x,y)
@test div(UInt(x),y) == div(x,y)
@test div(x,UInt(y)) == div(x,y)
@test div(UInt(x),-y) == reinterpret(UInt,div(x,-y))
@test div(-x,UInt(y)) == div(-x,y)
@test fld(UInt(x),UInt(y)) == fld(x,y)
@test fld(UInt(x),y) == fld(x,y)
@test fld(x,UInt(y)) == fld(x,y)
@test fld(UInt(x),-y) == reinterpret(UInt,fld(x,-y))
@test fld(-x,UInt(y)) == fld(-x,y)
@test cld(UInt(x),UInt(y)) == cld(x,y)
@test cld(UInt(x),y) == cld(x,y)
@test cld(x,UInt(y)) == cld(x,y)
@test cld(UInt(x),-y) == reinterpret(UInt,cld(x,-y))
@test cld(-x,UInt(y)) == cld(-x,y)
@test rem(UInt(x),UInt(y)) == rem(x,y)
@test rem(UInt(x),y) == rem(x,y)
@test rem(x,UInt(y)) == rem(x,y)
@test rem(UInt(x),-y) == rem(x,-y)
@test rem(-x,UInt(y)) == rem(-x,y)
@test mod(UInt(x),UInt(y)) == mod(x,y)
@test mod(UInt(x),y) == mod(x,y)
@test mod(x,UInt(y)) == mod(x,y)
@test mod(UInt(x),-y) == mod(x,-y)
@test mod(-x,UInt(y)) == mod(-x,y)
end
@test div(typemax(UInt64) , 1) == typemax(UInt64)
@test div(typemax(UInt64) ,-1) == -typemax(UInt64)
@test div(typemax(UInt64)-1, 1) == typemax(UInt64)-1
@test div(typemax(UInt64)-1,-1) == -typemax(UInt64)+1
@test div(typemax(UInt64)-2, 1) == typemax(UInt64)-2
@test div(typemax(UInt64)-2,-1) == -typemax(UInt64)+2
@test signed(div(unsigned(typemax(Int64))+2, 1)) == typemax(Int64)+2
@test signed(div(unsigned(typemax(Int64))+2,-1)) == -typemax(Int64)-2
@test signed(div(unsigned(typemax(Int64))+1, 1)) == typemax(Int64)+1
@test signed(div(unsigned(typemax(Int64))+1,-1)) == -typemax(Int64)-1
@test signed(div(unsigned(typemax(Int64)) , 1)) == typemax(Int64)
@test signed(div(unsigned(typemax(Int64)) ,-1)) == -typemax(Int64)
@test signed(div(typemax(UInt),typemax(Int))) == 2
@test signed(div(typemax(UInt),(typemax(Int)>>1)+1)) == 3
@test signed(div(typemax(UInt),typemax(Int)>>1)) == 4
@test signed(div(typemax(UInt),typemin(Int))) == -1
@test signed(div(typemax(UInt),typemin(Int)+1)) == -2
@test signed(div(typemax(UInt),typemin(Int)>>1)) == -3
@test signed(div(typemax(UInt),(typemin(Int)>>1)+1)) == -4
@test fld(typemax(UInt64) , 1) == typemax(UInt64)
@test fld(typemax(UInt64) ,-1) == -typemax(UInt64)
@test fld(typemax(UInt64)-1, 1) == typemax(UInt64)-1
@test fld(typemax(UInt64)-1,-1) == -typemax(UInt64)+1
@test fld(typemax(UInt64)-2, 1) == typemax(UInt64)-2
@test fld(typemax(UInt64)-2,-1) == -typemax(UInt64)+2
@test signed(fld(unsigned(typemax(Int64))+2, 1)) == typemax(Int64)+2
@test signed(fld(unsigned(typemax(Int64))+2,-1)) == -typemax(Int64)-2
@test signed(fld(unsigned(typemax(Int64))+1, 1)) == typemax(Int64)+1
@test signed(fld(unsigned(typemax(Int64))+1,-1)) == -typemax(Int64)-1
@test signed(fld(unsigned(typemax(Int64)) , 1)) == typemax(Int64)
@test signed(fld(unsigned(typemax(Int64)) ,-1)) == -typemax(Int64)
@test signed(fld(typemax(UInt),typemax(Int))) == 2
@test signed(fld(typemax(UInt),(typemax(Int)>>1)+1)) == 3
@test signed(fld(typemax(UInt),typemax(Int)>>1)) == 4
@test signed(fld(typemax(UInt),typemin(Int))) == -2
@test signed(fld(typemax(UInt),typemin(Int)+1)) == -3
@test signed(fld(typemax(UInt),typemin(Int)>>1)) == -4
@test signed(fld(typemax(UInt),(typemin(Int)>>1)+1)) == -5
@test cld(typemax(UInt64) , 1) == typemax(UInt64)
@test cld(typemax(UInt64) ,-1) == -typemax(UInt64)
@test cld(typemax(UInt64)-1, 1) == typemax(UInt64)-1
@test cld(typemax(UInt64)-1,-1) == -typemax(UInt64)+1
@test cld(typemax(UInt64)-2, 1) == typemax(UInt64)-2
@test cld(typemax(UInt64)-2,-1) == -typemax(UInt64)+2
@test signed(cld(unsigned(typemax(Int64))+2, 1)) == typemax(Int64)+2
@test signed(cld(unsigned(typemax(Int64))+2,-1)) == -typemax(Int64)-2
@test signed(cld(unsigned(typemax(Int64))+1, 1)) == typemax(Int64)+1
@test signed(cld(unsigned(typemax(Int64))+1,-1)) == -typemax(Int64)-1
@test signed(cld(unsigned(typemax(Int64)) , 1)) == typemax(Int64)
@test signed(cld(unsigned(typemax(Int64)) ,-1)) == -typemax(Int64)
@test signed(cld(typemax(UInt),typemax(Int))) == 3
@test signed(cld(typemax(UInt),(typemax(Int)>>1)+1)) == 4
@test signed(cld(typemax(UInt),typemax(Int)>>1)) == 5
@test signed(cld(typemax(UInt),typemin(Int))) == -1
@test signed(cld(typemax(UInt),typemin(Int)+1)) == -2
@test signed(cld(typemax(UInt),typemin(Int)>>1)) == -3
@test signed(cld(typemax(UInt),(typemin(Int)>>1)+1)) == -4
# Test exceptions and special cases
for T in (Int8,Int16,Int32,Int64,Int128, UInt8,UInt16,UInt32,UInt64,UInt128)
@test_throws DivideError div(T(1), T(0))
@test_throws DivideError fld(T(1), T(0))
@test_throws DivideError cld(T(1), T(0))
@test_throws DivideError rem(T(1), T(0))
@test_throws DivideError mod(T(1), T(0))
end
for T in (Int8,Int16,Int32,Int64,Int128)
@test_throws DivideError div(typemin(T), T(-1))
@test_throws DivideError fld(typemin(T), T(-1))
@test_throws DivideError cld(typemin(T), T(-1))
@test rem(typemin(T), T(-1)) === T(0)
@test mod(typemin(T), T(-1)) === T(0)
end
# Test return types
for T in (Int8,Int16,Int32,Int64,Int128, UInt8,UInt16,UInt32,UInt64,UInt128)
z, o = T(0), T(1)
@test typeof(+z) === T
@test typeof(-z) === T
@test typeof(abs(z)) === T
@test typeof(sign(z)) === T
@test typeof(copysign(z,z)) === T
@test typeof(flipsign(z,z)) === T
@test typeof(z+z) === T
@test typeof(z-z) === T
@test typeof(z*z) === T
@test typeof(z÷o) === T
@test typeof(z%o) === T
@test typeof(fld(z,o)) === T
@test typeof(mod(z,o)) === T
@test typeof(cld(z,o)) === T
end
# issue #4156
@test fld(1.4,0.35667494393873234) == 3.0
@test div(1.4,0.35667494393873234) == 3.0
@test fld(0.3,0.01) == 29.0
@test div(0.3,0.01) == 29.0
# see https://github.com/JuliaLang/julia/issues/3127
# issue #8831
@test rem(prevfloat(1.0),1.0) == prevfloat(1.0)
@test mod(prevfloat(1.0),1.0) == prevfloat(1.0)
# issue #3046
@test mod(Int64(2),typemax(Int64)) == 2
# things related to floating-point epsilon
@test eps() == eps(Float64)
@test eps(Float64) == eps(1.0)
@test eps(Float64) == eps(1.5)
@test eps(Float32) == eps(1f0)
@test eps(float(0)) == 5e-324
@test eps(-float(0)) == 5e-324
@test eps(nextfloat(float(0))) == 5e-324
@test eps(-nextfloat(float(0))) == 5e-324
@test eps(realmin()) == 5e-324
@test eps(-realmin()) == 5e-324
@test eps(realmax()) == 2.0^(1023-52)
@test eps(-realmax()) == 2.0^(1023-52)
@test isnan(eps(NaN))
@test isnan(eps(Inf))
@test isnan(eps(-Inf))
@test .1+.1+.1 != .3
@test .1+.1+.1 .3
@test .1+.1+.1-.3 0
@test .1+.1+.1-.3 0 atol=eps(.3)
@test 1.1 1.1f0
@test div(1e50,1) == 1e50
@test fld(1e50,1) == 1e50
@test cld(1e50,1) == 1e50
# rounding difficult values
for x = 2^53-10:2^53+10
y = Float64(x)
i = trunc(Int64,y)
@test Int64(trunc(y)) == i
@test Int64(round(y)) == i
@test Int64(floor(y)) == i
@test Int64(ceil(y)) == i
@test round(Int64,y) == i
@test floor(Int64,y) == i
@test ceil(Int64,y) == i
end
for x = 2^24-10:2^24+10
y = Float32(x)
i = trunc(Int,y)
@test Int(trunc(y)) == i
@test Int(round(y)) == i
@test Int(floor(y)) == i
@test Int(ceil(y)) == i
@test round(Int,y) == i
@test floor(Int,y) == i
@test ceil(Int,y) == i
end
# rounding vectors
let (x,y) = x==y && typeof(x)==typeof(y)
for t in [Float32,Float64]
# try different vector lengths
for n in [0,3,255,256]
r = (1:n)-div(n,2)
y = t[x/4 for x in r]
@test trunc.(y) t[div(i,4) for i in r]
@test floor.(y) t[i>>2 for i in r]
@test ceil.(y) t[(i+3)>>2 for i in r]
@test round.(y) t[(i+1+isodd(i>>2))>>2 for i in r]
@test broadcast(x -> round(x, RoundNearestTiesAway), y) t[(i+1+(i>=0))>>2 for i in r]
@test broadcast(x -> round(x, RoundNearestTiesUp), y) t[(i+2)>>2 for i in r]
end
end
end
@test_throws InexactError round(Int,Inf)
@test_throws InexactError round(Int,NaN)
@test round(Int,2.5) == 2
@test round(Int,1.5) == 2
@test round(Int,-2.5) == -2
@test round(Int,-1.5) == -2
@test round(Int,2.5,RoundNearestTiesAway) == 3
@test round(Int,1.5,RoundNearestTiesAway) == 2
@test round(Int,2.5,RoundNearestTiesUp) == 3
@test round(Int,1.5,RoundNearestTiesUp) == 2
@test round(Int,-2.5,RoundNearestTiesAway) == -3
@test round(Int,-1.5,RoundNearestTiesAway) == -2
@test round(Int,-2.5,RoundNearestTiesUp) == -2
@test round(Int,-1.5,RoundNearestTiesUp) == -1
@test round(Int,-1.9) == -2
@test_throws InexactError round(Int64, 9.223372036854776e18)
@test round(Int64, 9.223372036854775e18) == 9223372036854774784
@test_throws InexactError round(Int64, -9.223372036854778e18)
@test round(Int64, -9.223372036854776e18) == typemin(Int64)
@test_throws InexactError round(UInt64, 1.8446744073709552e19)
@test round(UInt64, 1.844674407370955e19) == 0xfffffffffffff800
@test_throws InexactError round(Int32, 2.1474836f9)
@test round(Int32, 2.1474835f9) == 2147483520
@test_throws InexactError round(Int32, -2.147484f9)
@test round(Int32, -2.1474836f9) == typemin(Int32)
@test_throws InexactError round(UInt32, 4.2949673f9)
@test round(UInt32, 4.294967f9) == 0xffffff00
for Ti in [Int,UInt]
for Tf in [Float16,Float32,Float64]
@test round(Ti,Tf(-0.0)) == 0
@test round(Ti,Tf(-0.0),RoundNearestTiesAway) == 0
@test round(Ti,Tf(-0.0),RoundNearestTiesUp) == 0
@test round(Ti, Tf(0.5)) == 0
@test round(Ti, Tf(0.5), RoundNearestTiesAway) == 1
@test round(Ti, Tf(0.5), RoundNearestTiesUp) == 1
@test round(Ti, prevfloat(Tf(0.5))) == 0
@test round(Ti, prevfloat(Tf(0.5)), RoundNearestTiesAway) == 0
@test round(Ti, prevfloat(Tf(0.5)), RoundNearestTiesUp) == 0
@test round(Ti, nextfloat(Tf(0.5))) == 1
@test round(Ti, nextfloat(Tf(0.5)), RoundNearestTiesAway) == 1
@test round(Ti, nextfloat(Tf(0.5)), RoundNearestTiesUp) == 1
@test round(Ti, Tf(-0.5)) == 0
@test round(Ti, Tf(-0.5), RoundNearestTiesUp) == 0
@test round(Ti, nextfloat(Tf(-0.5))) == 0
@test round(Ti, nextfloat(Tf(-0.5)), RoundNearestTiesAway) == 0
@test round(Ti, nextfloat(Tf(-0.5)), RoundNearestTiesUp) == 0
if Ti <: Signed
@test round(Ti, Tf(-0.5), RoundNearestTiesAway) == -1
@test round(Ti, prevfloat(Tf(-0.5))) == -1
@test round(Ti, prevfloat(Tf(-0.5)), RoundNearestTiesAway) == -1
@test round(Ti, prevfloat(Tf(-0.5)), RoundNearestTiesUp) == -1
else
@test_throws InexactError round(Ti, Tf(-0.5), RoundNearestTiesAway)
@test_throws InexactError round(Ti, prevfloat(Tf(-0.5)))
@test_throws InexactError round(Ti, prevfloat(Tf(-0.5)), RoundNearestTiesAway)
@test_throws InexactError round(Ti, prevfloat(Tf(-0.5)), RoundNearestTiesUp)
end
end
end
# numbers that can't be rounded by trunc(x+0.5)
@test round(Int64, 2.0^52 + 1) == 4503599627370497
@test round(Int32, 2.0f0^23 + 1) == 8388609
# binary literals
@test 0b1010101 == 0x55
@test isa(0b00000000,UInt8)
@test isa(0b000000000,UInt16)
@test isa(0b0000000000000000,UInt16)
@test isa(0b00000000000000000,UInt32)
@test isa(0b00000000000000000000000000000000,UInt32)
@test isa(0b000000000000000000000000000000000,UInt64)
@test isa(0b0000000000000000000000000000000000000000000000000000000000000000,UInt64)
@test isa(0b00000000000000000000000000000000000000000000000000000000000000000,UInt128)
@test isa(0b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
@test isa(0b11111111,UInt8)
@test isa(0b111111111,UInt16)
@test isa(0b1111111111111111,UInt16)
@test isa(0b11111111111111111,UInt32)
@test isa(0b11111111111111111111111111111111,UInt32)
@test isa(0b111111111111111111111111111111111,UInt64)
@test isa(0b1111111111111111111111111111111111111111111111111111111111111111,UInt64)
@test isa(0b11111111111111111111111111111111111111111111111111111111111111111,UInt128)
@test isa(0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")
# octal literals
@test 0o10 == 0x8
@test 0o100 == 0x40
@test 0o1000 == 0x200
@test 0o724 == 0x1d4
@test isa(0o377,UInt8)
@test isa(0o00,UInt8)
@test isa(0o000,UInt16)
@test isa(0o00000,UInt16)
@test isa(0o000000,UInt32)
@test isa(0o0000000000,UInt32)
@test isa(0o00000000000,UInt64)
@test isa(0o000000000000000000000,UInt64)
@test isa(0o0000000000000000000000,UInt128)
@test isa(0o000000000000000000000000000000000000000000,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0o0000000000000000000000000000000000000000000")
@test isa(0o11,UInt8)
@test isa(0o111,UInt8)
@test isa(0o11111,UInt16)
@test isa(0o111111,UInt16)
@test isa(0o1111111111,UInt32)
@test isa(0o11111111111,UInt32)
@test isa(0o111111111111111111111,UInt64)
@test isa(0o1111111111111111111111,UInt64)
@test isa(0o111111111111111111111111111111111111111111,UInt128)
@test isa(0o1111111111111111111111111111111111111111111,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0o11111111111111111111111111111111111111111111")
# hexadecimal literals
@test isa(0x00,UInt8)
@test isa(0x000,UInt16)
@test isa(0x0000,UInt16)
@test isa(0x00000,UInt32)
@test isa(0x00000000,UInt32)
@test isa(0x000000000,UInt64)
@test isa(0x0000000000000000,UInt64)
@test isa(0x00000000000000000,UInt128)
@test isa(0x00000000000000000000000000000000,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0x000000000000000000000000000000000")
@test isa(0x11,UInt8)
@test isa(0x111,UInt16)
@test isa(0x1111,UInt16)
@test isa(0x11111,UInt32)
@test isa(0x11111111,UInt32)
@test isa(0x111111111,UInt64)
@test isa(0x1111111111111111,UInt64)
@test isa(0x11111111111111111,UInt128)
@test isa(0x11111111111111111111111111111111,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("0x111111111111111111111111111111111")
# "-" is not part of unsigned literals
@test -0x10 == -(0x10)
@test -0b10 == -(0b10)
@test -0o10 == -(0o10)
@test -0x0010 == -(0x0010)
@test -0b0010 == -(0b0010)
@test -0o0010 == -(0o0010)
@test -0x00000000000000001 == -(0x00000000000000001)
@test -0o0000000000000000000001 == -(0o0000000000000000000001)
@test -0b00000000000000000000000000000000000000000000000000000000000000001 ==
-(0b00000000000000000000000000000000000000000000000000000000000000001)
@test isa(-0x00,UInt8)
@test isa(-0x0000000000000000,UInt64)
@test isa(-0x00000000000000000,UInt128)
@test isa(-0x00000000000000000000000000000000,UInt128)
# remove BigInt unsigned integer literals #11105
@test_throws ParseError parse("-0x000000000000000000000000000000000")
# Float32 literals
@test isa(1f0,Float32)
@test isa(1.f0,Float32)
@test isa(1.0f0,Float32)
@test 1f0 == 1.
@test isa(1f1,Float32)
@test 1f1 == 10.
# hexadecimal float literals
@test 0x1p0 === 1.
@test 0x1p1 === 2.
@test 0x.1p0 === 0.0625
@test 0x.1p1 === 0.125
@test 0xfp0 === 15.
@test 0xfp1 === 30.
@test 0x.fp0 === 0.9375
@test 0x.fp1 === 1.875
@test 0x1.p0 === 1.
@test 0x1.p1 === 2.
@test 0xf.p0 === 15.
@test 0xf.p1 === 30.
@test 0x1.0p0 === 1.
@test 0x1.0p1 === 2.
@test 0x1.1p0 === 1.0625
@test 0x1.1p1 === 2.125
@test 0x1.fp0 === 1.9375
@test 0x1.fp1 === 3.875
@test 0xf.0p0 === 15.
@test 0xf.0p1 === 30.
@test 0xf.1p0 === 15.0625
@test 0xf.1p1 === 30.125
@test 0xf.fp0 === 15.9375
@test 0xf.fp1 === 31.875
@test 0x1P0 === 1.
@test 0x1P1 === 2.
@test 0x.1P0 === 0.0625
@test 0x.1P1 === 0.125
@test 0xfP0 === 15.
@test 0xfP1 === 30.
@test 0x.fP0 === 0.9375
@test 0x.fP1 === 1.875
@test 0x1.P0 === 1.
@test 0x1.P1 === 2.
@test 0xf.P0 === 15.
@test 0xf.P1 === 30.
@test 0x1.0P0 === 1.
@test 0x1.0P1 === 2.
@test 0x1.1P0 === 1.0625
@test 0x1.1P1 === 2.125
@test 0x1.fP0 === 1.9375
@test 0x1.fP1 === 3.875
@test 0xf.0P0 === 15.
@test 0xf.0P1 === 30.
@test 0xf.1P0 === 15.0625
@test 0xf.1P1 === 30.125
@test 0xf.fP0 === 15.9375
@test 0xf.fP1 === 31.875
@test -0x1.0p2 === -4.0
# eps / realmin / realmax
@test 0x1p-52 == eps()
@test 0x1p-52 + 1 != 1
@test 0x1p-53 + 1 == 1
@test 0x1p-1022 == realmin()
@test 0x1.fffffffffffffp1023 == realmax()
@test isinf(nextfloat(0x1.fffffffffffffp1023))
# custom rounding and significant-digit ops
function approx_eq(a, b, tol)
abs(a - b) < tol
end
approx_eq(a, b) = approx_eq(a, b, 1e-6)
# rounding to digits relative to the decimal point
@test approx_eq(round(pi,0), 3.)
@test approx_eq(round(pi,1), 3.1)
@test approx_eq(round(10*pi,-1), 30.)
@test round(.1,0) == 0.
@test round(-.1,0) == -0.
@test isnan(round(NaN, 2))
@test isinf(round(Inf,2))
@test isinf(round(-Inf,2))
# round vs trunc vs floor vs ceil
@test approx_eq(round(123.456,1), 123.5)
@test approx_eq(round(-123.456,1), -123.5)
@test approx_eq(trunc(123.456,1), 123.4)
@test approx_eq(trunc(-123.456,1), -123.4)
@test approx_eq(ceil(123.456,1), 123.5)
@test approx_eq(ceil(-123.456,1), -123.4)
@test approx_eq(floor(123.456,1), 123.4)
@test approx_eq(floor(-123.456,1), -123.5)
# rounding with too much (or too few) precision
for x in (12345.6789, 0, -12345.6789)
y = float(x)
@test y == trunc(x, 1000)
@test y == round(x, 1000)
@test y == floor(x, 1000)
@test y == ceil(x, 1000)
end
x = 12345.6789
@test 0.0 == trunc(x, -1000)
@test 0.0 == round(x, -1000)
@test 0.0 == floor(x, -1000)
@test Inf == ceil(x, -1000)
x = -12345.6789
@test -0.0 == trunc(x, -1000)
@test -0.0 == round(x, -1000)
@test -Inf == floor(x, -1000)
@test -0.0 == ceil(x, -1000)
x = 0.0
@test 0.0 == trunc(x, -1000)
@test 0.0 == round(x, -1000)
@test 0.0 == floor(x, -1000)
@test 0.0 == ceil(x, -1000)
# rounding in other bases
@test approx_eq(round(pi,2,2), 3.25)
@test approx_eq(round(pi,3,2), 3.125)
@test approx_eq(round(pi,3,5), 3.144)
# vectorized trunc/round/floor/ceil with digits/base argument
a = rand(2, 2, 2)
for f in (round, trunc, floor, ceil)
@test f.(a[:, 1, 1], 2) == map(x->f(x, 2), a[:, 1, 1])
@test f.(a[:, :, 1], 2) == map(x->f(x, 2), a[:, :, 1])
@test f.(a, 9, 2) == map(x->f(x, 9, 2), a)
@test f.(a[:, 1, 1], 9, 2) == map(x->f(x, 9, 2), a[:, 1, 1])
@test f.(a[:, :, 1], 9, 2) == map(x->f(x, 9, 2), a[:, :, 1])
@test f.(a, 9, 2) == map(x->f(x, 9, 2), a)
end
# significant digits (would be nice to have a smart vectorized
# version of signif)
@test approx_eq(signif(123.456,1), 100.)
@test approx_eq(signif(123.456,3), 123.)
@test approx_eq(signif(123.456,5), 123.46)
@test approx_eq(signif(123.456,8,2), 123.5)
@test signif(0.0, 1) === 0.0
@test signif(-0.0, 1) === -0.0
@test signif(1.2, 2) === 1.2
@test signif(1.0, 6) === 1.0
@test signif(0.6, 1) === 0.6
@test signif(7.262839104539736, 2) === 7.3
@test isinf(signif(Inf, 3))
@test isnan(signif(NaN, 3))
@test signif(1.12312, 1000) === 1.12312
@test signif(Float32(7.262839104539736), 3) === Float32(7.26)
@test signif(Float32(7.262839104539736), 4) === Float32(7.263)
@test signif(Float32(1.2), 3) === Float32(1.2)
@test signif(Float32(1.2), 5) === Float32(1.2)
@test signif(Float16(0.6), 2) === Float16(0.6)
@test signif(Float16(1.1), 70) === Float16(1.1)
# issue #1308
@test hex(~UInt128(0)) == "f"^32
@test (~0)%UInt128 == ~UInt128(0)
@test Int128(~0) == ~Int128(0)
# issue 1552
@test isa(rationalize(Int8, float(pi)), Rational{Int8})
@test rationalize(Int8, float(pi)) == 22//7
@test rationalize(Int64, 0.957762604052997) == 42499549//44373782
@test rationalize(Int16, 0.929261477046077) == 11639//12525
@test rationalize(Int16, 0.2264705884044309) == 77//340
@test rationalize(Int16, 0.39999899264235683) == 2//5
@test rationalize(Int16, 1.1264233500618559e-5) == 0//1
@test rationalize(UInt16, 0.6666652791223875) == 2//3
@test rationalize(Int8, 0.9374813124660655) == 15//16
@test rationalize(Int8, 0.003803032342443835) == 0//1
# issue 3412
@test convert(Rational{Int32},0.5) === Int32(1)//Int32(2)
# issue 6712
@test convert(Rational{BigInt},Float64(pi)) == Float64(pi)
@test convert(Rational{BigInt},big(pi)) == big(pi)
@test convert(Rational,0.0) == 0
@test convert(Rational,-0.0) == 0
@test convert(Rational,zero(BigFloat)) == 0
@test convert(Rational,-zero(BigFloat)) == 0
@test convert(Rational{BigInt},0.0) == 0
@test convert(Rational{BigInt},-0.0) == 0
@test convert(Rational{BigInt},zero(BigFloat)) == 0
@test convert(Rational{BigInt},-zero(BigFloat)) == 0
@test convert(Rational{BigInt},5e-324) == 5e-324
@test convert(Rational{BigInt},realmin(Float64)) == realmin(Float64)
@test convert(Rational{BigInt},realmax(Float64)) == realmax(Float64)
@test isa(convert(Float64, big(1)//2), Float64)
# issue 16513
@test convert(Rational{Int32}, pi) == 1068966896 // 340262731
@test convert(Rational{Int64}, pi) == 2646693125139304345 // 842468587426513207
@test convert(Rational{Int128}, pi) == 60728338969805745700507212595448411044 // 19330430665609526556707216376512714945
@test_throws ArgumentError convert(Rational{BigInt}, pi)
# issue 5935
@test rationalize(Int8, nextfloat(0.1)) == 1//10
@test rationalize(Int64, nextfloat(0.1)) == 300239975158034//3002399751580339
@test rationalize(Int128,nextfloat(0.1)) == 300239975158034//3002399751580339
@test rationalize(BigInt,nextfloat(0.1)) == 300239975158034//3002399751580339
@test rationalize(Int8, nextfloat(0.1),tol=0.5eps(0.1)) == 1//10
@test rationalize(Int64, nextfloat(0.1),tol=0.5eps(0.1)) == 379250494936463//3792504949364629
@test rationalize(Int128,nextfloat(0.1),tol=0.5eps(0.1)) == 379250494936463//3792504949364629
@test rationalize(BigInt,nextfloat(0.1),tol=0.5eps(0.1)) == 379250494936463//3792504949364629
@test rationalize(Int8, nextfloat(0.1),tol=1.5eps(0.1)) == 1//10
@test rationalize(Int64, nextfloat(0.1),tol=1.5eps(0.1)) == 1//10
@test rationalize(Int128,nextfloat(0.1),tol=1.5eps(0.1)) == 1//10
@test rationalize(BigInt,nextfloat(0.1),tol=1.5eps(0.1)) == 1//10
@test rationalize(BigInt,nextfloat(parse(BigFloat,"0.1")),tol=1.5eps(big(0.1))) == 1//10
@test rationalize(Int64, nextfloat(0.1),tol=0) == 7205759403792795//72057594037927936
@test rationalize(Int128,nextfloat(0.1),tol=0) == 7205759403792795//72057594037927936
@test rationalize(BigInt,nextfloat(0.1),tol=0) == 7205759403792795//72057594037927936
@test rationalize(Int8, prevfloat(0.1)) == 1//10
@test rationalize(Int64, prevfloat(0.1)) == 1//10
@test rationalize(Int128,prevfloat(0.1)) == 1//10
@test rationalize(BigInt,prevfloat(0.1)) == 1//10
@test rationalize(BigInt,prevfloat(parse(BigFloat,"0.1"))) == 1//10
@test rationalize(Int64, prevfloat(0.1),tol=0) == 7205759403792793//72057594037927936
@test rationalize(Int128,prevfloat(0.1),tol=0) == 7205759403792793//72057594037927936
@test rationalize(BigInt,prevfloat(0.1),tol=0) == 7205759403792793//72057594037927936
@test rationalize(BigInt,nextfloat(parse(BigFloat,"0.1")),tol=0) == 46316835694926478169428394003475163141307993866256225615783033603165251855975//463168356949264781694283940034751631413079938662562256157830336031652518559744
@test rationalize(Int8, 200f0) == 1//0
@test rationalize(Int8, -200f0) == -1//0
@test [rationalize(1pi,tol=0.1^n) for n=1:10] == [
16//5
22//7
201//64
333//106
355//113
355//113
75948//24175
100798//32085
103993//33102
312689//99532 ]
# issue 16311
rationalize(nextfloat(0.0)) == 0//1
# rational-exponent promotion rules (issue #3155):
@test 2.0f0^(1//3) == 2.0f0^(1.0f0/3)
@test 2^(1//3) == 2^(1/3)
# no loss of precision for rational powers (issue #18114)
@test BigFloat(2)^(BigFloat(1)/BigFloat(3)) == BigFloat(2)^(1//3)
# large shift amounts
@test Int32(-1)>>31 == -1
@test Int32(-1)>>32 == -1
@test Int32(-1)>>33 == -1
@test 10>>64 == 0
@test 10>>>64 == 0
@test 10<<64 == 0
# issue #3520 - certain int literals on 32-bit systems
@test -536870913 === -536870912-1
# overflow in rational comparison
@test 3//2 < typemax(Int)
@test 3//2 <= typemax(Int)
# check gcd and related functions against GMP
for T in (Int32,Int64), ii = -20:20, jj = -20:20
i::T, j::T = ii, jj
local d = gcd(i,j)
@test d >= 0
@test lcm(i,j) >= 0
local ib = big(i)
local jb = big(j)
@test d == gcd(ib,jb)
@test lcm(i,j) == lcm(ib,jb)
@test gcdx(i,j) == gcdx(ib,jb)
if j == 0 || d != 1
@test_throws DomainError invmod(i,j)
@test_throws DomainError invmod(ib,jb)
else
n = invmod(i,j)
@test div(n, j) == 0
@test n == invmod(ib,jb)
@test mod(n*i,j) == mod(1,j)
end
end
# check powermod function against few types (in particular [U]Int128 and BigInt)
for i = -10:10, p = 0:5, m = -10:10
m == 0 && continue
x = powermod(i, p, m)
for T in [Int32, Int64, Int128, UInt128, BigInt]
T <: Unsigned && m < 0 && continue
let xT = powermod(i, p, T(m))
@test x == xT
@test isa(xT, T)
end
T <: Unsigned && i < 0 && continue
@test x == mod(T(i)^p, T(m))
end
end
# with m==1 should give 0
@test powermod(1,0,1) == 0
@test powermod(1,0,big(1)) == 0
@test powermod(1,0,-1) == 0
@test powermod(1,0,big(-1)) == 0
# divide by zero error
@test_throws DivideError powermod(1,0,0)
@test_throws DivideError powermod(1,0,big(0))
# negative powers perform modular inversion before exponentiation
@test powermod(1, -1, 1) == 0
@test powermod(1, -1, big(1)) == 0
# additional BigInt powermod tests
@test powermod(0, 1, big(6)) == 0
@test powermod(1, 0, big(6)) == 1
@test powermod(big(6), big(6), big(6)) == 0
@test powermod(10, 50, big(10)^50 - 1) == 1
@test powermod(-1, 1, big(6)) == 5
@test powermod(-1, 0, big(6)) == 1
@test powermod(-1, -1, big(6)) == 5
@test powermod(-1, 1, big(-6)) == -1
@test powermod(-1, 0, big(-6)) == -5
@test powermod(-1, -1, big(-6)) == -1
@test_throws DivideError powermod(2, -1, big(6))
@test_throws DivideError powermod(-2, -1, big(6))
# other divide-by-zero errors
@test_throws DivideError div(1,0)
@test_throws DivideError rem(1,0)
@test_throws DivideError divrem(1,0)
@test_throws DivideError fld(1,0)
@test_throws DivideError mod(1,0)
@test_throws DivideError fldmod(1,0)
@test_throws DivideError cld(1,0)
@test_throws DivideError div(-1,0)
@test_throws DivideError rem(-1,0)
@test_throws DivideError divrem(-1,0)
@test_throws DivideError fld(-1,0)
@test_throws DivideError mod(-1,0)
@test_throws DivideError fldmod(-1,0)
@test_throws DivideError cld(-1,0)
@test_throws DivideError div(UInt(1),UInt(0))
@test_throws DivideError rem(UInt(1),UInt(0))
@test_throws DivideError divrem(UInt(1),UInt(0))
@test_throws DivideError fld(UInt(1),UInt(0))
@test_throws DivideError mod(UInt(1),UInt(0))
@test_throws DivideError fldmod(UInt(1),UInt(0))
@test_throws DivideError cld(UInt(1),UInt(0))
@test_throws DivideError div(typemin(Int),-1)
@test_throws DivideError fld(typemin(Int),-1)
@test_throws DivideError cld(typemin(Int),-1)
@test_throws DivideError divrem(typemin(Int),-1)
@test_throws DivideError fldmod(typemin(Int),-1)
@test rem(typemin(Int),-1) == 0
@test mod(typemin(Int),-1) == 0
# prevpow2/nextpow2:
@test nextpow2(0) == prevpow2(0) == 0
for i = -2:2
@test nextpow2(i) == prevpow2(i) == i
end
@test nextpow2(56789) == -nextpow2(-56789) == 65536
@test prevpow2(56789) == -prevpow2(-56789) == 32768
for i = -100:100
@test nextpow2(i) == nextpow2(big(i))
@test prevpow2(i) == prevpow2(big(i))
end
for T in (Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64)
@test nextpow2(T(42)) === T(64)
@test prevpow2(T(42)) === T(32)
end
@test ispow2(64)
@test !ispow2(42)
@test !ispow2(~typemax(Int))
@test nextpow(2,1) == 1
@test prevpow(2,1) == 1
@test nextpow(3,243) == 243
@test prevpow(3,243) == 243
@test nextpow(3,241) == 243
@test prevpow(3,244) == 243
for a = -1:1
@test_throws DomainError nextpow(a, 2)
@test_throws DomainError prevpow(a, 2)
end
@test_throws DomainError nextpow(2,0)
@test_throws DomainError prevpow(2,0)
@test_throws ArgumentError nextprod([2,3,5],Int128(typemax(Int))+1)
@test nextprod([2,3,5],30) == 30
@test nextprod([2,3,5],33) == 36
@test nextfloat(0.0) == 5.0e-324
@test prevfloat(0.0) == -5.0e-324
@test nextfloat(-0.0) == 5.0e-324
@test prevfloat(-0.0) == -5.0e-324
@test nextfloat(-5.0e-324) === -0.0
@test prevfloat(5.0e-324) == 0.0
@test nextfloat(-1.0) > -1.0
@test prevfloat(-1.0) < -1.0
@test nextfloat(nextfloat(0.0),-2) == -5.0e-324
@test nextfloat(prevfloat(0.0), 2) == 5.0e-324
@test nextfloat(Inf) === Inf
@test prevfloat(-Inf) === -Inf
@test isequal(nextfloat(NaN), NaN)
@test nextfloat(Inf32) === Inf32
@test prevfloat(-Inf32) === -Inf32
@test isequal(nextfloat(NaN32), NaN32)
# issue #16206
@test prevfloat(Inf) == 1.7976931348623157e308
@test prevfloat(Inf32) == 3.4028235f38
@test nextfloat(prevfloat(Inf)) == Inf
@test nextfloat(prevfloat(Inf),2) == Inf
@test nextfloat(1.0,typemax(Int64)) == Inf
@test nextfloat(0.0,typemin(Int64)) == -Inf
@test nextfloat(1f0,typemin(Int64)) == -Inf32
@test nextfloat(1.0,typemax(UInt64)) == Inf
@test nextfloat(1.0,typemax(UInt128)) == Inf
@test nextfloat(1.0,big(2)^67) == Inf
@test nextfloat(1.0,-big(2)^67) == -Inf
for F in (Float16,Float32,Float64)
@test reinterpret(Unsigned,one(F)) === Base.exponent_one(F)
@test reinterpret(Signed,one(F)) === signed(Base.exponent_one(F))
end
@test eps(realmax(Float64)) == 1.99584030953472e292
@test eps(-realmax(Float64)) == 1.99584030953472e292
# modular multiplicative inverses of odd numbers via exponentiation
for T = (UInt8,Int8,UInt16,Int16,UInt32,Int32,UInt64,Int64,UInt128,Int128)
for n = 1:2:1000
@test n*(n^typemax(T)) & typemax(T) == 1
n = rand(T) | one(T)
@test n*(n^typemax(T)) == 1
end
end
@test false*pi === 0.0
@test pi*false === 0.0
@test true*pi === Float64(pi)
@test pi*true === Float64(pi)
# issue #5492
@test -0.0 + false === -0.0
# issue #5881
@test bits(true) == "00000001"
@test bits(false) == "00000000"
# edge cases of intrinsics
let g() = sqrt(-1.0)
@test_throws DomainError sqrt(-1.0)
end
@test sqrt(NaN) === NaN
let g() = sqrt(NaN)
@test g() === NaN
end
let g(x) = sqrt(x)
@test g(NaN) === NaN
end
# widen
@test widen(1.5f0) === 1.5
@test widen(Int32(42)) === Int64(42)
@test widen(Int8) === Int32
@test widen(Int64) === Int128
@test widen(Float32) === Float64
@test widen(Float16) === Float32
## Note: this should change to e.g. Float128 at some point
@test widen(Float64) === BigFloat
@test widen(BigInt) === BigInt
@test widemul(typemax(Int64),typemax(Int64)) == 85070591730234615847396907784232501249
@test typeof(widemul(Int64(1),UInt64(1))) == Int128
@test typeof(widemul(UInt64(1),Int64(1))) == Int128
@test typeof(widemul(Int128(1),UInt128(1))) == BigInt
@test typeof(widemul(UInt128(1),Int128(1))) == BigInt
# .//
@test [1,2,3] // 4 == [1//4, 2//4, 3//4]
@test [1,2,3] .// [4,5,6] == [1//4, 2//5, 3//6]
@test [1+2im,3+4im] .// [5,6] == [(1+2im)//5,(3+4im)//6]
@test [1//3+2im,3+4im] .// [5,6] == [(1//3+2im)//5,(3+4im)//6]
# issue #7441
@test_throws InexactError Int32(2.0^50)
@test_throws InexactError round(UInt8, 255.5)
@test round(UInt8, 255.4) === 0xff
@test_throws InexactError round(Int16, -32768.7)
@test round(Int16, -32768.1) === Int16(-32768)
# issue #7508
@test_throws ErrorException reinterpret(Int, 0x01)
# issue #12832
@test_throws ErrorException reinterpret(Float64, Complex{Int64}(1))
@test_throws ErrorException reinterpret(Float64, Complex64(1))
@test_throws ErrorException reinterpret(Complex64, Float64(1))
@test_throws ErrorException reinterpret(Int32, false)
# issue #41
ndigf(n) = Float64(log(Float32(n)))
@test Float64(log(Float32(256))) == ndigf(256) == 5.545177459716797
# cmp on unsigned integers (see commit 24b236321e03c6d9b8cb91a450f567256a793196)
@test cmp(0x77777777,0x88888888) == -1
@test cmp(0x3959dcc5d7fd177b67df4e10bc350850, 0xd63d5b1183221b0a9e38c6809b33cdec) == -1
# issue #7911
@test sum([Int128(1) Int128(2)]) == Int128(3)
# digits and digits!
@test digits(24, 2) == [0, 0, 0, 1, 1]
@test digits(24, 2, 3) == [0, 0, 0, 1, 1]
@test digits(24, 2, 7) == [0, 0, 0, 1, 1, 0, 0]
@test digits(100) == [0, 0, 1]
@test digits(BigInt(2)^128, 2) == [zeros(128); 1]
let a = zeros(Int, 3)
digits!(a, 50)
@test a == [0, 5, 0]
digits!(a, 9, 2)
@test a == [1, 0, 0]
digits!(a, 7, 2)
@test a == [1, 1, 1]
end
# Fill a pre allocated 2x4 matrix
let a = zeros(Int,(2,4))
for i in 0:3
digits!(view(a,:,i+1),i,2)
end
@test a == [0 1 0 1;
0 0 1 1]
end
@test_throws InexactError convert(UInt8, 256)
@test_throws InexactError convert(UInt, -1)
@test_throws InexactError convert(Int, big(2)^100)
@test_throws InexactError convert(Int16, big(2)^100)
@test_throws InexactError convert(Int, typemax(UInt))
# issue #9789
@test_throws InexactError convert(Int8, typemax(UInt64))
@test_throws InexactError convert(Int16, typemax(UInt64))
@test_throws InexactError convert(Int, typemax(UInt64))
# issue #14549
for T in (Int8, Int16, UInt8, UInt16)
for F in (Float32,Float64)
@test_throws InexactError convert(T, F(200000.0))
end
end
let x = big(-0.0)
@test signbit(x) && !signbit(abs(x))
end
@test all(x -> (m=mod1(x,3); 0<m<=3), -5:+5)
@test all(x -> x == (fld1(x,3)-1)*3 + mod1(x,3), -5:+5)
@test all(x -> fldmod1(x,3) == (fld1(x,3), mod1(x,3)), -5:+5)
#Issue #5570
@test map(x -> Int(mod1(UInt(x),UInt(5))), 0:15) == [5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
# Issue #9618: errors thrown by large exponentiations
@test_throws DomainError big(2)^-(big(typemax(UInt))+1)
@test_throws OverflowError big(2)^(big(typemax(UInt))+1)
@test 0==big(0)^(big(typemax(UInt))+1)
# bswap (issue #9726)
@test bswap(0x0002) === 0x0200
@test bswap(0x01020304) === 0x04030201
@test reinterpret(Float64,bswap(0x000000000000f03f)) === 1.0
@test reinterpret(Float32,bswap(0x0000c03f)) === 1.5f0
@test bswap(reinterpret(Float64,0x000000000000f03f)) === 1.0
@test bswap(reinterpret(Float32,0x0000c03f)) === 1.5f0
zbuf = IOBuffer([0xbf, 0xc0, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00,
0x40, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc0, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
z1 = read(zbuf, Complex64)
z2 = read(zbuf, Complex128)
@test bswap(z1) === -1.5f0 + 2.5f0im
@test bswap(z2) === 3.5 - 4.5im
#isreal(x::Real) = true
for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
@test isreal(x) == true
end
function allsubtypes!(m::Module, x::DataType, sts::Set)
for s in names(m, true)
if isdefined(m, s) && !Base.isdeprecated(m, s)
t = getfield(m, s)
if isa(t, Type) && t <: x && t != Union{}
push!(sts, t)
elseif isa(t, Module) && t !== m && module_name(t) === s && module_parent(t) === m
allsubtypes!(t, x, sts)
end
end
end
end
let number_types = Set()
allsubtypes!(Base, Number, number_types)
allsubtypes!(Core, Number, number_types)
@test !isempty(number_types)
#eltype{T<:Number}(::Type{T}) = T
for T in number_types
@test eltype(T) == T
end
#ndims{T<:Number}(::Type{T}) = 0
for x in number_types
@test ndims(x) == 0
end
end
#getindex(x::Number) = x
for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
@test getindex(x) == x
@test getindex(x, 1, 1) == x
end
#getindex(x::Number,-1) throws BoundsError
#getindex(x::Number,0) throws BoundsError
#getindex(x::Number,2) throws BoundsError
#getindex(x::Array,-1) throws BoundsError
#getindex(x::Array,0 throws BoundsError
#getindex(x::Array,length(x::Array)+1) throws BoundsError
for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
@test_throws BoundsError getindex(x,-1)
@test_throws BoundsError getindex(x,0)
@test_throws BoundsError getindex(x,2)
@test_throws BoundsError getindex([x x],-1)
@test_throws BoundsError getindex([x x],0)
@test_throws BoundsError getindex([x x],length([x,x])+1)
@test_throws BoundsError getindex(x, 1, 0)
end
# copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, x)
# flipsign(x::Real, y::Real) = ifelse(signbit(y), -x, x)
for x in [1.23, 7, e, 4//5]
for y in [1.23, 7, e, 4//5]
@test copysign(x, y) == x
@test copysign(x, -y) == -x
@test copysign(-x, y) == x
@test copysign(-x, -y) == -x
@test flipsign(x, y) == x
@test flipsign(x, -y) == -x
@test flipsign(-x, y) == -x
@test flipsign(-x, -y) == x
end
end
#angle(z::Real) = atan2(zero(z), z)
#function only returns two values, depending on sign
@test angle(10) == 0.0
@test angle(-10) == 3.141592653589793
#in(x::Number, y::Number) = x == y
@test in(3,3) == true #Int
@test in(2.0,2.0) == true #FP
@test in(e,e) == true #Const
@test in(4//5,4//5) == true #Rat
@test in(1+2im, 1+2im) == true #Imag
@test in(3, 3.0) == true #mixed
#map(f::Callable, x::Number, ys::Number...) = f(x)
@test map(sin, 3) == sin(3)
@test map(cos, 3) == cos(3)
@test map(tan, 3) == tan(3)
@test map(log, 3) == log(3)
@test map(copysign, 1.0, -2.0) == -1.0
@test map(muladd, 2, 3, 4) == 10
@test_throws InexactError convert(UInt8, big(300))
# issue #10311
let n = 1
@test n//n + n//big(n)*im == 1//1 + 1//1*im
end
# BigInt - (small negative) is tricky because gmp only has gmpz_sub_ui
@test big(-200) - Int8(-128) == -72
# n % Type
for T in Any[Int16, Int32, UInt32, Int64, UInt64, BigInt]
if !(T <: Unsigned)
@test convert(T, -200) % Int8 === Int8(56)
@test convert(T, -200) % UInt8 === 0x38
@test convert(T, -300) % Int8 === Int8(-44)
@test convert(T, -300) % UInt8 === 0xd4
@test convert(T, -128) % Int8 === Int8(-128)
@test convert(T, -128) % UInt8 === 0x80
end
@test convert(T, 127) % Int8 === Int8(127)
@test convert(T, 127) % UInt8 === 0x7f
@test convert(T, 128) % Int8 === Int8(-128)
@test convert(T, 128) % UInt8 === 0x80
@test convert(T, 200) % Int8 === Int8(-56)
@test convert(T, 300) % UInt8 === 0x2c
end
@test_throws InexactError UInt128(-1)
for T in (Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128)
@test_throws InexactError T(big(typemax(T))+1)
@test_throws InexactError T(big(typemin(T))-1)
end
for (d,B) in ((4//2+1im,Rational{BigInt}),(3.0+1im,BigFloat),(2+1im,BigInt))
@test typeof(big(d)) == Complex{B}
@test big(d) == d
@test typeof(big.([d])) == Vector{Complex{B}}
@test big.([d]) == [d]
end
# issue #12536
@test Rational{Int16}(1,2) === Rational(Int16(1),Int16(2))
@test Rational{Int16}(500000,1000000) === Rational(Int16(1),Int16(2))
rand_int = rand(Int8)
for T in [Int8, Int16, Int32, Int128, BigInt]
@test numerator(convert(T, rand_int)) == rand_int
@test denominator(convert(T, rand_int)) == 1
@test typemin(Rational{T}) == -one(T)//zero(T)
@test typemax(Rational{T}) == one(T)//zero(T)
@test widen(Rational{T}) == Rational{widen(T)}
end
@test Rational(Float32(rand_int)) == Rational(rand_int)
@test Rational(Rational(rand_int)) == Rational(rand_int)
@test begin
var = -Rational(UInt32(0))
var == UInt32(0)
end
@test Rational(rand_int, 3)/Complex(3, 2) == Complex(Rational(rand_int, 13), -Rational(rand_int*2, 39))
@test Complex(rand_int, 0) == Rational(rand_int)
@test Rational(rand_int) == Complex(rand_int, 0)
@test (Complex(rand_int, 4) == Rational(rand_int)) == false
@test (Rational(rand_int) == Complex(rand_int, 4)) == false
@test trunc(Rational(BigInt(rand_int), BigInt(3))) == Rational(trunc(BigInt, Rational(BigInt(rand_int),BigInt(3))))
@test ceil(Rational(BigInt(rand_int), BigInt(3))) == Rational( ceil(BigInt, Rational(BigInt(rand_int),BigInt(3))))
@test round(Rational(BigInt(rand_int), BigInt(3))) == Rational(round(BigInt, Rational(BigInt(rand_int),BigInt(3))))
for a = -3:3
@test Rational(Float32(a)) == Rational(a)
@test Rational(a)//2 == a//2
@test a//Rational(2) == Rational(a/2)
@test a.//[-2, -1, 1, 2] == [-a//2, -a//1, a//1, a//2]
for b=-3:3, c=1:3
@test b//(a+c*im) == b*a//(a^2+c^2)-(b*c//(a^2+c^2))*im
for d=-3:3
@test (a+b*im)//(c+d*im) == (a*c+b*d+(b*c-a*d)*im)//(c^2+d^2)
@test Complex(Rational(a)+b*im)//Complex(Rational(c)+d*im) == Complex(a+b*im)//Complex(c+d*im)
end
end
end
# issue #15205
let T = Rational
x = Complex{T}(1//3 + 1//4*im)
y = Complex{T}(1//2 + 1//5*im)
xf = Complex{BigFloat}(1//3 + 1//4*im)
yf = Complex{BigFloat}(1//2 + 1//5*im)
yi = 4
@test x^y xf^yf
@test x^yi xf^yi
@test x^true xf^true
@test x^false == xf^false
@test x^1 xf^1
@test xf^Rational(2, 1) xf*xf
@test Complex(1., 1.)^Rational(2,1) == Complex(1., 1.)*Complex(1.,1.) == Complex(0., 2.)
end
for Tf = (Float16, Float32, Float64), Ti = (Int16, Int32, Int64)
almost_half = Rational(div(typemax(Ti),Ti(2)) , typemax(Ti))
over_half = Rational(div(typemax(Ti),Ti(2))+one(Ti), typemax(Ti))
exactly_half = Rational(one(Ti) , Ti(2))
@test round( almost_half) == 0//1
@test round(-almost_half) == 0//1
@test round(Tf, almost_half, RoundNearestTiesUp) == 0.0
@test round(Tf, -almost_half, RoundNearestTiesUp) == 0.0
@test round(Tf, almost_half, RoundNearestTiesAway) == 0.0
@test round(Tf, -almost_half, RoundNearestTiesAway) == 0.0
@test round( exactly_half) == 0//1 # rounds to closest _even_ integer
@test round(-exactly_half) == 0//1 # rounds to closest _even_ integer
@test round(Tf, exactly_half, RoundNearestTiesUp) == 1.0
@test round(Tf, -exactly_half, RoundNearestTiesUp) == 0.0
@test round(Tf, exactly_half, RoundNearestTiesAway) == 1.0
@test round(Tf, -exactly_half, RoundNearestTiesAway) == -1.0
@test round(over_half) == 1//1
@test round(-over_half) == -1//1
@test round(Tf, over_half, RoundNearestTiesUp) == 1.0
@test round(Tf, over_half, RoundNearestTiesAway) == 1.0
@test round(Tf, -over_half, RoundNearestTiesUp) == -1.0
@test round(Tf, -over_half, RoundNearestTiesAway) == -1.0
@test round(Tf, 11//2, RoundNearestTiesUp) == 6.0
@test round(Tf, -11//2, RoundNearestTiesUp) == -5.0
@test round(Tf, 11//2, RoundNearestTiesAway) == 6.0
@test round(Tf, -11//2, RoundNearestTiesAway) == -6.0
@test round(Tf, Ti(-1)//zero(Ti)) == -Inf
@test round(Tf, one(1)//zero(Ti)) == Inf
@test round(Tf, Ti(-1)//zero(Ti), RoundNearestTiesUp) == -Inf
@test round(Tf, one(1)//zero(Ti), RoundNearestTiesUp) == Inf
@test round(Tf, Ti(-1)//zero(Ti), RoundNearestTiesAway) == -Inf
@test round(Tf, one(1)//zero(Ti), RoundNearestTiesAway) == Inf
@test round(Tf, zero(Ti)//one(Ti)) == 0
@test round(Tf, zero(Ti)//one(Ti), RoundNearestTiesUp) == 0
@test round(Tf, zero(Ti)//one(Ti), RoundNearestTiesAway) == 0
end
let
io = IOBuffer()
rational1 = Rational(1465, 8593)
rational2 = Rational(-4500, 9000)
@test sprint(show, rational1) == "1465//8593"
@test sprint(show, rational2) == "-1//2"
let
io1 = IOBuffer()
write(io1, rational1)
io1.ptr = 1
@test read(io1, typeof(rational1)) == rational1
io2 = IOBuffer()
write(io2, rational2)
io2.ptr = 1
@test read(io2, typeof(rational2)) == rational2
end
end
@test round(11//2) == 6//1 # rounds to closest _even_ integer
@test round(-11//2) == -6//1 # rounds to closest _even_ integer
@test round(11//3) == 4//1 # rounds to closest _even_ integer
@test round(-11//3) == -4//1 # rounds to closest _even_ integer
for T in (Float16, Float32, Float64)
@test round(T, true//false) === convert(T, Inf)
@test round(T, true//true) === one(T)
@test round(T, false//true) === zero(T)
end
for T in (Int8, Int16, Int32, Int64, Bool)
@test_throws DivideError round(T, true//false)
@test round(T, true//true) === one(T)
@test round(T, false//true) === zero(T)
end
# multiplicative inverses
function testmi(numrange, denrange)
for d in denrange
d == 0 && continue
fastd = Base.multiplicativeinverse(d)
for n in numrange
@test div(n,d) == div(n,fastd)
end
end
end
testmi(-1000:1000, -100:100)
testmi(typemax(Int)-1000:typemax(Int), -100:100)
testmi(typemin(Int)+1:typemin(Int)+1000, -100:100)
@test_throws ArgumentError Base.multiplicativeinverse(0)
testmi(map(UInt32, 0:1000), map(UInt32, 1:100))
testmi(typemax(UInt32)-UInt32(1000):typemax(UInt32), map(UInt32, 1:100))
@test ndims(1) == 0
@test ndims(Integer) == 0
@test size(1,1) == 1
@test_throws BoundsError size(1,-1)
@test indices(1) == ()
@test indices(1,1) == 1:1
@test_throws BoundsError indices(1,-1)
@test isinteger(Integer(2)) == true
@test size(1) == ()
@test length(1) == 1
@test endof(1) == 1
@test eltype(Integer) == Integer
# issue #15920
@test Rational(0, 1) / Complex(3, 2) == 0
# issue #16282
@test_throws MethodError 3 // 4.5im
# PR #16995
let types = (Base.BitInteger_types..., BigInt, Bool,
Rational{Int}, Rational{BigInt},
Float16, Float32, Float64, BigFloat,
Complex{Int}, Complex{UInt}, Complex32, Complex64, Complex128)
for S in types
for op in (+, -)
T = @inferred Base.promote_op(op, S)
t = @inferred op(one(S))
@test T === typeof(t)
end
for R in types
for op in (+, -, *, /, ^)
T = @inferred Base.promote_op(op, S, R)
t = @inferred op(one(S), one(R))
@test T === typeof(t)
end
end
end
@test @inferred(Base.promote_op(!, Bool)) === Bool
end
let types = (Base.BitInteger_types..., BigInt, Bool,
Rational{Int}, Rational{BigInt},
Float16, Float32, Float64, BigFloat)
for S in types, T in types
for op in (<, >, <=, >=, (==))
@test @inferred(Base.promote_op(op, S, T)) === Bool
end
end
end
let types = (Base.BitInteger_types..., BigInt, Bool)
for S in types
T = @inferred Base.promote_op(~, S)
t = @inferred ~one(S)
@test T === typeof(t)
for R in types
for op in (&, |, <<, >>, (>>>), %, ÷)
T = @inferred Base.promote_op(op, S, R)
t = @inferred op(one(S), one(R))
@test T === typeof(t)
end
end
end
end
@test !isempty(complex(1,2))
@testset "rem $T rounded" for T in (Float16, Float32, Float64, BigFloat)
@test rem(T(1), T(2), RoundToZero) == 1
@test rem(T(1), T(2), RoundNearest) == 1
@test rem(T(1), T(2), RoundDown) == 1
@test rem(T(1), T(2), RoundUp) == -1
@test rem(T(1.5), T(2), RoundToZero) == 1.5
@test rem(T(1.5), T(2), RoundNearest) == -0.5
@test rem(T(1.5), T(2), RoundDown) == 1.5
@test rem(T(1.5), T(2), RoundUp) == -0.5
@test rem(T(-1), T(2), RoundToZero) == -1
@test rem(T(-1), T(2), RoundNearest) == -1
@test rem(T(-1), T(2), RoundDown) == 1
@test rem(T(-1), T(2), RoundUp) == -1
@test rem(T(-1.5), T(2), RoundToZero) == -1.5
@test rem(T(-1.5), T(2), RoundNearest) == 0.5
@test rem(T(-1.5), T(2), RoundDown) == 0.5
@test rem(T(-1.5), T(2), RoundUp) == -1.5
end
@testset "rem2pi $T" for T in (Float16, Float32, Float64, BigFloat)
@test rem2pi(T(1), RoundToZero) == 1
@test rem2pi(T(1), RoundNearest) == 1
@test rem2pi(T(1), RoundDown) == 1
@test rem2pi(T(1), RoundUp) 1-2pi
@test rem2pi(T(2), RoundToZero) == 2
@test rem2pi(T(2), RoundNearest) == 2
@test rem2pi(T(2), RoundDown) == 2
@test rem2pi(T(2), RoundUp) 2-2pi
@test rem2pi(T(4), RoundToZero) == 4
@test rem2pi(T(4), RoundNearest) 4-2pi
@test rem2pi(T(4), RoundDown) == 4
@test rem2pi(T(4), RoundUp) 4-2pi
@test rem2pi(T(-4), RoundToZero) == -4
@test rem2pi(T(-4), RoundNearest) 2pi-4
@test rem2pi(T(-4), RoundDown) 2pi-4
@test rem2pi(T(-4), RoundUp) == -4
end
import Base.^
struct PR20530; end
struct PR20889; x; end
^(::PR20530, p::Int) = 1
^(t::PR20889, b) = t.x + b
^(t::PR20889, b::Integer) = t.x + b
Base.literal_pow{p}(::typeof(^), ::PR20530, ::Type{Val{p}}) = 2
@testset "literal powers" begin
x = PR20530()
p = 2
@test x^p == 1
@test x^2 == 2
@test [x,x,x].^2 == [2,2,2]
for T in (Float16, Float32, Float64, BigFloat, Int8, Int, BigInt, Complex{Int}, Complex{Float64})
for p in -4:4
if p < 0 && real(T) <: Integer
@test_throws DomainError eval(:($T(2)^$p))
else
v = eval(:($T(2)^$p))
@test 2.0^p == T(2)^p == v
@test v isa T
end
end
end
@test PR20889(2)^3 == 5
end
module M20889 # do we get the expected behavior without importing Base.^?
struct PR20889; x; end
^(t::PR20889, b) = t.x + b
Base.Test.@test PR20889(2)^3 == 5
end
@testset "iszero" begin
# Numeric scalars
for T in [Float16, Float32, Float64, BigFloat,
Int8, Int16, Int32, Int64, Int128, BigInt,
UInt8, UInt16, UInt32, UInt64, UInt128]
@test iszero(T(0))
@test iszero(Complex{T}(0))
if T <: Integer
@test iszero(Rational{T}(0))
elseif T <: AbstractFloat
@test iszero(T(-0.0))
@test iszero(Complex{T}(-0.0))
end
end
@test !iszero(nextfloat(BigFloat(0)))
for x in (π, e, γ, catalan, φ)
@test !iszero(x)
end
# Array reduction
@test !iszero([0, 1, 2, 3])
@test iszero(zeros(Int, 5))
end
f20065(B, i) = UInt8(B[i])
@testset "issue 20065" begin
# f20065 must be called from global scope to exhibit the buggy behavior
for B in (Array{Bool}(10), Array{Bool}(10,10), reinterpret(Bool, rand(UInt8, 10)))
@test all(x-> x <= 1, (f20065(B, i) for i in eachindex(B)))
for i in 1:length(B)
@test (@eval f20065($B, $i) <= 1)
end
end
end