Remove @interval, @tinterval and @decorated

Author: OlivierHnt

src/IntervalArithmetic.jl

@@ -50,7 +50,7 @@ import .Broadcast: broadcasted
 
 export
     Interval, BooleanInterval,
-    interval, @interval, @tinterval,
+    interval, ±, .., @I_str,
     diam, radius, mid, scaled_mid, mag, mig, hull,
     emptyinterval, ∅, ∞, isempty, isinterior, isdisjoint, ⪽,
     precedes, strictprecedes, ≺, ⊂, ⊃, ⊇, contains_zero, isthinzero,
@@ -64,7 +64,6 @@ export
     IntervalRounding,
     PointwisePolicy,
     cancelminus, cancelplus, isbounded, isunbounded,
-    .., @I_str, ±,
     pow, extended_div, nthroot,
     setformat, @format
 
@@ -86,7 +85,6 @@ export
 
 ## Decorations
 export
-    @decorated,
     interval, decoration, DecoratedInterval,
     com, dac, def, trv, ill
 

src/decorations/intervals.jl

@@ -77,20 +77,3 @@ end
 
 float(x::DecoratedInterval) = DecoratedInterval(float(interval(x)), decoration(x))
 big(x::DecoratedInterval) = DecoratedInterval(big(interval(x)), decoration(x))
-
-macro decorated(ex...)
-    if !(ex[1] isa String)
-        if length(ex) == 1
-            x = :(@interval($(esc(ex[1]))))
-            lo = :(inf($x))
-            hi = :(sup($x))
-        else
-            lo, hi = ex
-        end
-
-        return :(DecoratedInterval($lo, $hi))
-    else
-        s = ex[1]
-        parse(DecoratedInterval{Float64}, s)
-    end
-end

src/intervals/construction.jl

@@ -15,16 +15,13 @@ Constructors compliant with the IEEE Standard 1788-2015:
 - [`interval`](@ref)
 - [`..`](@ref)
 - [`±`](@ref)
-- [`@interval`](@ref)
-- [`@tinterval`](@ref)
 - [`@I_str`](@ref)
 
 !!! warning
     The internal constructor `unsafe_interval` is *not* compliant with the
     IEEE Standard 1788-2015.
 
-See also: [`interval`](@ref), [`±`](@ref), [`..`](@ref), [`@interval`](@ref),
-[`@tinterval`](@ref) and [`I"desc"`](@ref).
+See also: [`interval`](@ref), [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref).
 """
 struct Interval{T<:NumTypes} <: Real
     lo::T
@@ -125,8 +122,7 @@ empty interval is returned.
     rounded to the nearest when parsed (e.g. 0.1). In such cases, use the string
     macro [`@I_str`](@ref) to ensure tight enclosure around the typed numbers.
 
-See also: [`±`](@ref), [`..`](@ref), [`@interval`](@ref), [`@tinterval`](@ref)
-and [`@I_str`](@ref).
+See also: [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref).
 
 # Examples
 ```jldoctest
@@ -205,8 +201,7 @@ Despite using the midpoint-radius notation, the returned interval is still an
     rounded to the nearest when parsed (e.g. 0.1). In such cases, use the string
     macro [`@I_str`](@ref) to ensure tight enclosure around the typed numbers.
 
-See also: [`interval`](@ref), [`..`](@ref), [`@interval`](@ref),
-[`@tinterval`](@ref) and [`@I_str`](@ref).
+See also: [`interval`](@ref), [`..`](@ref) and [`@I_str`](@ref).
 
 # Examples
 ```jldoctest

src/intervals/construction_macros.jl

@@ -1,6 +1,5 @@
 # Construction and composability with numbers
 include("construction.jl")
-include("construction_macros.jl")
 include("real_interface.jl")
 
 # Rounding
@@ -27,4 +26,4 @@ include("interval_operations/boolean.jl")
 include("interval_operations/overlap.jl")
 include("interval_operations/numeric.jl")
 include("interval_operations/pointwise_boolean.jl")
-include("interval_operations/set_operations.jl")
+include("interval_operations/set_operations.jl")

src/intervals/intervals.jl

@@ -42,9 +42,7 @@ themselves single operations.
 
 The macro uses the internal `round_expr` function to transform e.g.
 `a + b` into `+(a, b, RoundDown)`.
-
-The user-facing equivalent is `@interval`, which can handle much more general cases.
 """
 macro round(T, ex1, ex2)
-     :(unsafe_interval($(esc(T)), $(round_expr(ex1, RoundDown)), $(round_expr(ex2, RoundUp))))
+    return :(unsafe_interval($(esc(T)), $(round_expr(ex1, RoundDown)), $(round_expr(ex2, RoundUp))))
 end

src/intervals/rounding_macros.jl

@@ -1,3 +1,33 @@
+"""
+    I"str"
+
+Create an interval according to the IEEE Standard 1788-2015. This is
+semantically equivalent to `parse(DecoratedInterval{default_numtype()}, str)` if
+the string contains the character `_` which delimits the interval and its
+decoration; otherwise, it is semantically equivalent to
+`parse(Interval{default_numtype()}, str)`.
+
+# Examples
+```jldoctest
+julia> setformat(:full);
+
+julia> I"[3, 4]"
+Interval{Float64}(3.0, 4.0)
+
+julia> I"0.1"
+Interval{Float64}(0.09999999999999999, 0.1)
+```
+"""
+macro I_str(str)
+    if '_' ∈ str
+        return parse(DecoratedInterval{default_numtype()}, str)
+    else
+        return parse(Interval{default_numtype()}, str)
+    end
+end
+
+#
+
 """
     parse(Interval, s::AbstractString)
 

src/parsing.jl

@@ -5,8 +5,7 @@
 Create an interval according to the IEEE Standard 1788-2015. This is
 semantically equivalent to [`interval(a, b)`](@ref).
 
-See also: [`interval`](@ref), [`@interval`](@ref), [`@tinterval`](@ref) and
-[`I_str`](@ref).
+See also: [`interval`](@ref), [`±`](@ref) and [`@I_str`](@ref).
 
 # Examples
 ```jldoctest

src/symbols.jl

@@ -4,14 +4,14 @@ using IntervalArithmetic
 let b
 
 @testset "DecoratedInterval tests" begin
-    a = DecoratedInterval(@interval(1, 2), com)
+    a = DecoratedInterval(interval(1, 2), com)
     @test decoration(a) == com
 
     b = sqrt(a)
     @test interval(b) ≛ sqrt(interval(a))
     @test decoration(b) == com
 
-    a = DecoratedInterval(@interval(-1, 1), com)
+    a = DecoratedInterval(interval(-1, 1), com)
     b = sqrt(a)
     @test interval(b) ≛ sqrt(interval(0, 1))
     @test decoration(b) == trv
@@ -25,44 +25,41 @@ let b
     @test decoration(DecoratedInterval(2, 0.1, com)) == ill
     @test decoration(DecoratedInterval(2, 0.1)) == ill
     @test isnai(DecoratedInterval(2, 0.1))
-    @test decoration(@decorated(2, 0.1)) == ill
     @test decoration(DecoratedInterval(big(2), big(1))) == ill
     @test isnai((DecoratedInterval(big(2), big(1))))
-    @test isnai(@decorated(big(2), big(1)))
 
     # Disabling the following tests, because Julia 0.5 has some strange behaviour here
     # @test_throws ArgumentError DecoratedInterval(BigInt(1), 1//10)
-    # @test_throws ArgumentError @decorated(BigInt(1), 1//10)
 
     # Tests related to powers of decorated Intervals
-    @test @decorated(2,3) ^ 2 ≛ DecoratedInterval(4, 9)
-    @test @decorated(2,3) ^ -2 ≛ DecoratedInterval(1/9,1/4)
-    @test @decorated(-3,2) ^ 3 ≛ DecoratedInterval(-27., 8.)
-    @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)^@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)^@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)^@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)^@decorated(-1.0, 1.0) ≛ DecoratedInterval(0.0, Inf, trv)
+    @test DecoratedInterval(2, 3) ^ 2 ≛ DecoratedInterval(4, 9)
+    @test DecoratedInterval(2, 3) ^ -2 ≛ DecoratedInterval(1/9,1/4)
+    @test DecoratedInterval(-3, 2) ^ 3 ≛ DecoratedInterval(-27, 8)
+    @test DecoratedInterval(-3, -2) ^ -3 ≛ DecoratedInterval(-1/8, -1/27)
+    @test DecoratedInterval(0, 3) ^ 2 ≛ DecoratedInterval(0, 9)
+    @test DecoratedInterval(0, 3) ^ -2 ≛ DecoratedInterval(1/9, Inf, trv)
+    @test DecoratedInterval(2, 3)^interval(0, 1) ≛ DecoratedInterval(1, 3)
+    @test DecoratedInterval(2, 3)^DecoratedInterval(0, 1) ≛ DecoratedInterval(1, 3)
+    @test DecoratedInterval(0, 2)^interval(0, 1) ≛ DecoratedInterval(0, 2, trv)
+    @test DecoratedInterval(0, 2)^DecoratedInterval(0, 1) ≛ DecoratedInterval(0, 2, trv)
+    @test DecoratedInterval(-3, 2)^interval(0, 1) ≛ DecoratedInterval(0, 2, trv)
+    @test DecoratedInterval(-3, 2)^DecoratedInterval(0, 1) ≛ DecoratedInterval(0, 2, trv)
+    @test DecoratedInterval(-3, 2)^interval(-1, 1) ≛ DecoratedInterval(0, Inf, trv)
+    @test DecoratedInterval(-3, 2)^DecoratedInterval(-1, 1) ≛ DecoratedInterval(0, Inf, trv)
 
-    a = @decorated 1 2
-    b = @decorated 3 4
+    a = DecoratedInterval(1, 2)
+    b = DecoratedInterval(3, 4)
 
     @test dist(a, b) == 2.0
 
     # invalid input
-    @test isnai(@decorated(3, 1, com))
-    @test isnai(@decorated(3, 1))
-    @test isnai(@decorated(Inf, Inf))
-    @test isnai(@decorated(-Inf, -Inf))
-    @test isnai(@decorated(NaN, 3))
-    @test isnai(@decorated(3, NaN))
-    @test isnai(@decorated(NaN, NaN))
+    @test isnai(DecoratedInterval(3, 1, com))
+    @test isnai(DecoratedInterval(3, 1))
+    @test isnai(DecoratedInterval(Inf, Inf))
+    @test isnai(DecoratedInterval(-Inf, -Inf))
+    @test isnai(DecoratedInterval(NaN, 3))
+    @test isnai(DecoratedInterval(3, NaN))
+    @test isnai(DecoratedInterval(NaN, NaN))
 end
 
 end

test/decoration_tests/decoration_tests.jl

@@ -61,7 +61,7 @@ let x, b
             @test sprint(show, MIME("text/plain"), large_expo) == "(5.0e+123456788 ± 5.00001e+123456788)₂₅₆"
 
             # issue 175:
-            @test sprint(show, MIME("text/plain"), @tinterval(BigFloat, 1, 2)) == "(1.5 ± 0.5)₂₅₆"
+            @test sprint(show, MIME("text/plain"), interval(BigFloat, 1, 2)) == "(1.5 ± 0.5)₂₅₆"
         end
     end
 
@@ -109,7 +109,7 @@ let x, b
     setprecision(BigFloat, 256)
 
     @testset "DecoratedInterval" begin
-        a = @decorated(1, 2)
+        a = DecoratedInterval(1, 2)
         @test typeof(a) == DecoratedInterval{Float64}
 
         setformat(:standard; decorations = false)
@@ -207,7 +207,7 @@ end
     @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]"
     @test sprint(show, x) == "Interval{Float64}(0.0, 1.0)"
 
-    x = @tinterval(BigFloat, 0, 1)
+    x = interval(BigFloat, 0, 1)
     @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]₁₂₈"
     @test sprint(show, x) == "Interval{BigFloat}(0.0, 1.0)"