Make Interval constructor fast by not including checks

benchmark/benchmarks.jl

@@ -35,8 +35,6 @@ end
 end
 
 @benchgroup "Elementary functions" begin
-    a = Interval(1, 2)
-
     for op in (exp, log, sin, tan)
         @bench string(op) $(op)($a)
     end

src/IntervalArithmetic.jl

@@ -30,7 +30,8 @@ import Base:
     parse
 
 export
-    Interval, AbstractInterval,
+    AbstractInterval, # Interval
+    interval,
     @interval, @biginterval, @floatinterval, @make_interval,
     diam, radius, mid, mag, mig, hull,
     emptyinterval, ∅, ∞, isempty, isinterior, isdisjoint, ⪽,

src/intervals/arithmetic.jl

@@ -308,16 +308,18 @@ doc"""
     mid(a::Interval, α=0.5)
 
 Find the midpoint (or, in general, an intermediate point) at a distance α along the interval `a`. The default is the true midpoint at α=0.5.
+
+Assumes 0 ≤ α ≤ 1.
 """
 function mid(a::Interval{T}, α) where T
 
     isempty(a) && return convert(T, NaN)
     isentire(a) && return zero(a.lo)
 
-    a.lo == -∞ && return nextfloat(a.lo)
-    a.hi == +∞ && return prevfloat(a.hi)
+    a.lo == -∞ && return nextfloat(-∞)
+    a.hi == +∞ && return prevfloat(+∞)
 
-    @assert 0 ≤ α ≤ 1
+    # @assert 0 ≤ α ≤ 1
 
     # return (1-α) * a.lo + α * a.hi  # rounds to nearest
     return α*(a.hi - a.lo) + a.lo  # rounds to nearest
@@ -338,7 +340,6 @@ end
 
 mid(a::Interval{Rational{T}}) where T = (1//2) * (a.lo + a.hi)
 
-
 doc"""
     diam(a::Interval)
 

src/intervals/intervals.jl

@@ -5,37 +5,38 @@
 
 ## Interval type
 
+if haskey(ENV, "IA_VALID") == true
+    const validity_check = true
+else
+    const validity_check = false
+end
+
 abstract type AbstractInterval{T} <: Real end
 
 struct Interval{T<:Real} <: AbstractInterval{T}
     lo :: T
     hi :: T
 
-    function Interval{T}(a::Real, b::Real) where T
+    function Interval{T}(a::Real, b::Real) where T<:Real
 
-        if isnan(a) || isnan(b)
-            return new(NaN, NaN)  # nai
-        end
+        if validity_check
 
-        if a > b
-            # empty interval = [∞,-∞]
-            (isinf(a) && isinf(b)) && return new(a, b)
-            throw(ArgumentError("Must have a ≤ b to construct Interval(a, b)."))
-        end
+            if is_valid_interval(a, b)
+                new(a, b)
+
+            else
+                throw(ArgumentError("Interval of form [$a, $b] not allowed. Must have a ≤ b to construct interval(a, b)."))
+            end
 
-        # The IEEE Std 1788-2015 states that a < Inf and b > -Inf;
-        # see page 6, "bounds".
-        if a == Inf || b == -Inf
-            throw(ArgumentError(
-                "Must satisfy `a < Inf` and `b > -Inf` to construct Interval(a, b)."))
         end
 
-        return new(a,b)
+        new(a, b)
 
     end
 end
 
 
+
 ## Outer constructors
 
 Interval(a::T, b::T) where T<:Real = Interval{T}(a, b)
@@ -57,6 +58,54 @@ Interval{T}(x) where T = Interval(convert(T, x))
 
 Interval{T}(x::Interval) where T = convert(Interval{T}, x)
 
+"""
+    is_valid_interval(a::Real, b::Real)
+
+Check if `(a, b)` constitute a valid interval
+"""
+function is_valid_interval(a::Real, b::Real)
+
+    # println("isvalid()")
+
+    if isnan(a) || isnan(b)
+        if isnan(a) && isnan(b)
+            return true
+        else
+            return false
+        end
+    end
+
+    if a > b
+        if isinf(a) && isinf(b)
+            return true  # empty interval = [∞,-∞]
+        else
+            return false
+        end
+    end
+
+    if a == Inf || b == -Inf
+        return false
+    end
+
+    return true
+end
+
+"""
+    interval(a, b)
+
+`interval(a, b)` checks whether [a, b] is a valid `Interval`, which is the case if `-∞ <= a <= b <= ∞`, using the (non-exported) `is_valid_interval` function. If so, then an `Interval(a, b)` object is returned; if not, then an error is thrown.
+"""
+function interval(a::Real, b::Real)
+    if !is_valid_interval(a, b)
+        throw(ArgumentError("`[$a, $b]` is not a valid interval. Need `a ≤ b` to construct `interval(a, b)`."))
+    end
+
+    return Interval(a, b)
+end
+
+interval(a::Real) = interval(a, a)
+
+
 ## Include files
 include("special.jl")
 include("macros.jl")
@@ -75,11 +124,11 @@ include("hyperbolic.jl")
 
 # a..b = Interval(convert(Interval, a).lo, convert(Interval, b).hi)
 
-..(a::Integer, b::Integer) = Interval(a, b)
-..(a::Integer, b::Real) = Interval(a, nextfloat(float(b)))
-..(a::Real, b::Integer) = Interval(prevfloat(float(a)), b)
+..(a::Integer, b::Integer) = interval(a, b)
+..(a::Integer, b::Real) = interval(a, nextfloat(float(b)))
+..(a::Real, b::Integer) = interval(prevfloat(float(a)), b)
 
-..(a::Real, b::Real) = Interval(prevfloat(float(a)), nextfloat(float(b)))
+..(a::Real, b::Real) = interval(prevfloat(float(a)), nextfloat(float(b)))
 
 macro I_str(ex)  # I"[3,4]"
     @interval(ex)

src/intervals/macros.jl

@@ -89,5 +89,5 @@ function make_interval(T, expr1, expr2)
 
     expr2 = transform(expr2[1], :convert, :(Interval{$T}))
 
-    :(Interval(($expr1).lo, ($expr2).hi))
+    :(interval(($expr1).lo, ($expr2).hi))
 end

src/multidim/intervalbox.jl

@@ -1,6 +1,5 @@
 # This file is part of the IntervalArithmetic.jl package; MIT licensed
 
-
 doc"""An `IntervalBox` is an $N$-dimensional rectangular box, given
 by a Cartesian product of $N$ `Interval`s.
 """

test/interval_tests/consistency.jl

@@ -335,4 +335,15 @@ c = @interval(0.25, 4.0)
         @test !iszero(Interval(0.0, nextfloat(0.0)))
     end
 
+    @testset "Difference between Interval and interval" begin
+        @test interval(1, 2) == Interval(1, 2)
+
+        @test inf(Interval(3, 2)) == 3
+        @test_throws ArgumentError interval(3, 2)
+
+        @test sup(Interval(Inf, Inf)) == Inf
+        @test_throws ArgumentError interval(Inf, Inf)
+
+    end
+
 end

test/interval_tests/construction.jl

@@ -43,20 +43,20 @@ using Base.Test
 
     # Disallowed conversions with a > b
 
-    @test_throws ArgumentError Interval(2, 1)
-    @test_throws ArgumentError Interval(big(2), big(1))
-    @test_throws ArgumentError Interval(BigInt(1), 1//10)
-    @test_throws ArgumentError Interval(1, 0.1)
-    @test_throws ArgumentError Interval(big(1), big(0.1))
+    @test_throws ArgumentError interval(2, 1)
+    @test_throws ArgumentError interval(big(2), big(1))
+    @test_throws ArgumentError interval(BigInt(1), 1//10)
+    @test_throws ArgumentError interval(1, 0.1)
+    @test_throws ArgumentError interval(big(1), big(0.1))
 
     @test_throws ArgumentError @interval(2, 1)
     @test_throws ArgumentError @interval(big(2), big(1))
     @test_throws ArgumentError @interval(big(1), 1//10)
     @test_throws ArgumentError @interval(1, 0.1)
     @test_throws ArgumentError @interval(big(1), big(0.1))
-    @test_throws ArgumentError Interval(Inf)
-    @test_throws ArgumentError Interval(-Inf, -Inf)
-    @test_throws ArgumentError Interval(Inf, Inf)
+    @test_throws ArgumentError interval(Inf)
+    @test_throws ArgumentError interval(-Inf, -Inf)
+    @test_throws ArgumentError interval(Inf, Inf)
 
     # Conversion to Interval without type
     @test convert(Interval, 1) == Interval(1.0)
@@ -254,12 +254,8 @@ end
 
 # issue 192:
 @testset "Disallow a single NaN in an interval" begin
-    a = Interval(NaN, 2)
-    @test isnan(a.lo) && isnan(a.hi)
-
-    a = Interval(Inf, NaN)
-    @test isnan(a.lo) && isnan(a.hi)
-
+    @test_throws ArgumentError interval(NaN, 2)
+    @test_throws ArgumentError interval(Inf, NaN)
 end
 
 # issue 206:
@@ -305,3 +301,7 @@ end
     x = 3..4
     @test @interval(f(x.lo), f(x.hi)) == Interval(0.75, 0.8)
 end
+
+@testset "a..b with a > b" begin
+    @test_throws ArgumentError 3..2
+end

test/interval_tests/numeric.jl

@@ -57,7 +57,7 @@ end
     @test Interval(1,2) ^ -3 == Interval(1/8, 1.0)
     @test Interval(0,3) ^ -3 == @interval(1/27, Inf)
     @test Interval(-1,2) ^ -3 == entireinterval()
-    @test_throws ArgumentError Interval(-1, -2) ^ -3  # wrong way round
+    @test_throws ArgumentError interval(-1, -2) ^ -3  # wrong way round
     @test Interval(-3,2) ^ (3//1) == Interval(-27, 8)
     @test Interval(0.0) ^ 1.1 == Interval(0, 0)
     @test Interval(0.0) ^ 0.0 == emptyinterval()

test/runtests.jl

@@ -2,6 +2,8 @@
 using IntervalArithmetic
 using Base.Test
 
+const Interval = IntervalArithmetic.Interval
+
 # Interval tests:
 
 setformat(:full)