Replace Interval with interval in tests

Author: OlivierHnt

test/decoration_tests/decoration_tests.jl

@@ -13,7 +13,7 @@ let b
 
     a = DecoratedInterval(@interval(-1, 1), com)
     b = sqrt(a)
-    @test interval(b) ≛ sqrt(Interval(0, 1))
+    @test interval(b) ≛ sqrt(interval(0, 1))
     @test decoration(b) == trv
 
     d = DecoratedInterval(a, dac)
@@ -41,13 +41,13 @@ let b
     @test @decorated(-3,-2) ^ -3 ≛ DecoratedInterval(-1/8.,-1/27)
     @test @decorated(0,3) ^ 2 ≛ DecoratedInterval(0, 9)
     @test @decorated(0,3) ^ -2 ≛ DecoratedInterval(1/9, Inf, trv)
-    @test @decorated(2,3)^Interval(0.0, 1.0) ≛ DecoratedInterval(1.0,3.0)
+    @test @decorated(2,3)^interval(0.0, 1.0) ≛ DecoratedInterval(1.0,3.0)
     @test @decorated(2,3)^@decorated(0.0, 1.0) ≛ DecoratedInterval(1.0,3.0)
-    @test @decorated(0, 2)^Interval(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
+    @test @decorated(0, 2)^interval(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
     @test @decorated(0, 2)^@decorated(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
-    @test @decorated(-3, 2)^Interval(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
+    @test @decorated(-3, 2)^interval(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
     @test @decorated(-3, 2)^@decorated(0.0, 1.0) ≛ DecoratedInterval(0.0,2.0, trv)
-    @test @decorated(-3, 2)^Interval(-1.0, 1.0) ≛ DecoratedInterval(0.0,Inf, trv)
+    @test @decorated(-3, 2)^interval(-1.0, 1.0) ≛ DecoratedInterval(0.0,Inf, trv)
     @test @decorated(-3, 2)^@decorated(-1.0, 1.0) ≛ DecoratedInterval(0.0, Inf, trv)
 
     a = @decorated 1 2

test/display_tests/display.jl

@@ -7,10 +7,10 @@ let x, b
     @testset "Interval" begin
         a = 1..2
         b = -1.1..1.3
-        c = Interval(pi)
+        c = interval(pi)
         # large_expo = IntervalArithmetic.atomic(Interval{BigFloat}, -Inf)
         # Use smaller exponent, cf. JuliaLang/julia#48678
-        large_expo = Interval(0, big"1e123456789")
+        large_expo = interval(0, big"1e123456789")
 
         @testset "6 significant digits" begin
             setformat(:standard; sigdigits = 6)
@@ -66,7 +66,7 @@ let x, b
     end
 
     @testset "Interval{Rational{T}}" begin
-        a = Interval(1//3, 5//4)
+        a = interval(1//3, 5//4)
         @test_broken typeof(a) == Interval{Rational{Int}}
 
         setformat(:standard)
@@ -96,7 +96,7 @@ let x, b
     end
 
     @testset "Complex{Interval}" begin
-        a = Complex(Interval(0, 2), Interval(1))
+        a = Complex(interval(0, 2), interval(1))
         @test typeof(a) == Complex{Interval{Float64}}
 
         setformat(:standard)
@@ -143,7 +143,7 @@ let x, b
     setprecision(BigFloat, 128)
 
     @testset "BigFloat intervals" begin
-        a = Interval(big(1))
+        a = interval(big(1))
         @test typeof(a) == Interval{BigFloat}
 
         setformat(:standard; decorations = false)

test/interval_tests/bisect.jl

@@ -6,7 +6,7 @@ using Test
     @test bisect(X, 0.5) ≛ (0..0.5, 0.5..1)
     @test bisect(X, 0.25) ≛ (0..0.25, 0.25..1)
 
-    @test bisect(X) ≛ (Interval(0.0, 0.49609375), Interval(0.49609375, 1.0))
+    @test bisect(X) ≛ (interval(0.0, 0.49609375), interval(0.49609375, 1.0))
 
     X = -∞..∞
     @test bisect(X, 0.5) ≛ (-∞..0, 0..∞)
@@ -23,8 +23,8 @@ using Test
     @test bisect(X, 1, 0.5) ≛ ( (0..0.5) × (0..2), (0.5..1) × (0..2) )
     @test bisect(X, 1, 0.25) ≛ ( (0..0.25) × (0..2), (0.25..1) × (0..2) )
 
-    @test bisect(X) ≛ (IntervalBox(0..1, Interval(0.0, 0.9921875)),
-                        IntervalBox(0..1, Interval(0.9921875, 2.0)))
+    @test bisect(X) ≛ (IntervalBox(0..1, interval(0.0, 0.9921875)),
+                        IntervalBox(0..1, interval(0.9921875, 2.0)))
 
     X = (-∞..∞) × (-∞..∞)
     @test bisect(X, 0.5) ≛ ( (-∞..0) × (-∞..∞), (0..∞) × (-∞..∞))

test/interval_tests/consistency.jl

@@ -5,47 +5,46 @@ using Test
 
 @testset "Constructing intervals" begin
     # Naive constructors, with no conversion involved
-    @test Interval(1.0) ≛ Interval(Interval(1.0)) ≛ Interval{Float64}(Interval(1.0))
-    @test Interval(1) ≛ Interval(1.0, 1.0)
-    @test size(Interval(1)) == ()  # Match the `size` behaviour of `Number`
-    @test Interval(big(1)) ≛ Interval(1.0, 1.0)
-    @test_broken Interval(1//10) ≛ Interval{Rational{Int}}(1//10, 1//10)
-    @test_broken Interval(BigInt(1)//10) ≛ Interval{Rational{BigInt}}(1//10, 1//10)
-    @test Interval( (1.0, 2.0) ) ≛ Interval(1.0, 2.0)
-    @test_broken Interval{Rational{Int}}(1) ≛ Interval(1//1)
-    @test Interval{BigFloat}(1) ≛ Interval{BigFloat}(big(1.0), big(1.0))
+    @test Interval{Float64}(1.0, 1.0) ≛ interval(1) ≛ interval(interval(1.0)) ≛
+        interval(Float64, interval(1.0))
+    @test size(interval(1)) == ()  # Match the `size` behaviour of `Number`
+    @test interval(big(1)) ≛ Interval{Float64}(1.0, 1.0)
+    @test_broken interval(1//10) ≛ Interval{Rational{Int}}(1//10, 1//10)
+    @test_broken interval(BigInt(1)//10) ≛ Interval{Rational{BigInt}}(1//10, 1//10)
+    @test interval( (1.0, 2.0) ) ≛ Interval{Float64}(1.0, 2.0)
+    @test_broken interval(Rational{Int}, 1) ≛ interval(1//1)
+    @test interval(BigFloat, 1) ≛ Interval{BigFloat}(big(1.0), big(1.0))
 
     # Irrational
     for irr in (π, ℯ)
         @test @interval(-irr, irr).hi == (-irr..irr).hi
-        @test 0..irr ≛ hull(interval(0), Interval{Float64}(irr))
+        @test 0..irr ≛ hull(interval(0), interval(Float64, irr))
         @test (1.2..irr).hi == @interval(1.2, irr).hi
-        @test irr..irr ≛ Interval{Float64}(irr)
-        @test Interval(irr) ≛ @interval(irr)
-        @test Interval(irr, irr) ≛ Interval(irr)
-        @test Interval{Float32}(irr, irr) ≛ Interval{Float32}(irr)
+        @test irr..irr ≛ interval(Float64, irr)
+        @test interval(irr) ≛ @interval(irr) ≛ interval(irr, irr)
+        @test Interval{Float32}(irr, irr) ≛ interval(Float32, irr)
     end
 
-    @test_broken ℯ..big(4) ≛ hull(Interval{BigFloat}(π), interval(4))
-    @test π..big(4) ≛ hull(Interval{BigFloat}(π), interval(4))
+    @test_broken ℯ..big(4) ≛ hull(interval(BigFloat, π), interval(4))
+    @test π..big(4) ≛ hull(interval(BigFloat, π), interval(4))
 
-    @test ℯ..pi ≛ hull(@interval(ℯ), Interval{Float64}(π))
-    @test big(ℯ) in Interval(ℯ, π)
-    @test big(π) in Interval(ℯ, π)
-    @test big(ℯ) in Interval(0, ℯ)
-    @test big(π) in Interval(π, 4)
+    @test ℯ..pi ≛ hull(@interval(ℯ), interval(Float64, π))
+    @test big(ℯ) in interval(ℯ, π)
+    @test big(π) in interval(ℯ, π)
+    @test big(ℯ) in interval(0, ℯ)
+    @test big(π) in interval(π, 4)
 
     @test big(ℯ) in Interval{Float32}(ℯ, π)
     @test big(π) in Interval{Float32}(ℯ, π)
     @test big(ℯ) in Interval{Float32}(0, ℯ)
     @test big(π) in Interval{Float32}(π, 4)
 
-    @test interval(Interval(pi)) ≛ Interval(pi)
-    @test interval(Interval(NaN, -Inf)) ≛ emptyinterval()
+    @test interval(interval(π)) ≛ interval(π)
+    @test interval(Interval{Float64}(NaN, -Inf)) ≛ emptyinterval()
 
     # a < Inf and b > -Inf
-    @test @interval("1e300") ≛ Interval(9.999999999999999e299, 1.0e300)
-    @test @interval("-1e307") ≛ Interval(-1.0000000000000001e307, -1.0e307)
+    @test @interval("1e300") ≛ Interval{Float64}(9.999999999999999e299, 1.0e300)
+    @test @interval("-1e307") ≛ Interval{Float64}(-1.0000000000000001e307, -1.0e307)
 
     # Disallowed construction with a > b
     @test_logs (:warn,) @test isempty(@interval(2, 1))
@@ -58,15 +57,15 @@ using Test
     @test_logs (:warn,) @test isempty(interval(Inf, Inf))
 
     # Conversion to Interval without type
-    @test convert(Interval, 1) ≛ Interval(1.0)
-    @test convert(Interval, pi) ≛ @interval(pi)
-    @test convert(Interval, ℯ) ≛ @interval(ℯ)
-    @test convert(Interval, BigInt(1)) ≛ Interval(BigInt(1))
-    @test convert(Interval, 1//10) ≛ @interval(1//10)
-    @test convert(Interval, Interval(0.1, 0.2)) === Interval(0.1, 0.2)
+    @test_throws MethodError convert(Interval, 1)
+    @test_throws MethodError convert(Interval, π)
+    @test_throws MethodError convert(Interval, ℯ)
+    @test_throws MethodError convert(Interval, BigInt(1))
+    @test_throws MethodError convert(Interval, 1//10)
+    @test convert(Interval, Interval{Float64}(0.1, 0.2)) === Interval{Float64}(0.1, 0.2)
 
     a = @interval(0.1)
-    b = @interval(pi)
+    b = @interval(π)
 
     @test @floatinterval("0.1") ⊆ a
     @test typeof(a) == Interval{Float64}
@@ -89,17 +88,17 @@ using Test
     # TODO Actually use the rounding mode here
     for rounding in (:wide, :narrow)
         a = @interval(0.1, 0.2)
-        @test a ⊆ Interval(0.09999999999999999, 0.20000000000000004)
+        @test a ⊆ interval(0.09999999999999999, 0.20000000000000004)
 
         b = @interval(0.1)
-        @test b ⊆ Interval(0.09999999999999999, 0.10000000000000002)
-        @test b ⊆ Interval(0.09999999999999999, 0.20000000000000004)
+        @test b ⊆ interval(0.09999999999999999, 0.10000000000000002)
+        @test b ⊆ interval(0.09999999999999999, 0.20000000000000004)
         @test float(b) ⊆ a
 
         c = @interval("0.1", "0.2")
         @test c ⊆ a   # c is narrower than a
-        @test Interval(1//2) ≛ Interval(0.5)
-        @test_broken Interval(1//10).lo == rationalize(0.1)
+        @test interval(1//2) ≛ interval(0.5)
+        @test_broken interval(1//10).lo == rationalize(0.1)
     end
 
     @test string(emptyinterval()) == "∅"
@@ -116,13 +115,13 @@ end
     @test typeof(a)== Interval{Float64}
     @test typeof(big(a)) == Interval{BigFloat}
 
-    @test @floatinterval(123412341234123412341241234) ≛ Interval(1.234123412341234e26, 1.2341234123412342e26)
+    @test @floatinterval(123412341234123412341241234) ≛ interval(1.234123412341234e26, 1.2341234123412342e26)
     @test @interval(big"3") ≛ @floatinterval(3)
 
-    @test @floatinterval(big"1e10000") ≛ Interval(prevfloat(∞), ∞)
+    @test @floatinterval(big"1e10000") ≛ interval(prevfloat(∞), ∞)
 
     a = big(10)^10000
-    @test @floatinterval(a) ≛ Interval(prevfloat(∞), ∞)
+    @test @floatinterval(a) ≛ interval(prevfloat(∞), ∞)
 end
 
 #=
@@ -147,11 +146,11 @@ end
     @test_logs (:warn, ) @test isempty(4..π)
     @test_logs (:warn, ) @test isempty(NaN..3)
     @test_logs (:warn, ) @test isempty(3..NaN)
-    @test 1..π ≛ Interval(1, π)
+    @test 1..π ≛ Interval{Float64}(1, π)
 end
 
 @testset "± tests" begin
-    @test 3 ± 1 ≛ Interval(2.0, 4.0)
+    @test 3 ± 1 ≛ Interval{Float64}(2.0, 4.0)
     @test 3 ± 0.5 ≛ 2.5..3.5
     @test 3 ± 0.1 ≛ 2.9..3.1
     @test 0.5 ± 1 ≛ -0.5..1.5
@@ -169,8 +168,8 @@ end
 end
 
 @testset "Promotion between intervals" begin
-    x = Interval{Float64}(π)
-    y = Interval{BigFloat}(π)
+    x = interval(Float64, π)
+    y = interval(BigFloat, π)
     x_, y_ = promote(x, y)
 
     @test promote_type(typeof(x), typeof(y)) == Interval{BigFloat}
@@ -185,9 +184,9 @@ end
     @test typeof(@interval Float16 1 2) == Interval{Float16}
 
     # PR 496
-    @test eltype(Interval(1, 2)) == Interval{Float64}
-    @test IntervalArithmetic.numtype(Interval(1, 2)) == Float64
-    @test all([1 2; 3 4] * Interval(-1, 1) .≛ [-1..1 -2..2;-3..3 -4..4])
+    @test eltype(interval(1, 2)) == Interval{Float64}
+    @test IntervalArithmetic.numtype(interval(1, 2)) == Float64
+    @test all([1 2; 3 4] * interval(-1, 1) .≛ [-1..1 -2..2;-3..3 -4..4])
 
     @test eltype(IntervalBox(1..2, 2..3)) == Interval{Float64}
     @test IntervalArithmetic.numtype(IntervalBox(1..2, 2..3)) == Float64
@@ -200,19 +199,19 @@ end
     a = convert(Interval{Float64}, @biginterval(3, 4))
     @test typeof(a) == Interval{Float64}
 
-    pi64, pi32 = Interval{Float64}(pi), Interval{Float32}(pi)
+    pi64, pi32 = interval(Float64, pi), interval(Float32, pi)
     x, y = promote(pi64, pi32)
     @test x ≛ pi64
     @test y ≛ Interval{Float64}(pi32)
 end
 
 @testset "Interval{T} constructor" begin
-    @test Interval{Float64}(1) ≛ 1..1
+    @test Interval{Float64}(1, 1) ≛ 1..1
     # no rounding
-    @test Interval{Float64}(1.1) ≛ Interval(1.1, 1.1)
+    @test bounds(Interval{Float64}(1.1, 1.1)) == (1.1, 1.1)
 
-    @test Interval{BigFloat}(1) ≛ @biginterval(1, 1)
-    @test Interval{BigFloat}(big"1.1") ≛ Interval(big"1.1", big"1.1")
+    @test Interval{BigFloat}(1, 1) ≛ @biginterval(1, 1)
+    @test bounds(Interval{BigFloat}(big"1.1", big"1.1")) == (big"1.1", big"1.1")
 end
 
 # issue 206:
@@ -221,19 +220,19 @@ end
 
     a = I"[2/3, 1.1]"
     b = @interval("[2/3, 1.1]")
-    c = Interval(0.6666666666666666, 1.1)
+    c = interval(0.6666666666666666, 1.1)
     @test a ≛ b
     @test b ≛ c
 
     a = I"[1]"
     b = @interval("[1]")
-    c = Interval(1.0, 1.0)
+    c = interval(1.0, 1.0)
     @test a ≛ b
     @test b ≛ c
 
     a = I"[-0x1.3p-1, 2/3]"
     b = @interval("[-0x1.3p-1, 2/3]")
-    c = Interval(-0.59375, 0.6666666666666667)
+    c = interval(-0.59375, 0.6666666666666667)
     @test a ≛ b
     @test b ≛ c
 end
@@ -254,21 +253,21 @@ end
 end
 
 @testset "Interval{T}(x::Interval)" begin
-    @test Interval{Float64}(3..4) ≛ Interval(3.0, 4.0)
+    @test Interval{Float64}(3..4) ≛ Interval{Float64}(3.0, 4.0)
     @test Interval{BigFloat}(3..4) ≛ Interval{BigFloat}(3, 4)
 end
 
 @testset "@interval with fields" begin
     a = 3..4
     x = @interval(a.lo, 2*a.hi)
-    @test Interval(3, 8) ⊆ x
+    @test interval(3, 8) ⊆ x
 end
 
 @testset "@interval with user-defined function" begin
     f(x) = x.lo == Inf ? one(x) : x/(1+x)  # monotonic
 
     x = 3..4
-    @test Interval(0.75, 0.8) ⊆ @interval(f(x.lo), f(x.hi))
+    @test interval(0.75, 0.8) ⊆ @interval(f(x.lo), f(x.hi))
 end
 
 # issue 192: