Display true/false whether an interval is guaranteed in :full format

Author: OlivierHnt

src/display.jl

@@ -8,11 +8,13 @@ end
 function Base.show(io::IO, ::MIME"text/plain", params::DisplayOptions)
     println(io, "Display options:")
     println(io, "  - format: ", params.format)
-    println(io, "  - decorations: ", params.decorations)
-    println(io, "  - NG flag: ", params.ng_flag)
     if params.format === :full
+        println(io, "  - decorations: ", params.decorations, " (ignored)")
+        println(io, "  - NG flag: ", params.ng_flag, " (ignored)")
         print(io, "  - significant digits: ", params.sigdigits, " (ignored)")
     else
+        println(io, "  - decorations: ", params.decorations)
+        println(io, "  - NG flag: ", params.ng_flag)
         print(io, "  - significant digits: ", params.sigdigits)
     end
 end
@@ -54,12 +56,12 @@ julia> x = interval(0.1, 0.3)
 julia> setdisplay(:full)
 Display options:
   - format: full
-  - decorations: true
-  - NG flag: true
+  - decorations: true (ignored)
+  - NG flag: true (ignored)
   - significant digits: 6 (ignored)
 
 julia> x
-Interval{Float64}(0.1, 0.3, com)
+Interval{Float64}(0.1, 0.3, com, true)
 
 julia> setdisplay(:infsup; sigdigits = 3)
 Display options:
@@ -119,15 +121,15 @@ function _str_repr(a::Interval{T}, format::Symbol) where {T<:NumTypes}
     # `format` is either `:infsup`, `:midpoint` or `:full`
     str_interval = _str_basic_repr(a.bareinterval, format) # use `a.bareinterval` to not print a warning if `a` is an NaI
     if format === :full && str_interval != "∅"
-        str_interval = string("Interval{", T, "}(", str_interval, ", ", decoration(a), ')')
+        return string("Interval{", T, "}(", str_interval, ", ", decoration(a), ", ", isguaranteed(a), ')')
     else
         str_interval = _str_precision(str_interval, a, format)
         if format === :midpoint && str_interval != "∅" && T !== BigFloat && (display_options.decorations | (display_options.ng_flag & !isguaranteed(a)))
             str_interval = string('(', str_interval, ')')
         end
         str_interval = ifelse(display_options.decorations, string(str_interval, '_', decoration(a)), str_interval)
+        return ifelse(display_options.ng_flag & !isguaranteed(a), string(str_interval, "_NG"), str_interval)
     end
-    return ifelse(display_options.ng_flag & !isguaranteed(a), string(str_interval, "_NG"), str_interval)
 end
 
 function _str_repr(x::Complex{Interval{T}}, format::Symbol) where {T<:NumTypes}

src/intervals/construction.jl

@@ -135,6 +135,8 @@ See also: [`interval`](@ref), [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref).
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> bareinterval(1//1, π)
@@ -318,6 +320,8 @@ In the case of a complex interval `x`, this is semantically equivalent to
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> isguaranteed(bareinterval(1))
 true
 
@@ -357,19 +361,21 @@ See also: [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref).
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> interval(1//1, π)
-Interval{Rational{Int64}}(1//1, 85563208//27235615, com)
+Interval{Rational{Int64}}(1//1, 85563208//27235615, com, true)
 
 julia> interval(Rational{Int32}, 1//1, π)
-Interval{Rational{Int32}}(1//1, 85563208//27235615, com)
+Interval{Rational{Int32}}(1//1, 85563208//27235615, com, true)
 
 julia> interval(1, π)
-Interval{Float64}(1.0, 3.1415926535897936, com)
+Interval{Float64}(1.0, 3.1415926535897936, com, true)
 
 julia> interval(BigFloat, 1, π)
-Interval{BigFloat}(1.0, 3.141592653589793238462643383279502884197169399375105820974944592307816406286233, com)
+Interval{BigFloat}(1.0, 3.141592653589793238462643383279502884197169399375105820974944592307816406286233, com, true)
 ```
 """
 function interval(::Type{T}, a, b, d::Decoration = com; format::Symbol = :infsup) where {T}
@@ -574,16 +580,18 @@ to `parse(Interval{T}, string(x))` if `x` is a `Number`.
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> x = IntervalArithmetic.atomic(Float64, 0.1)
-Interval{Float64}(0.09999999999999999, 0.1, com)
+Interval{Float64}(0.09999999999999999, 0.1, com, true)
 
 julia> in_interval(1//10, IntervalArithmetic.atomic(Float64, 0.1))
 true
 
 julia> IntervalArithmetic.atomic(Float64, 0.3)
-Interval{Float64}(0.3, 0.30000000000000004, com)
+Interval{Float64}(0.3, 0.30000000000000004, com, true)
 
 julia> in_interval(3//10, IntervalArithmetic.atomic(Float64, 0.3))
 true
@@ -615,6 +623,8 @@ constructor [`atomic`](@ref).
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> @macroexpand @interval sin(1) # Float64 is the default bound type
@@ -624,7 +634,7 @@ julia> @macroexpand @interval Float32 sin(1)
 :(sin(IntervalArithmetic.atomic(Float32, 1)))
 
 julia> @interval Float64 sin(1) exp(1)
-Interval{Float64}(0.8414709848078965, 2.7182818284590455, com)
+Interval{Float64}(0.8414709848078965, 2.7182818284590455, com, true)
 ```
 """
 macro interval(T, expr)

src/intervals/exact_literals.jl

@@ -26,23 +26,27 @@ producing the "NG" flag.
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> 0.5 * interval(1)
-Interval{Float64}(0.5, 0.5, com)_NG
+Interval{Float64}(0.5, 0.5, com, false)
 
 julia> ExactReal(0.5) * interval(1)
-Interval{Float64}(0.5, 0.5, com)
+Interval{Float64}(0.5, 0.5, com, false)
+
+julia> setdisplay(:infsup);
 
 julia> [1, interval(2)]
 2-element Vector{Interval{Float64}}:
- Interval{Float64}(1.0, 1.0, com)_NG
- Interval{Float64}(2.0, 2.0, com)
+ [1.0, 1.0]_com_NG
+ [2.0, 2.0]_com
 
 julia> [ExactReal(1), interval(2)]
 2-element Vector{Interval{Float64}}:
- Interval{Float64}(1.0, 1.0, com)
- Interval{Float64}(2.0, 2.0, com)
+ [1.0, 1.0]_com
+ [2.0, 2.0]_com
 ```
 
 See also: [`@exact`](@ref).
@@ -206,19 +210,21 @@ macro allows defining generic functions, seamlessly accepting both `Number` and
 # Examples
 
 ```jldoctest
-julia> setdisplay(:full);
+julia> using IntervalArithmetic
+
+julia> setdisplay(:infsup);
 
-julia> f(x) = 1.2*x + 0.1
+julia> f(x) = 1.2 * x + 0.1
 f (generic function with 1 method)
 
 julia> f(interval(1, 2))
-Interval{Float64}(1.2999999999999998, 2.5, com)_NG
+[1.29999, 2.5]_com_NG
 
-julia> @exact g(x) = 1.2*x + 0.1
+julia> @exact g(x) = 1.2 * x + 0.1
 g (generic function with 1 method)
 
 julia> g(interval(1, 2))
-Interval{Float64}(1.2999999999999998, 2.5, com)
+[1.29999, 2.5]_com
 
 julia> g(1.4)
 1.78

src/intervals/parsing.jl

@@ -7,13 +7,15 @@ equivalent to `parse(Interval{[DEFAULT BOUND TYPE]}, "str")`.
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> I"[3, 4]"
-Interval{Float64}(3.0, 4.0, com)
+Interval{Float64}(3.0, 4.0, com, true)
 
 julia> I"0.1"
-Interval{Float64}(0.09999999999999999, 0.1, com)
+Interval{Float64}(0.09999999999999999, 0.1, com, true)
 
 julia> in_interval(1//10, I"0.1")
 true
@@ -57,6 +59,8 @@ For more details, see sections 9.7 and 12.11 of the IEEE Standard 1788-2015.
 # Examples
 
 ```jldoctest
+julia> using IntervalArithmetic
+
 julia> setdisplay(:full);
 
 julia> parse(BareInterval{Float64}, "[1, 2]")
@@ -72,13 +76,13 @@ julia> parse(BareInterval{Float64}, "6.42?2e2")
 BareInterval{Float64}(640.0, 644.0)
 
 julia> parse(Interval{Float64}, "[1, 2]")
-Interval{Float64}(1.0, 2.0, com)
+Interval{Float64}(1.0, 2.0, com, true)
 
 julia> parse(Interval{Float64}, "[1, 2]_def")
-Interval{Float64}(1.0, 2.0, def)
+Interval{Float64}(1.0, 2.0, def, true)
 
 julia> parse(Interval{Float64}, "[1, 1e400]_com")
-Interval{Float64}(1.0, Inf, dac)
+Interval{Float64}(1.0, Inf, dac, true)
 ```
 """
 function Base.parse(::Type{BareInterval{T}}, str::AbstractString) where {T<:NumTypes}

src/piecewise.jl

@@ -103,14 +103,18 @@ Return an interval containing only the value for an interval input,
 and the value directly otherwise.
 
 ```jldoctest
+julia> using IntervalArithmetic
+
+julia> setdisplay(:full);
+
 julia> c = Constant(1.2)
 Constant{Float64}(1.2)
 
 julia> c(22.2)
 1.2
 
 julia> c(interval(0, 1.3))
-Interval{Float64}(1.2, 1.2, com)
+Interval{Float64}(1.2, 1.2, com, true)
 ```
 
 Note that this is not equivalent to `Returns(value)` from base,
@@ -131,7 +135,11 @@ end
 A function defined by pieces (each associating a domain to a function).
 Support both intervals and standard numbers.
 
-```jl
+```jldoctest
+julia> using IntervalArithmetic
+
+julia> setdisplay(:full);
+
 julia> myabs = Piecewise(
           Domain{:open, :closed}(-Inf, 0) => x -> -x,
           Domain{:open, :open}(0, Inf) => identity
@@ -144,7 +152,7 @@ julia> myabs(-22.3)
 22.3
 
 julia> myabs(interval(-5, 5))
-Interval{Float64}(0.0, 5.0, def)
+Interval{Float64}(0.0, 5.0, def, true)
 ```
 
 For constant pieces, it is recommended to use `Constant`
@@ -203,7 +211,7 @@ function Piecewise(
     if length(domains) != length(fs)
         throw(ArgumentError("the number of domains and the number of functions don't match"))
     end
-    
+
     if length(domains) - 1 != length(continuity)
         n = length(domains)
         throw(ArgumentError("$(length(sub)) junction points but $(n - 1) are expected based on the number of domains ($n)"))
@@ -251,7 +259,7 @@ end
 function Base.show(io::IO, ::MIME"text/plain", piecewise::Piecewise)
     n = length(pieces(piecewise))
     print(io, "Piecewise function with $n pieces:")
-    
+
     for (domain, f) in pieces(piecewise)
         println(io)
         print(io, "  $(domain_string(domain)) -> $(repr(f))")
@@ -292,7 +300,7 @@ function (piecewise::Piecewise)(X::Interval{T}) where {T}
     if !in_domain(input_domain, piecewise)
         dec = trv
     elseif any(x -> in_domain(x, input_domain), discontinuities(piecewise))
-        dec = def 
+        dec = def
     else
         dec = com
     end
@@ -313,4 +321,4 @@ function (piecewise::Piecewise)(x::Real)
         (in_domain(x, domain)) && return f(x)
     end
     throw(DomainError(x, "piecewise function was called outside of its domain $(domain_string(piecewise))"))
-end
+end

src/symbols.jl

@@ -27,10 +27,10 @@ julia> using IntervalArithmetic.Symbols
 julia> setdisplay(:full);
 
 julia> (1//1)..π
-Interval{Rational{Int64}}(1//1, 85563208//27235615, com)
+Interval{Rational{Int64}}(1//1, 85563208//27235615, com, true)
 
 julia> 0.1..0.3
-Interval{Float64}(0.1, 0.3, com)
+Interval{Float64}(0.1, 0.3, com, true)
 ```
 """
 ..(a, b) = interval(a, b; format = :infsup)
@@ -60,10 +60,10 @@ julia> using IntervalArithmetic.Symbols
 julia> setdisplay(:full);
 
 julia> 0 ± π
-Interval{Float64}(-3.1415926535897936, 3.1415926535897936, com)
+Interval{Float64}(-3.1415926535897936, 3.1415926535897936, com, true)
 
 julia> 0//1 ± π
-Interval{Rational{Int64}}(-85563208//27235615, 85563208//27235615, com)
+Interval{Rational{Int64}}(-85563208//27235615, 85563208//27235615, com, true)
 ```
 """
 ±(m, r) = interval(m, r; format = :midpoint)

test/interval_tests/display.jl

@@ -125,15 +125,15 @@ setprecision(BigFloat, 256) do
             @test sprint(show, MIME("text/plain"), emptyinterval()) == "∅"
             @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "∅_NG"
 
-            @test sprint(show, MIME("text/plain"), a)    == "Interval{Float64}(1.0, 2.0, com)"
-            @test sprint(show, MIME("text/plain"), a_NG) == "Interval{Float64}(1.0, 2.0, com)_NG"
-            @test sprint(show, MIME("text/plain"), b)    == "Interval{Float64}(-2.2250738585072014e-308, 1.3, com)"
-            @test sprint(show, MIME("text/plain"), b32)  == "Interval{Float32}(-1.1754944f-38, 1.3f0, com)"
-            @test sprint(show, MIME("text/plain"), b16)  == "Interval{Float16}(Float16(-6.104e-5), Float16(1.3), com)"
-            @test sprint(show, MIME("text/plain"), br)   == "Interval{Rational{Int64}}(-11//10, 13//10, com)"
-            @test sprint(show, MIME("text/plain"), c)    == "Interval{Float64}(-1.0, Inf, dac)"
+            @test sprint(show, MIME("text/plain"), a)    == "Interval{Float64}(1.0, 2.0, com, true)"
+            @test sprint(show, MIME("text/plain"), a_NG) == "Interval{Float64}(1.0, 2.0, com, false)"
+            @test sprint(show, MIME("text/plain"), b)    == "Interval{Float64}(-2.2250738585072014e-308, 1.3, com, true)"
+            @test sprint(show, MIME("text/plain"), b32)  == "Interval{Float32}(-1.1754944f-38, 1.3f0, com, true)"
+            @test sprint(show, MIME("text/plain"), b16)  == "Interval{Float16}(Float16(-6.104e-5), Float16(1.3), com, true)"
+            @test sprint(show, MIME("text/plain"), br)   == "Interval{Rational{Int64}}(-11//10, 13//10, com, true)"
+            @test sprint(show, MIME("text/plain"), c)    == "Interval{Float64}(-1.0, Inf, dac, true)"
             @test sprint(show, MIME("text/plain"), large_expo) ==
-                "Interval{BigFloat}(0.0, $(sup(large_expo)), com)"
+                "Interval{BigFloat}(0.0, $(sup(large_expo)), com, true)"
         end
 
         @testset "Midpoint format" begin
@@ -208,9 +208,9 @@ setprecision(BigFloat, 256) do
             # `sigdigits` and `decorations` keywords are not taken into account for format `:full`
             setdisplay(:full; sigdigits = 100, decorations = false)
 
-            @test sprint(show, MIME("text/plain"), a) == "Interval{Float64}(0.0, 2.0, com) + im*Interval{Float64}(1.0, 1.0, com)"
-            @test sprint(show, MIME("text/plain"), b) == "Interval{Float64}(0.0, 2.0, com) - im*Interval{Float64}(1.0, 1.0, com)"
-            @test sprint(show, MIME("text/plain"), c) == "Interval{Float64}(0.0, 1.0e-70, com) - im*Interval{Float64}(1.0e-70, 1.0e-70, com)"
+            @test sprint(show, MIME("text/plain"), a) == "Interval{Float64}(0.0, 2.0, com, true) + im*Interval{Float64}(1.0, 1.0, com, true)"
+            @test sprint(show, MIME("text/plain"), b) == "Interval{Float64}(0.0, 2.0, com, true) - im*Interval{Float64}(1.0, 1.0, com, true)"
+            @test sprint(show, MIME("text/plain"), c) == "Interval{Float64}(0.0, 1.0e-70, com, true) - im*Interval{Float64}(1.0e-70, 1.0e-70, com, true)"
         end
 
         @testset "Midpoint format" begin