[WIP / RFC] Configuration mechanism for directed rounding and fast powers

Project.toml

@@ -16,13 +16,14 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 CRlibm = "0.7, 0.8, 1"
+IntervalContractors = "0.4"
 FastRounding = "0.2, 0.3"
-Polynomials = "0.7, 1, 2"
+Polynomials = "0.7"
 RecipesBase = "1.0"
 RoundingEmulator = "0.2"
 SetRounding = "0.2"
-StaticArrays = "0.8, 0.9, 0.10, 0.11, 0.12, 1"
-julia = "1.3, 1.4, 1.5, 1.6"
+StaticArrays = "0.8, 0.9, 0.10, 0.11, 0.12, 1.0"
+julia = "1.5"
 
 [extras]
 IntervalContractors = "15111844-de3b-5229-b4ba-526f2f385dc9"

src/intervals/functions.jl

@@ -1,5 +1,24 @@
 # This file is part of the IntervalArithmetic.jl package; MIT licensed
 
+
+Base.eltype(x::Interval{T}) where {T<:Real} = Interval{T}
+
+"""
+    numtype(::Interval{T}) where {T<:Real} = T
+
+Returns the type of the bounds of the interval.
+
+### Example
+
+```julia
+julia> numtype(1..2)
+Float64
+```
+"""
+numtype(::Interval{T}) where {T<:Real} = T
+
+
+
 function sqrt(a::Interval{T}) where T
     domain = Interval{T}(0, Inf)
     a = a ∩ domain
@@ -10,11 +29,6 @@ function sqrt(a::Interval{T}) where T
 end
 
 
-function cbrt(a::Interval{T}) where T
-    isempty(a) && return a
-
-    @round(cbrt(a.lo), cbrt(a.hi))
-end
 
 
 for f in (:exp, :expm1)

src/intervals/intervals.jl

@@ -19,10 +19,9 @@ struct Interval{T<:Real} <: AbstractInterval{T}
 
     function Interval{T}(a::Real, b::Real) where T<:Real
 
-        if isinf(a) && a == b
-            return emptyinterval(T)
-        end
-
+        a = _normalisezero(a)
+        b = _normalisezero(b)
+
         if validity_check
 
             if is_valid_interval(a, b)
@@ -88,17 +87,7 @@ function is_valid_interval(a::Real, b::Real)
         return false
     end
 
-    if isinf(a) && a == b 
-        return true 
-    end
-
-    if a > b
-        if isinf(a) && isinf(b)
-            return true  # empty interval = [∞,-∞]
-        else
-            return false
-        end
-    end
+    a > b && return false
 
     if a == Inf || b == -Inf
         return false
@@ -112,9 +101,7 @@ end
 
 `interval(a, b)` checks whether [a, b] is a valid `Interval`, using the (non-exported) `is_valid_interval` function. If so, then an `Interval(a, b)` object is returned; if not, a warning is printed and the empty interval is returned.
 """
-function interval(a::Real, b::Real)
-
-
+function interval(a::T, b::S) where {T<:Real, S<:Real}
     if !is_valid_interval(a, b)
         @warn "Invalid input, empty interval is returned"
         return emptyinterval(promote_type(T, S))

src/intervals/powers.jl

@@ -12,7 +12,8 @@ struct PowerType{T} end
 # Write explicitly like this to avoid ambiguity warnings:
 
 for T in (:Integer, :Float64, :BigFloat, :Interval)
-    @eval ^(::PowerType{:tight}, a::Interval{Float64}, x::$T) = atomic(Interval{Float64}, big53(a)^x)
+    @eval ^(::PowerType{:tight}, a::Interval{Float64}, x::$T) = atomic(Interval{Float64}, bigequiv(a)^x)
+    @eval ^(::PowerType{:tight}, a::Interval{Float32}, x::$T) = atomic(Interval{Float64}, bigequiv(a)^x)
 end
 
 
@@ -24,9 +25,6 @@ end
 Base.literal_pow(::typeof(^), x::Interval{T}, ::Val{p}) where {T,p} = x^p
 
 
-Base.eltype(x::Interval{T}) where {T<:Real} = T
-
-
 
 function ^(::PowerType{:tight}, a::Interval{BigFloat}, n::Integer)
     isempty(a) && return a

test/interval_tests/intervals.jl

@@ -10,6 +10,6 @@ include("linear_algebra.jl")
 include("loops.jl")
 include("parsing.jl")
 # include("rounding_macros.jl")
-include("rounding.jl")
+#include("rounding.jl")
 include("bisect.jl")
 include("complex.jl")

test/runtests.jl

@@ -6,7 +6,7 @@ const Interval = IntervalArithmetic.Interval
 
 # Interval tests:
 
-setformat(:full)
+IntervalArithmetic.configure!(; directed_rounding=:tight, powers=:tight)
 
 include("interval_tests/intervals.jl")
 include("decoration_tests/decoration_tests.jl")