diff --git a/Project.toml b/Project.toml index ec3b1115a..026cf7011 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "IntervalArithmetic" uuid = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" repo = "https://github.com/JuliaIntervals/IntervalArithmetic.jl.git" -version = "0.21.1" +version = "0.21.2" [deps] CRlibm = "96374032-68de-5a5b-8d9e-752f78720389" diff --git a/docs/make.jl b/docs/make.jl index 5b5944a47..ca9c0f8ec 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -22,10 +22,10 @@ makedocs(; "Manual" => [ "Constructing intervals" => "manual/construction.md", "Usage" => "manual/usage.md", - "Decorations" => "manual/decorations.md", "API" => "manual/api.md" ] - ] + ], + warnonly = true ) deploydocs(; diff --git a/docs/src/index.md b/docs/src/index.md index 0aee95580..31843e19d 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -25,18 +25,3 @@ If you use the IntervalArithmetic library in your publication, research, teachin - [MPFI.jl](https://github.com/andrioni/MPFI.jl), a Julia wrapper around the [MPFI C library](http://perso.ens-lyon.fr/nathalie.revol/software.html), a multiple-precision interval arithmetic library based on MPFR - [Intervals.jl](https://github.com/invenia/Intervals.jl), an alternative implementation of basic interval functions by Invenia Technical Computing - - - -## History - -This project began in 2014 during a masters' course in the postgraduate programs of Mathematics and Physics at the Universidad Nacional Autónoma de México. It was initially written in Python, then reinitiated in 2015 and rewritten in Julia. We thank the participants of the courses for their contribution, energy and ideas. - - -## Support - -Financial support is acknowledged from DGAPA-UNAM PAPIME grants PE-105911 and PE-107114, and DGAPA-UNAM PAPIIT grant IN-117214. - -Luis Benet acknowledges support from *Cátedra Marcos Moshinsky* (2013). - -David P. Sanders acknowledges a sabbatical fellowship from CONACYT and thanks Alan Edelman and the Julia group at MIT for hosting his sabbatical visit. diff --git a/docs/src/manual/construction.md b/docs/src/manual/construction.md index 1d2d41d95..d516f8274 100644 --- a/docs/src/manual/construction.md +++ b/docs/src/manual/construction.md @@ -1,46 +1,188 @@ -# Constructing intervals - -Constructing an interval is the most basic operation in the library. The [`interval`](@ref) constructor is the standard way to create an interval. It accepts one or two values, and an optional bound type. +The library provides two interval types. The first one is [`BareInterval`](@ref), corresponding to a basic implementation of intervals, stored by their infimum and supremum. The second type is [`Interval`](@ref) and builds on top of bare intervals, with the additional fields `decoration` and `isguaranteed`. See the sections below. ```@repl construction using IntervalArithmetic -setformat(:full) # print the interval in full -interval(0.1) # interval(Float64, 0.1) -interval(0.1, 0.2) # interval(Float64, 0.1, 0.2) -interval(3.1f0) # interval(Float32, 3.1f0) -interval(π) # interval(Float64, π) -interval(BigFloat, π) -interval(Inf) # not valid since infinity is not part of an interval -interval(3, 2) # not valid since the lower bound is strictly greater than the upper bound +setdisplay(:full) # print the interval in full +bareinterval(1, π) # `bareinterval(Float64, 1, π)` +interval(1, π) # `interval(Float64, 1, π)`, interval decorated with `com` (common) ``` -The submodule `IntervalArithmetic.Symbols` exports the infix operator `..` as an alias for `interval`. +Therefore, we **strongly recommend the use of [`Interval`](@ref) over [`BareInterval`](@ref)** to better track the effect of functions according to the IEEE Standard 1788-2015 specifications. For instance, taking the square root of an interval discards the negative part of the interval, without any notice for bare intervals: ```@repl construction -using IntervalArithmetic.Symbols -0.1..0.2 # interval(0.1, 0.2) +sqrt(bareinterval(-1, 1)) # `sqrt(bareinterval(0, 1))` +sqrt(interval(-1, 1)) # interval decorated with `trv` (trivial) +``` + + + +### Decorations + +A *decoration* is a label that indicates the status of a given interval. Decorated intervals provide valuable information on the result of evaluating a function on an initial interval. + +Upon the application of a function ``f`` on an interval ``x``, the resulting interval ``f(x)`` has either one of the following decorations: + +- `com` (common): ``x`` is a closed, bounded, non-empty subset of the domain of ``f``, ``f`` is continuous on the interval ``x``, and ``f(x)`` is bounded. + +- `dac` (defined and continuous): ``x`` is a non-empty subset of the domain of ``f``, and ``f`` is continuous on ``x``. + +- `def` (defined): ``x`` is a non-empty subset of the domain of ``f``; in other words, ``f`` is defined at each point of ``x``. + +- `trv` (trivial): ``f(x)`` carries no meaningful information. + +- `ill` (ill-formed): ``f(x)`` is Not an Interval (NaI). + +Each decoration is paired with an integer as follows: `ill = 0`, `trv = 1`, `def = 2`, `dac = 3` and `com = 4`. Then, decorations degrade according to the propagation order `com > dac > def > trv > ill`. + +One can specify a decoration when constructing intervals. Otherwise, the interval is initialised with a decoration according to the underlying bare interval: + +- `com`: non-empty and bounded. + +- `dac`: unbounded. + +- `trv`: empty. + +- `ill`: NaI. + + +#### Examples + +##### Common + +```@repl construction +x = interval(0.5, 3) +sqrt(x) +``` + +Both input `x` and output `sqrt(x)` are common intervals since they are closed, bounded, non-empty and that ``\sqrt`` is continuous over ``[1/2, 3]``. + +Observe that these decorations, together with the fact that any element of the interval `sqrt(x)` is also in the interval `x`, imply that the [Schauder Fixed-Point Theorem](https://en.wikipedia.org/wiki/Schauder_fixed-point_theorem) is satisfied. More precisely, this computation proves the existence of a fixed-point of ``\sqrt`` in ``[1/2, 3]`` (in this simple example, ``\sqrt(1) = 1``). + +##### Defined and continuous + +```@repl construction +x = interval(3, Inf) +sqrt(x) +``` + +Both the intervals are unbounded, hence the maximum possible decoration is `dac`. + +Note that overflows can also produce the decoration `dac`: + +```@repl construction +x = interval(floatmax(Float64)) +x + interval(1) ``` -The [`±`](@ref) (`\pm`) infix operator creates the interval from the midpoint and the radius. +##### Defined and continuous ```@repl construction -0 ± 1 +x = interval(-3, 4) +sign(x) ``` -The various string formats are as follows: -- No string parameter or `Empty` string ("[Empty]") returns an empty interval. -- `entire` ("[entire]") and "[,]" string returns entireinterval -- "[nai]" returns `Nai{Type}` -- "[m]" returns `Interval(m,m)` -- "[l, r]" returns `Interval(l, r)` -- "m?r" returns `Interval(m-r, m+r)` -- "m?ren" returns `Interval((m-r)en, (m+r)en)` -- "m?ru" or "m?rd" returns `Interval(m, m+r)` or `Interval(m-r, m)` respectively -- "m?" returns `Interval(m + 5 precision units, m - 5 precision units)` -- "m??" returns `Interval(-Inf, +Inf)` -- "m??u" or "m??d" returns `Interval(m, +Inf)` or `Interval(-Inf, m) respectively` - -!!! warning +The ``\sign`` function is discontinuous at ``0``, but is defined everywhere on the input interval, so the decoration of the result is `def`. + +##### Trivial + +```@repl construction +x = interval(-3.5, 4) +sqrt(x) +``` + +The negative part of `x` is discarded before evaluating the ``\sqrt`` function since its domain is ``[0, \infty)``. The process of discarding parts of an interval that are not in the domain of a function is called *loose evaluation*. This event has been recorded by degrading the decoration of the resulting interval to `trv`, indicating that nothing is known about the relationship between `x` and `sqrt(x)`. + +In this case, we know why the decoration was reduced to `trv`. Generally, if this were just a single step in a longer calculation, a resulting decoration `trv` shows only that something like this occured at some step. + +For instance, + +```@repl construction +f = asin ∘ sqrt +x = interval(-3, 3) +f(x) +y = interval(0, 3) +f(y) +``` + +In both cases, `asin(sqrt(X))` gives a result with the decoration `trv`; to find out where things went wrong, the function must be analyzed. + +```@repl construction +sqrt(x) # `f(x)` has the decoration is `trv` since `x` contains negative values +sqrt(y) # the decoration is `com` +asin(sqrt(y)) # `f(x)` has the decoration is `trv` since `sqrt(y)` contains values stricly greater than `1` +``` + +This shows that loose evaluation occurred in different parts of `f` for `x` and `y`. + +!!! danger + The decoration `trv` is an indicator of information loss. Often this also reveals that something unexpected occured. Therefore, any interval marked by this decoration may not be trusted and the code may need to be revised. + +##### Ill-formed + +```@repl construction +interval(2, 1) +interval(NaN) +``` + +These are all examples of ill-formed intervals, resulting in the decoration `ill`. + +!!! danger + The decoration `ill` is an indicator that an error has occured. Therefore, any interval marked by this decoration cannot be trusted and the code needs to be debugged. + + + +### Guarantee + +A *guarantee* is yet another label, independent of decorations, and not described by the IEEE Standard 1788-2015 specifications. Its purpose is to accomodate for Julia's extensive conversion and promotion system, while retaining reliability in computations. Specifically, an interval `x` constructed via [`interval`](@ref) satisfies `isguaranteed(x) == true`. However, if a call to `convert(::Type{<:Interval}, ::Real)` occurs, then the resulting interval `x` satisfies `isguaranteed(x) == false`. + +In contrast, a [`BareInterval`](@ref) can only be constructed via [`bareinterval`](@ref), it is not a subtype of `Real`, and there are no allowed conversion with `Number`. Thus, this interval type is always guaranteed. + +!!! danger + A user interested in validated numerics should **always** have a resulting interval for which [`isguaranteed`](@ref) is `true`. + + + +## More constructors + +The submodule `IntervalArithmetic.Symbols` exports the infix operator `..` and `±` as an alias for `interval`; this submodule must be explicitly imported. + +```@repl construction +using IntervalArithmetic.Symbols +0.1 .. 0.2 # interval(0.1, 0.2; format = :standard) +0.1 ± 0.2 # interval(0.1, 0.2; format = :midpoint) +``` + +Moreover, one can parse strings into intervals. The various string formats are the following: + +- `"[m]"` is equivalent to `interval(m, m)`. + +- `"[l, r]"` is equivalent to `interval(l, r)`. + +- `"m?r"` is equivalent to `interval(m-r, m+r)`. + +- `"m?ren"` is equivalent to `interval((m-r)*1en, (m+r)*1en)`. + +- `"m?rd"` is equivalent to `interval(m-r, m)`. + +- `"m?ru"` is equivalent to `interval(m, m+r)`. + +- `"m?"` is equivalent to `interval(m + 5 precision units, m - 5 precision units)`. + +- `"m??"` is equivalent to `interval(-Inf, +Inf)`. + +- `"m??d"` is equivalent to `interval(-Inf, m)`. + +- `"m??u"` is equivalent to `interval(m, +Inf)`. + +- `"[Entire]"`, `"[entire]"` and `"[,]"` are equivalent to `entireinterval()`. + +- `"[Empty]"`, `"[empty]"` and `"[]"` are equivalent to `emptyinterval()`. + +- `"[nai]"` and any other unsupported string formats are equivalent to `nai()`. + +To add a specific decoration, add `"_com"`, `"_dac"`, `"_dec"`, `"_trv"` and `"_ill"` at the end of the string. + +!!! danger Most real numbers cannot be exactly represented by floating-points. In such cases, the literal expression is rounded at parse time. To construct an interval enclosing the true real number, one must rely on the string constructor mentioned above. For instance, consider @@ -49,15 +191,15 @@ The various string formats are as follows: x = 0.1 ``` - This appears to store the real number ``1/10`` in a variable `x` of type `Float64`. Yet, + This appears to store the real number ``1/10`` in a variable `x` of type `Float64`. Yet, ```@repl construction x > 1//10 ``` - Hence, the floating-point `0.1` is (slightly) greater than the real number ``1/10`` since ``1/10`` *cannot be represented exactly in binary floating-point arithmetic, at any precision*. The true value must be approximated by a floating-point number with fixed precision -- this procedure is called rounding. + Hence, the floating-point `0.1` is (slightly) greater than the real number ``1/10`` since ``1/10`` **cannot be represented exactly in binary floating-point arithmetic, at any precision**. The true value must be approximated by a floating-point number with fixed precision -- this procedure is called rounding. - In particular, this implies that `interval(0.1)` *does not* contain the real number ``1/10``. A valid interval containing the real number ``1/10`` can be constructed by + In particular, this implies that `interval(0.1)` **does not** contain the real number ``1/10``. A valid interval containing the real number ``1/10`` can be constructed by ```@repl construction I"0.1" diff --git a/docs/src/manual/decorations.md b/docs/src/manual/decorations.md deleted file mode 100644 index cab769a4b..000000000 --- a/docs/src/manual/decorations.md +++ /dev/null @@ -1,138 +0,0 @@ -```@meta -DocTestSetup = quote - using IntervalArithmetic -end -``` - -# Decorations - -Decorations are flags, or labels, attached to intervals to indicate the status of a given interval as the result of evaluating a function on an initial interval. The combination of an interval $X$ and a decoration $d$ is called a decorated interval. - -The allowed decorations and their ordering are as follows: -`com` > `dac` > `def` > `trv` > `ill`. - -Suppose that a decorated interval $(X, d)$ is the result of evaluating a function $f$, or the composition of a sequence of functions, on an initial decorated interval $(X_0, d_0)$. The meaning of the resulting decoration $d$ is as follows: - -- `com` ("common"): $X$ is a closed, bounded, nonempty subset of the domain of $f$; $f$ is continuous on the interval $X$; and the resulting interval $f(X)$ is bounded. - -- `dac` ("defined & continuous"): $X$ is a nonempty subset of $\mathrm{Dom}(f)$, and $f$ is continuous on $X$. - -- `def` ("defined"): $X$ is a nonempty subset of $\mathrm{Dom}(f)$, i.e. $f$ is defined at each point of $X$. - -- `trv` ("trivial"): always true; gives no information - -- `ill` ("ill-formed"): Not an Interval (an error occurred), e.g. $\mathrm{Dom}(f) = \emptyset$. - -An example will be given at the end of this section. - -## Initialisation - -The simplest way to create a `DecoratedInterval` is as follows: -``` -julia> X = DecoratedInterval(3, 4) -[3, 4] -``` - -By default, decorations are not displayed. The following turns on display of decorations: -``` -julia> setformat(decorations=true) -Display parameters: -- format: standard -- decorations: true -- significant figures: 6 - -julia> X -[3, 4]_com -``` - -To parse string, for decorated interval add `_dec` at the end of the string otherwise decoration is determined using `decoration` function. - -If no decoration is explicitly specified when a `DecoratedInterval` is created, then it is initialised with a decoration according to its interval `X`: - -- `com`: if `X` is nonempty and bounded; -- `dac` if `X` is unbounded; -- `trv` if `X` is empty. - - -An explicit decoration may be provided for advanced use: -``` -julia> DecoratedInterval(3, 4, dac) -[3, 4]_dac - -julia> DecoratedInterval(X, def) -[3, 4]_def -``` -Here, a new `DecoratedInterval` was created by extracting the interval from another one and appending a different decoration. - -## Action of functions - -A decoration is the combination of an interval together with the sequence of functions that it has passed through. Here are some examples: - -``` -julia> X1 = DecoratedInterval(0.5, 3) -[0.5, 3]_com - -julia> sqrt(X1) -[0.707106, 1.73206]_com -``` -In this case, both input and output are "common" intervals, meaning that they are closed and bounded, and that the resulting function is continuous over the input interval, so that fixed-point theorems may be applied. Since `sqrt(X1) ⊆ X1`, we know that there must be a fixed point of the function inside the interval `X1` (in this case, `sqrt(1) == 1`). - -``` -julia> X2 = DecoratedInterval(3, ∞) -[3, ∞]_dac - -julia> sqrt(X2) -[1.73205, ∞]_dac -``` -Since the intervals are unbounded here, the maximum decoration possible is `dac`. - -``` -julia> X3 = DecoratedInterval(-3, 4) -[-3, 4]_com - -julia> sign(X3) -[-1, 1]_def -``` -The `sign` function is discontinuous at 0, but is defined everywhere on the input interval, so the decoration is `def`. - -``` -julia> X4 = DecoratedInterval(-3.5, 4.1) -[-3.5, 4.1]_com - -julia> sqrt(X4) -[0, 2.02485]_trv -``` -The negative part of `X` is discarded by the `sqrt` function, since its domain is `[0,∞]`. (This process of discarding parts of the input interval that are not in the domain is called "loose evaluation".) The fact that this occurred is, however, recorded by the resulting decoration, `trv`, indicating a loss of information: "nothing is known" about the relationship between the output interval and the input. - - -In this case, we know why the decoration was reduced to `trv`. But if this were just a single step in a longer calculation, a resulting `trv` decoration shows only that something like this happened *at some step*. For example: - -``` -julia> X5 = DecoratedInterval(-3, 3) -[-3, 3]_com - -julia> asin(sqrt(X5)) -[0, 1.5708]_trv - -julia> X6 = DecoratedInterval(0, 3) -[0, 3]_com - -julia> asin(sqrt(X6)) -[0, 1.5708]_trv -``` -In both cases, `asin(sqrt(X))` gives a result with a `trv` decoration, but -we do not know at which step this happened, unless we break down the function into its constituent parts: -``` -julia> sqrt(X5) -[0, 1.73206]_trv - -julia> sqrt(X6) -[0, 1.73206]_com -``` -This shows that loose evaluation occurred in different parts of the expression in the two different cases. - -In general, the `trv` decoration is thus used only to signal that "something unexpected" happened during the calculation. Often this is later used to split up the original interval into pieces and reevaluate the function on each piece to refine the information that is obtained about the function. - -```@meta -DocTestSetup = nothing -``` diff --git a/docs/src/manual/usage.md b/docs/src/manual/usage.md index 8bd7c6cd9..a8aa9ec34 100644 --- a/docs/src/manual/usage.md +++ b/docs/src/manual/usage.md @@ -1,33 +1,31 @@ ## Display modes -There are several useful output representations for intervals, some of which we have already touched on. The display is controlled globally by the `setformat` function, which has -the following options, specified by keyword arguments (type `?setformat` to get help at the REPL): +There are several useful output representations for intervals. The display is controlled globally by the [`setdisplay`](@ref) function, which has the following options: -- `format`: interval output format +- interval output format: - - `:standard`: output of the form `[1.09999, 1.30001]`, rounded to the current number of significant figures + - `:standard`: output of the form `[1.09999, 1.30001]`, rounded to the current number of significant figures. - - `:full`: output of the form `Interval(1.0999999999999999, 1.3)`, as in the `showfull` function + - `:full`: output of the form `Interval(1.0999999999999999, 1.3)`, as in the `showfull` function. - - `:midpoint`: output in the midpoint-radius form, e.g. `1.2 ± 0.100001` + - `:midpoint`: output in the midpoint-radius form, e.g. `1.2 ± 0.100001`. -- `sigfigs`: number of significant figures to show in standard mode +- `sigfigs :: Int` keyword argument: number of significant figures to show in standard mode. -- `decorations` (boolean): whether to show [decorations](decorations.md) or not +- `decorations :: Bool` keyword argument: whether to show [decorations](decorations.md) or not. ```@repl using IntervalArithmetic -setformat() # default values -a = interval(1.1, pi) -setformat(; sigdigits = 10) +a = interval(1.1, pi) # default display +setdisplay(; sigdigits = 10) a -setformat(:full) +setdisplay(:full) a -setformat(:midpoint) +setdisplay(:midpoint) a -setformat(; sigdigits = 4) +setdisplay(; sigdigits = 4) a -setformat(:standard) +setdisplay(:standard) a ``` @@ -38,14 +36,14 @@ a Basic arithmetic operations (`+`, `-`, `*`, `/`, `^`) are defined for pairs of intervals in a standard way: the result is the smallest interval containing the result of operating with each element of each interval. More precisely, for two intervals ``X`` and ``Y`` and an operation ``\bigcirc``, we define the operation on the two intervals by ```math -X \bigcirc Y := \{ x \bigcirc y \,:\, x \in X \text{ and } y \in Y \}. +X \bigcirc Y \bydef \{ x \bigcirc y \,:\, x \in X \text{ and } y \in Y \}. ``` For example, ```@repl usage using IntervalArithmetic -setformat(:full) +setdisplay(:full) X = interval(0, 1) Y = interval(1, 2) X + Y @@ -61,7 +59,7 @@ X - X ## Elementary functions -The main elementary functions are implemented. The functions for `Interval{Float64}` internally use routines from the correctly-rounded [`CRlibm` library](https://github.com/dpsanders/CRlibm.jl) where possible, i.e. for the following functions defined in that library: +The main elementary functions are implemented. The functions for `Interval{Float64}` internally use routines from the correctly-rounded [CRlibm library](https://github.com/dpsanders/CRlibm.jl) where possible, i.e. for the following functions defined in that library: - `exp`, `expm1` - `log`, `log1p`, `log2`, `log10` - `sin`, `cos`, `tan` @@ -69,13 +67,13 @@ The main elementary functions are implemented. The functions for `Interval{Float - `sinh`, `cosh` Other functions that are implemented for `Interval{Float64}` internally convert -to an `Interval{BigFloat}`, and then use routines from the `MPFR` library +to an `Interval{BigFloat}`, and then use routines from the MPFR library (`BigFloat` in Julia): - `^` - `exp2`, `exp10` - `atan`, `atanh` -Note, in particular, that in order to obtain correct rounding for the power function (`^`), intervals are converted to and from `BigFloat`; this implies a significant slow-down in this case. +In particular, in order to obtain correct rounding for the power function (`^`), intervals are converted to and from `BigFloat`; this implies a significant slow-down in this case. For example, diff --git a/src/IntervalArithmetic.jl b/src/IntervalArithmetic.jl index 9f116991e..f3257e9d9 100644 --- a/src/IntervalArithmetic.jl +++ b/src/IntervalArithmetic.jl @@ -8,17 +8,15 @@ using SetRounding using EnumX import Base: - +, -, *, /, //, muladd, fma, - ^, sqrt, exp, log, exp2, exp10, log2, log10, inv, cbrt, hypot, - zero, one, eps, typemin, typemax, abs, abs2, min, max, - rad2deg, deg2rad, - sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, sinpi, cospi, sincospi, + +, -, *, /, \, inv, //, muladd, fma, sqrt, sinh, cosh, tanh, coth, csch, sech, asinh, acosh, atanh, acoth, + rad2deg, deg2rad, sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, sinpi, cospi, sincospi, + exp, log, exp2, exp10, log2, log10, cbrt, hypot, ^, + zero, one, eps, typemin, typemax, abs, abs2, min, max, float, big, - floor, ceil, trunc, sign, round, copysign, flipsign, signbit, + floor, ceil, trunc, sign, round, copysign, flipsign, expm1, log1p, precision, - abs, abs2, show, parse, hash @@ -36,39 +34,30 @@ end # include("intervals/intervals.jl") -export Interval, interval, ±, @I_str, - diam, radius, mid, midradius, scaled_mid, mag, mig, hull, +export BareInterval, bareinterval, Interval, interval, decoration, @I_str, + isguaranteed, diam, radius, mid, midradius, scaled_mid, mag, mig, hull, emptyinterval, isempty_interval, isequal_interval, in_interval, issubset_interval, isstrictsubset_interval, precedes, strictprecedes, isweakless, isstrictless, - contains_zero, isthinzero, isthin, isbounded, isunbounded, isdisjoint_interval, intersect_interval, setdiff_interval, entireinterval, isentire_interval, nai, isnai, iscommon, isatomic, inf, sup, bounds, mince, dist, - RoundTiesToEven, RoundTiesToAway, IntervalRounding, cancelminus, cancelplus, - pow, extended_div, nthroot, + fastpow, extended_div, nthroot, nthpow, + bisect, overlap, Overlap -include("bisect.jl") -export bisect - -include("decorations/decorations.jl") -export decoration, DecoratedInterval, com, dac, def, trv, ill - include("rand.jl") -include("parsing.jl") - include("display.jl") -export setformat +export setdisplay include("symbols.jl") diff --git a/src/bisect.jl b/src/bisect.jl deleted file mode 100644 index f6e41d140..000000000 --- a/src/bisect.jl +++ /dev/null @@ -1,24 +0,0 @@ -""" - bisect(X::Interval, α=0.49609375) - -Split the interval `X` at position α; α=0.5 corresponds to the midpoint. -Returns a tuple of the new intervals. -""" -function bisect(X::Interval{T}, α=0.49609375) where {T<:NumTypes} - @assert 0 ≤ α ≤ 1 - - m = scaled_mid(X, α) - - return (unsafe_interval(T, inf(X), m), unsafe_interval(T, m, sup(X))) -end - -""" - mince(x::Interval, n) - -Split `x` in `n` intervals of the same diameter, which are returned -as a vector. -""" -function mince(x::Interval{T}, n) where {T<:NumTypes} - nodes = LinRange(inf(x), sup(x), n+1) - return [unsafe_interval(T, nodes[i], nodes[i+1]) for i in 1:n] -end diff --git a/src/decorations/decorations.jl b/src/decorations/decorations.jl deleted file mode 100644 index 0e630d341..000000000 --- a/src/decorations/decorations.jl +++ /dev/null @@ -1,13 +0,0 @@ -include("intervals.jl") -include("functions.jl") - - -"""`NaI` not-an-interval: [NaN, NaN].""" -nai(::Type{Interval{T}}) where {T<:NumTypes} = nai(T) -nai(::Type{T}) where {T<:NumTypes} = DecoratedInterval(convert(T, NaN), convert(T, NaN), ill) -nai(::Type{<:Real}) = nai(default_numtype()) -nai() = nai(default_numtype()) -nai(::T) where {T} = nai(T) - -isnai(x::Interval) = isnan(inf(x)) || isnan(sup(x)) # || inf(x) > sup(x) || (isinf(inf(x)) && inf(x) == sup(x)) -isnai(x::DecoratedInterval) = isnai(interval(x)) || x.decoration == ill diff --git a/src/decorations/functions.jl b/src/decorations/functions.jl deleted file mode 100644 index 4f194d397..000000000 --- a/src/decorations/functions.jl +++ /dev/null @@ -1,356 +0,0 @@ -# This file is part of the IntervalArithmetic.jl package; MIT licensed - -Base.literal_pow(::typeof(^), x::DecoratedInterval{T}, ::Val{p}) where {T,p} = x^p - - -# zero, one -zero(::DecoratedInterval{T}) where {T<:NumTypes} = DecoratedInterval(zero(T)) -zero(::Type{DecoratedInterval{T}}) where {T<:NumTypes} = DecoratedInterval(zero(T)) -one(::DecoratedInterval{T}) where {T<:NumTypes} = DecoratedInterval(one(T)) -one(::Type{DecoratedInterval{T}}) where {T<:NumTypes} = DecoratedInterval(one(T)) - -## Bool functions - -Base.:(==)(::DecoratedInterval, ::DecoratedInterval) = - throw(ArgumentError("`==` is purposely not supported, use `isequal_interval` instead")) - -const bool_functions = ( - :isempty_interval, :isentire_interval, :isunbounded, :isbounded, - :isthin, :iscommon -) - -const bool_binary_functions = ( - :issubset_interval, :isstrictsubset_interval, :isdisjoint_interval, - :precedes, :strictprecedes, :isweakless, :isstrictless, - :isequal_interval, :overlap -) - -for f in bool_functions - @eval $(f)(xx::DecoratedInterval) = $(f)(interval(xx)) -end - -for f in bool_binary_functions - @eval function $(f)(xx::DecoratedInterval, yy::DecoratedInterval) - (isnai(xx) || isnai(yy)) && return false - $(f)(interval(xx), interval(yy)) - end -end - -in_interval(x::Real, a::DecoratedInterval) = in_interval(x, interval(a)) - - -## scalar functions: mig, mag and friends -scalar_functions = ( - :mig, :mag, :inf, :sup, :mid, :diam, :radius, :eps, :midradius -) - -for f in scalar_functions - @eval $(f)(xx::DecoratedInterval)= $f(interval(xx)) -end - -dist(xx::DecoratedInterval, yy::DecoratedInterval) = dist(interval(xx), interval(yy)) - -## Arithmetic function; / is treated separately -arithm_functions = ( :+, :-, :* ) - -+(xx::DecoratedInterval) = xx --(xx::DecoratedInterval) = DecoratedInterval(-interval(xx), decoration(xx)) -for f in arithm_functions - @eval function $(f)(xx::DecoratedInterval{T}, yy::DecoratedInterval{T}) where T - x = interval(xx) - y = interval(yy) - r = $f(x, y) - dec = min(decoration(xx), decoration(yy), decoration(r)) - DecoratedInterval(r, dec) - end - @eval $(f)(xx::Real, yy::DecoratedInterval) = $(f)(DecoratedInterval(xx), yy) - @eval $(f)(xx::DecoratedInterval, yy::Real) = $(f)(xx, DecoratedInterval(yy)) -end - -# Division -function inv(xx::DecoratedInterval{T}) where T - x = interval(xx) - dx = decoration(xx) - dx = in_interval(zero(T), x) ? min(dx, trv) : dx - r = inv(x) - dx = min(decoration(r), dx) - DecoratedInterval( r, dx ) -end -/(xx::Real, yy::DecoratedInterval) = DecoratedInterval(xx) / yy -/(xx::DecoratedInterval, yy::Real) = xx / DecoratedInterval(yy) -function /(xx::DecoratedInterval{T}, yy::DecoratedInterval{T}) where T - x = interval(xx) - y = interval(yy) - r = x / y - dy = decoration(yy) - dy = in_interval(zero(T), y) ? min(dy, trv) : dy - dy = min(decoration(xx), dy, decoration(r)) - DecoratedInterval(r, dy) -end - -## fma -function fma(xx::DecoratedInterval{T}, yy::DecoratedInterval{T}, zz::DecoratedInterval{T}) where T - r = fma(interval(xx), interval(yy), interval(zz)) - d = min(decoration(xx), decoration(yy), decoration(zz)) - d = min(decoration(r), d) - DecoratedInterval(r, d) -end - - -# power function must be defined separately and carefully -function ^(xx::DecoratedInterval{T}, n::Integer) where T - x = interval(xx) - r = x^n - d = min(decoration(xx), decoration(r)) - n < 0 && in_interval(zero(T), x) && return DecoratedInterval(r, trv) - DecoratedInterval(r, d) -end - -function ^(xx::DecoratedInterval{T}, q::AbstractFloat) where T - x = interval(xx) - r = x^q - d = min(decoration(xx), decoration(r)) - if inf(x) > zero(T) || (inf(x) ≥ zero(T) && q > zero(T)) || - (isinteger(q) && q > zero(q)) || (isinteger(q) && !in_interval(zero(T), x)) - return DecoratedInterval(r, d) - end - DecoratedInterval(r, trv) -end - -function ^(xx::DecoratedInterval{T}, q::Rational{S}) where {T, S<:Integer} - x = interval(xx) - r = x^q - d = min(decoration(xx), decoration(r)) - if inf(x) > zero(T) || (inf(x) ≥ zero(T) && q > zero(T)) || - (isinteger(q) && q > zero(q)) || (isinteger(q) && !in_interval(zero(T), x)) - return DecoratedInterval(r, d) - end - DecoratedInterval(r, trv) -end - -function ^(xx::DecoratedInterval{T}, qq::DecoratedInterval{S}) where {T,S} - x = interval(xx) - q = interval(qq) - r = x^q - d = min(decoration(xx), decoration(qq), decoration(r)) - if inf(x) > zero(T) || (inf(x) ≥ zero(T) && inf(q) > zero(T)) || - (isthin(q) && isinteger(inf(q)) && inf(q) > zero(T)) || - (isthin(q) && isinteger(inf(q)) && !in_interval(zero(T), x)) - return DecoratedInterval(r, d) - end - DecoratedInterval(r, trv) -end - -^(xx::DecoratedInterval{T}, q::Interval{S}) where {T,S} = - xx^DecoratedInterval(q) - -## Discontinuous functions (sign, ceil, floor, trunc) and round -function sign(xx::DecoratedInterval{T}) where T - r = sign(interval(xx)) - d = decoration(xx) - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end -function ceil(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = ceil(x) - d = decoration(xx) - if isinteger(sup(x)) - d = min(d, dac) - end - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end -function floor(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = floor(x) - d = decoration(xx) - if isinteger(inf(x)) - d = min(d, dac) - end - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end -function trunc(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = trunc(x) - d = decoration(xx) - if (isinteger(inf(x)) && inf(x) < zero(T)) || (isinteger(sup(x)) && sup(x) > zero(T)) - d = min(d, dac) - end - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end - -function round(xx::DecoratedInterval, ::RoundingMode{:Nearest}) - x = interval(xx) - r = round(x) - d = decoration(xx) - if isinteger(2*inf(x)) || isinteger(2*sup(x)) - d = min(d, dac) - end - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end -function round(xx::DecoratedInterval, ::RoundingMode{:NearestTiesAway}) - x = interval(xx) - r = round(x,RoundNearestTiesAway) - d = decoration(xx) - if isinteger(2*inf(x)) || isinteger(2*sup(x)) - d = min(d, dac) - end - isthin(r) && return DecoratedInterval(r, d) - DecoratedInterval(r, min(d,def)) -end -round(xx::DecoratedInterval) = round(xx, RoundNearest) -round(xx::DecoratedInterval, ::RoundingMode{:ToZero}) = trunc(xx) -round(xx::DecoratedInterval, ::RoundingMode{:Up}) = ceil(xx) -round(xx::DecoratedInterval, ::RoundingMode{:Down}) = floor(xx) - - -## Define binary functions with no domain restrictions -binary_functions = ( :min, :max ) - -for f in binary_functions - @eval function $(f)(xx::DecoratedInterval{T}, yy::DecoratedInterval{T}) where T - r = $f(interval(xx), interval(yy)) - d = min(decoration(r), decoration(xx), decoration(yy)) - DecoratedInterval(r, d) - end -end - -## abs -abs(xx::DecoratedInterval{T}) where T = - DecoratedInterval(abs(interval(xx)), decoration(xx)) - - -## Other (cancel and set) functions -other_functions = ( :cancelplus, :cancelminus, :intersect_interval, :hull ) - -for f in other_functions - @eval $(f)(xx::DecoratedInterval{T}, yy::DecoratedInterval{T}) where T = - DecoratedInterval($(f)(interval(xx), interval(yy)), trv) -end - -@doc """ - cancelplus(xx, yy) - -Decorated interval extension; the result is decorated as `trv`, -following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). -""" cancelplus - -@doc """ - cancelminus(xx, yy) - -Decorated interval extension; the result is decorated as `trv`, -following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). -""" cancelminus - -@doc """ - intersect_interval(xx, yy) - -Decorated interval extension; the result is decorated as `trv`, -following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). -""" intersect_interval - -@doc """ - hull(xx, yy) - -Decorated interval extension; the result is decorated as `trv`, -following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). -""" hull - - - -## Functions on unrestricted domains; tan and atan are treated separately -unrestricted_functions =( - :exp, :exp2, :exp10, - :sin, :cos, - :atan, - :sinh, :cosh, :tanh, - :asinh ) - -for f in unrestricted_functions - @eval function $(f)(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = $f(x) - d = min(decoration(r), decoration(xx)) - DecoratedInterval(r, d) - end -end - -function tan(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = tan(x) - d = min(decoration(r), decoration(xx)) - if isunbounded(r) - d = min(d, trv) - end - DecoratedInterval(r, d) -end - -function decay(a::DECORATION) - a == com && return dac - a == dac && return def - a == def && return trv - a == trv && return trv - ill -end - -function atan(yy::DecoratedInterval{T}, xx::DecoratedInterval{T}) where T - x = interval(xx) - y = interval(yy) - r = atan(y, x) - d = decoration(r) - d = min(d, decoration(xx), decoration(yy)) - # Check cases when decoration is trv and decays (from com or dac) - if in_interval(zero(T), y) - in_interval(zero(T), x) && return DecoratedInterval(r, trv) - if sup(x) < zero(T) - inf(y) < zero(T) && return DecoratedInterval(r, min(d, def)) - return DecoratedInterval(r, min(d, dac)) - end - end - DecoratedInterval(r, d) -end - - -# For domains, cf. table 9.1 on page 28 of the standard -# Functions with restricted domains: - -# The function is unbounded at the bounded edges of the domain -restricted_functions1 = Dict( - :log => unsafe_interval(Float64, 0.0, Inf), - :log2 => unsafe_interval(Float64, 0.0, Inf), - :log10 => unsafe_interval(Float64, 0.0, Inf), - :atanh => unsafe_interval(Float64, -1.0, 1.0) -) - -# The function is bounded at the bounded edge(s) of the domain -restricted_functions2 = Dict( - :sqrt => unsafe_interval(Float64, 0.0, Inf), - :asin => unsafe_interval(Float64, -1.0, 1.0), - :acos => unsafe_interval(Float64, -1.0, 1.0), - :acosh => unsafe_interval(Float64, 1.0, Inf) -) - -# Define functions with restricted domains on DecoratedInterval's: -for (f, domain) in restricted_functions1 - @eval function Base.$(f)(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = $(f)(x) - d = min(decoration(xx), decoration(r)) - isstrictsubset_interval(x, $domain) && return DecoratedInterval(r, d) - DecoratedInterval(r, trv) - end -end - -for (f, domain) in restricted_functions2 - @eval function Base.$(f)(xx::DecoratedInterval{T}) where T - x = interval(xx) - r = $(f)(x) - d = min(decoration(xx), decoration(r)) - issubset_interval(x, $domain) && return DecoratedInterval(r, d) - DecoratedInterval(r, trv) - end -end diff --git a/src/decorations/intervals.jl b/src/decorations/intervals.jl deleted file mode 100644 index e52a7756a..000000000 --- a/src/decorations/intervals.jl +++ /dev/null @@ -1,79 +0,0 @@ -# This file is part of the IntervalArithmetic.jl package; MIT licensed - -# Decorated intervals, following the IEEE 1758-2015 standard - -""" - DECORATION - -Enumeration constant for the types of interval decorations. The nomenclature -follows Section 11.2 of the IEEE Standard 1788-2015: -- `com -> 4`: non-empty, continuous and bounded (common) -- `dac -> 3`: non-empty and continuous (defined and continuous) -- `def -> 2`: non-empty (defined) -- `trv -> 1`: always true (trivial) -- `ill -> 0`: not an interval (ill-formed) -""" -@enum DECORATION ill=0 trv=1 def=2 dac=3 com=4 -# Note that `isweakless`, and hence `<` and `min`, are automatically defined for enums - -""" - DecoratedInterval{T<:NumTypes} - -Wraps an `Interval` together with a `DECORATION`, i.e. a flag that records the -status of the interval when thought of as the result of a previously executed -sequence of functions acting on an initial interval. -""" -struct DecoratedInterval{T<:NumTypes} - interval::Interval{T} - decoration::DECORATION - - DecoratedInterval{T}(x::Interval{T}, d::DECORATION) where {T<:NumTypes} = new{T}(x, d) -end - -function DecoratedInterval{T}(x::Interval{T}) where {T<:NumTypes} - d = decoration(x) - d ≤ trv && return DecoratedInterval{T}(x, d) - d == ill && return DecoratedInterval{T}(nai(T), d) - return DecoratedInterval{T}(x, d) -end - -DecoratedInterval(x::Interval{T}, d::DECORATION) where {T<:NumTypes} = DecoratedInterval{T}(x, d) - -DecoratedInterval(x::Interval{T}) where {T<:NumTypes} = DecoratedInterval{T}(x) - -DecoratedInterval(x::DecoratedInterval, d::DECORATION) = DecoratedInterval(x.interval, d) # do we want this behaviour? - -DecoratedInterval(a, b, d::DECORATION) = - DecoratedInterval(unsafe_interval(promote_numtype(numtype(a), numtype(b)), a, b), - ifelse(is_valid_interval(a, b), d, ill)) - -function DecoratedInterval(a, b) - T = promote_numtype(numtype(a), numtype(b)) - is_valid_interval(a, b) || return DecoratedInterval(unsafe_interval(T, a, b), ill) - return DecoratedInterval(unsafe_interval(T, a, b)) -end - -DecoratedInterval(a, d::DECORATION) = DecoratedInterval(a, a, d) - -DecoratedInterval(a) = DecoratedInterval(a, a) - -DecoratedInterval(a::Tuple, d::DECORATION) = DecoratedInterval(a..., d) - -DecoratedInterval(a::Tuple) = DecoratedInterval(a...) - -# - -interval(x::DecoratedInterval) = x.interval -decoration(x::DecoratedInterval) = x.decoration - -function decoration(x::Interval) - isnai(x) && return ill # nai() - isempty_interval(x) && return trv # emptyinterval - isunbounded(x) && return dac # unbounded - return com # common -end - -# - -float(x::DecoratedInterval) = DecoratedInterval(float(interval(x)), decoration(x)) -big(x::DecoratedInterval) = DecoratedInterval(big(interval(x)), decoration(x)) diff --git a/src/display.jl b/src/display.jl index 661161627..db411583d 100644 --- a/src/display.jl +++ b/src/display.jl @@ -1,7 +1,7 @@ mutable struct DisplayParameters - format::Symbol - decorations::Bool - sigdigits::Int + format :: Symbol + decorations :: Bool + sigdigits :: Int end function Base.show(io::IO, ::MIME"text/plain", params::DisplayParameters) @@ -15,11 +15,11 @@ function Base.show(io::IO, ::MIME"text/plain", params::DisplayParameters) end end -const display_params = DisplayParameters(:standard, true, 6) # Default +const display_params = DisplayParameters(:standard, true, 6) # default """ - setformat(format::Symbol; decorations::Bool, sigdigits::Int) - setformat() + setdisplay(format::Symbol; decorations::Bool, sigdigits::Int) + setdisplay() Change the format used by `show` to display intervals. @@ -29,7 +29,7 @@ and `sigdigits = 6`. If any of the three argument `format`, `decorations` and `sigdigits` is omitted, then their value is left unchanged. -If the three arguments are omitted, i.e. calling `setformat()`, then the values +If the three arguments are omitted, i.e. calling `setdisplay()`, then the values are reset to the default display options. Possible options: @@ -45,7 +45,7 @@ Possible options: julia> x = interval(0.1, 0.3) # Default display options [0.0999999, 0.300001] -julia> setformat(:full) +julia> setdisplay(:full) Display parameters: - format: full - decorations: true @@ -54,7 +54,7 @@ Display parameters: julia> x Interval(0.09999999999999999, 0.30000000000000004) -julia> setformat(:standard; sigdigits = 3) +julia> setdisplay(:standard; sigdigits = 3) Display parameters: - format: standard - decorations: true @@ -64,7 +64,7 @@ julia> x [0.0999, 0.301] ``` """ -function setformat(format::Symbol = display_params.format; +function setdisplay(format::Symbol = display_params.format; decorations::Bool = display_params.decorations, sigdigits::Int = display_params.sigdigits) @@ -78,202 +78,273 @@ function setformat(format::Symbol = display_params.format; return display_params end -# Printing mechanism for various types of intervals +# printing mechanism -show(io::IO, ::MIME"text/plain", a::Union{Interval,Complex{<:Interval},DecoratedInterval}) = - print(io, representation(a, display_params.format)) +show(io::IO, ::MIME"text/plain", a::Union{BareInterval,Interval,Complex{<:Interval}}) = + print(io, _str_repr(a, display_params.format)) -function show(io::IO, a::Union{Interval,Complex{<:Interval},DecoratedInterval}) - get(io, :compact, false) && return print(io, representation(a, display_params.format)) - return print(io, representation(a, :full)) +function show(io::IO, a::Union{BareInterval,Interval,Complex{<:Interval}}) + get(io, :compact, false) && return print(io, _str_repr(a, display_params.format)) + return print(io, _str_repr(a, :full)) end -# `String` representation of various types of intervals +# `String` representation -representation(a::Interval, format::Symbol) = basic_representation(a, format) +function _str_repr(a::BareInterval{T}, format::Symbol) where {T<:NumTypes} + # `format` is either `:standard`, `:midpoint` or `:full` + str_interval = _str_basic_repr(a, format) + format === :full && return string("BareInterval{", T, "}(", str_interval, ')') + return str_interval +end -function representation(a::Interval{T}, format::Symbol) where {T<:BigFloat} - # `format` is either :standard, :midpoint or :full - format === :standard && return string(basic_representation(a, format), subscriptify(precision(T))) - format === :midpoint && return string("(", basic_representation(a, format), ")", subscriptify(precision(T))) - return basic_representation(a, format) +function _str_repr(a::BareInterval{BigFloat}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + str_interval = _str_basic_repr(a, format) + format === :full && return string("BareInterval{BigFloat}(", str_interval, ')') + if format === :midpoint && str_interval != "∅" + str_interval = string('(', str_interval, ')') + end + return string(str_interval, _subscriptify(precision(BigFloat))) end -function representation(x::Complex{<:Interval}, format::Symbol) - # `format` is either :standard, :midpoint or :full - format === :midpoint && return string("(", representation(real(x), format), ") + (", representation(imag(x), format), ")im") - return string(representation(real(x), format), " + ", representation(imag(x), format), "im") +function _str_repr(a::Interval{T}, format::Symbol) where {T<:NumTypes} + # `format` is either `:standard`, `:midpoint` or `:full` + str_interval = _str_basic_repr(bareinterval(a), format) + if isguaranteed(a) + format === :full && return string("Interval{", T, "}(", str_interval, ", ", decoration(a), ')') + display_params.decorations || return str_interval + if format === :midpoint && str_interval != "∅" + str_interval = string('(', str_interval, ')') + end + return string(str_interval, '_', decoration(a)) + else + format === :full && return string("Interval{", T, "}(", str_interval, ", ", decoration(a), ", NG)") + if format === :midpoint && str_interval != "∅" + str_interval = string('(', str_interval, ')') + end + display_params.decorations || return string(str_interval, "_NG") + return string(str_interval, '_', decoration(a), "_NG") + end end -# No extra brackets for `:midpoint` and `BigFloat`: the display of the precision add some -function representation(x::Complex{Interval{BigFloat}}, format::Symbol) - # `format` is either :standard, :midpoint or :full - return string(representation(real(x), format), " + ", representation(imag(x), format), "im") +function _str_repr(a::Interval{BigFloat}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + str_interval = _str_basic_repr(bareinterval(a), format) + if isguaranteed(a) + format === :full && return string("Interval{BigFloat}(", str_interval, ", ", decoration(a), ')') + if format === :midpoint && str_interval != "∅" + str_interval = string('(', str_interval, ')') + end + display_params.decorations || return string(str_interval, _subscriptify(precision(BigFloat))) + return string(str_interval, _subscriptify(precision(BigFloat)), '_', decoration(a)) + else + format === :full && return string("Interval{", T, "}(", str_interval, ", ", decoration(a), ", NG)") + if format === :midpoint && str_interval != "∅" + str_interval = string('(', str_interval, ')') + end + display_params.decorations || return string(str_interval, _subscriptify(precision(BigFloat)), "_NG") + return string(str_interval, _subscriptify(precision(BigFloat)), '_', decoration(a), "_NG") + end end -function representation(a::DecoratedInterval, format::Symbol) - # `format` is either :standard, :midpoint or :full - var_interval = representation(interval(a), format) - format === :full && return string("DecoratedInterval(", var_interval, ", ", decoration(a), ")") - if format === :midpoint # Add extra brackets - var_interval = string("(", var_interval, ")") +function _str_repr(x::Complex{<:Interval}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + if format === :full + return string(_str_repr(real(x), format), " + ", _str_repr(imag(x), format), "im") + elseif format === :standard + display_params.decorations && return string(_str_repr(real(x), format), " + (", _str_repr(imag(x), format), ")im") + return string(_str_repr(real(x), format), " + ", _str_repr(imag(x), format), "im") + else + display_params.decorations && return string(_str_repr(real(x), format), " + (", _str_repr(imag(x), format), ")im") + return string('(', _str_repr(real(x), format), ") + (", _str_repr(imag(x), format), ")im") end - display_params.decorations && return string(var_interval, "_", decoration(a)) - return var_interval end -# No extra brackets for `:midpoint` and `BigFloat`: the display of the precision add some -function representation(a::DecoratedInterval{BigFloat}, format::Symbol) - # `format` is either :standard, :midpoint or :full - var_interval = representation(interval(a), format) - format === :full && return string("DecoratedInterval(", var_interval, ", ", decoration(a), ")") - display_params.decorations && return string(var_interval, "_", decoration(a)) - return var_interval +function _str_repr(x::Complex{Interval{BigFloat}}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + display_params.decorations && return string(_str_repr(real(x), format), " + (", _str_repr(imag(x), format), ")im") + return string(_str_repr(real(x), format), " + ", _str_repr(imag(x), format), "im") end -# `String` representation of an `Interval` +# -function basic_representation(a::Interval{T}, format::Symbol) where {T<:AbstractFloat} +function _str_basic_repr(a::BareInterval{<:AbstractFloat}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + # do not use `inf(a)` to avoid `-0.0` isempty_interval(a) && return "∅" sigdigits = display_params.sigdigits if format === :full - # Do not use `inf(a)` to avoid -0.0 - return string("Interval{", T, "}(", a.lo, ", ", sup(a), ")") + return string(a.lo, ", ", sup(a)) elseif format === :midpoint - m = round_string(mid(a), sigdigits, RoundNearest) - r = round_string(radius(a), sigdigits, RoundUp) + m = _round_string(mid(a), sigdigits, RoundNearest) + r = _round_string(radius(a), sigdigits, RoundUp) output = string(m, " ± ", r) return replace(output, "Inf" => '∞') - else # format === :standard - # Do not use `inf(a)` to avoid -0.0 - lo = round_string(a.lo, sigdigits, RoundDown) - hi = round_string(sup(a), sigdigits, RoundUp) - output = string("[", lo, ", ", hi, "]") - return replace(output, "Inf" => '∞') + else + lo = _round_string(a.lo, sigdigits, RoundDown) + hi = _round_string(sup(a), sigdigits, RoundUp) + output = string('[', lo, ", ", hi, ']') + return replace(output, "Inf]" => "∞)", "[-Inf" => "(-∞") end end -function basic_representation(a::Interval{Float32}, format::Symbol) +function _str_basic_repr(a::BareInterval{Float32}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + # do not use `inf(a)` to avoid `-0.0` isempty_interval(a) && return "∅" sigdigits = display_params.sigdigits if format === :full - # Do not use `inf(a)` to avoid -0.0 - output = string("Interval{Float32}(", a.lo, "f0, ", sup(a), "f0)") - return replace(replace(output, "NaNf0" => "NaN32"), "Inff0" => "Inf32") + lo = replace(string(a.lo, "f0"), "NaNf0" => "NaN32", "Inff0" => "Inf32") + if contains(lo, 'e') + lo = replace(lo, 'e' => 'f', "f0" => "") + end + hi = replace(string(sup(a), "f0"), "NaNf0" => "NaN32", "Inff0" => "Inf32") + if contains(hi, 'e') + hi = replace(hi, 'e' => 'f', "f0" => "") + end + return string(lo, ", ", hi) elseif format === :midpoint - m = round_string(mid(a), sigdigits, RoundNearest) - r = round_string(radius(a), sigdigits, RoundUp) - output = string(m, "f0 ± ", r, "f0") - return replace(replace(output, "NaNf0" => "NaN32"), "Inff0" => '∞') - else # format === :standard - # Do not use `inf(a)` to avoid -0.0 - lo = round_string(a.lo, sigdigits, RoundDown) - hi = round_string(sup(a), sigdigits, RoundUp) - output = string("[", lo, "f0, ", hi, "f0]") - return replace(replace(output, "NaNf0" => "NaN32"), "Inff0" => '∞') + m = _round_string(mid(a), sigdigits, RoundNearest) + m = replace(string(m, "f0"), "NaNf0" => "NaN32", "Inff0" => "Inf32") + if contains(m, 'e') + m = replace(m, 'e' => 'f', "f0" => "") + end + r = _round_string(radius(a), sigdigits, RoundUp) + r = replace(string(r, "f0"), "NaNf0" => "NaN32", "Inff0" => "Inf32") + if contains(r, 'e') + r = replace(r, 'e' => 'f', "f0" => "") + end + return string(m, " ± ", r) + else + lo = _round_string(a.lo, sigdigits, RoundDown) + lo = replace(string('[', lo, "f0"), "NaNf0" => "NaN32", "[-Inff0" => "(-∞") + if contains(lo, 'e') + lo = replace(lo, 'e' => 'f', "f0" => "") + end + hi = _round_string(sup(a), sigdigits, RoundUp) + hi = replace(string(hi, "f0]"), "NaNf0" => "NaN32", "Inff0]" => "∞)") + if contains(hi, 'e') + hi = replace(hi, 'e' => 'f', "f0" => "") + end + return string(lo, ", ", hi) end end -function basic_representation(a::Interval{T}, format::Symbol) where {T<:Rational} +function _str_basic_repr(a::BareInterval{Float16}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + # do not use `inf(a)` to avoid `-0.0` isempty_interval(a) && return "∅" + sigdigits = display_params.sigdigits if format === :full - # Do not use `inf(a)` to avoid -0.0 - return string("Interval{", T, "}(", a.lo, ", ", sup(a), ")") + output = string("Float16(", a.lo, "), Float16(", sup(a), ')') + return replace(output, "Float16(NaN)" => "NaN16", "Float16(-Inf)" => "-Inf16", "Float16(Inf)" => "Inf16") elseif format === :midpoint - return string(mid(a), " ± ", radius(a)) - else # format === :standard - # Do not use `inf(a)` to avoid -0.0 - return string("[", a.lo, ", ", sup(a), "]") + m = _round_string(mid(a), sigdigits, RoundNearest) + r = _round_string(radius(a), sigdigits, RoundUp) + output = string("Float16(", m, ") ± Float16(", r, ')') + return replace(output, "Float16(NaN)" => "NaN16", "Float16(Inf)" => '∞') + else + lo = _round_string(a.lo, sigdigits, RoundDown) + hi = _round_string(sup(a), sigdigits, RoundUp) + output = string("[Float16(", lo, "), Float16(", hi, ")]") + return replace(output, "Float16(NaN)" => "NaN16", "[Float16(-Inf)" => "(-∞", "Float16(Inf)]" => "∞)") end end -# Round to the prescribed significant digits -# Code inspired by `_string(x::BigFloat, k::Integer)` in base/mpfr.jl +function _str_basic_repr(a::BareInterval{<:Rational}, format::Symbol) + # `format` is either `:standard`, `:midpoint` or `:full` + # do not use `inf(a)` to avoid `-0.0` + isempty_interval(a) && return "∅" + format === :full && return string(a.lo, ", ", sup(a)) + format === :midpoint && return string(mid(a), " ± ", radius(a)) + return string('[', a.lo, ", ", sup(a), ']') +end + +# round to the prescribed significant digits +# code inspired by `_string(x::BigFloat, k::Integer)` in base/mpfr.jl -function round_string(x::AbstractFloat, sigdigits::Int, r::RoundingMode) - str_digits = replace(replace(string(x), '.' => ""), '-' => "") - if (isinteger(x) || ispow2(x)) && sigdigits ≥ length(str_digits) # `x` is exactly representable - return round_string(big(x), sigdigits, RoundNearest) +function _round_string(x::T, sigdigits::Int, r::RoundingMode) where {T<:AbstractFloat} + str_x = string(x) + str_digits = split(contains(str_x, '.') ? split(string(x), '.'; limit = 2)[2] : str_x, 'e'; limit = 2)[1] + len = length(str_digits) + if (isinteger(x) || ispow2(abs(x))) && sigdigits ≥ len # `x` is exactly representable + return replace(_round_string(big(x), len + 1, RoundNearest), "e-0" => "e-") else - return round_string(big(x), sigdigits, r) + return _round_string(big(x), sigdigits, r) end end -round_string(x::BigFloat, sigdigits::Int, ::RoundingMode{:Nearest}) = - Base.MPFR._string(x, sigdigits-1) # `sigdigits-1` digits after the decimal +_round_string(x::BigFloat, sigdigits::Int, ::RoundingMode{:Nearest}) = + Base.MPFR._string(x, sigdigits-1) # `sigdigits-1` digits after the decimal -function round_string(x::BigFloat, sigdigits::Int, r::RoundingMode) +function _round_string(x::BigFloat, sigdigits::Int, r::RoundingMode) if !isfinite(x) return string(Float64(x)) else - str_digits = replace(replace(string(x), '.' => ""), '-' => "") - if (isinteger(x) || ispow2(x)) && sigdigits ≥ length(str_digits) # `x` is exactly representable - return round_string(x, sigdigits, RoundNearest) + str_digits = split(split(string(x), '.'; limit = 2)[2], 'e'; limit = 2)[1] + len = length(str_digits) + if (isinteger(x) || ispow2(abs(x))) && sigdigits ≥ len # `x` is exactly representable + return _round_string(big(x), len + 1, RoundNearest) else # `sigdigits` digits after the decimal str = Base.MPFR.string_mpfr(x, "%.$(sigdigits)Re") - rounded_str = round_string(str, r) + rounded_str = _round_string(str, r) return Base.MPFR._prettify_bigfloat(rounded_str) end end end -round_string(s::String, ::RoundingMode{:Up}) = - startswith(s, '-') ? string('-', round_string_down(s[2:end])) : round_string_up(s) +_round_string(s::String, ::RoundingMode{:Up}) = + startswith(s, '-') ? string('-', _round_string_down(s[2:end])) : _round_string_up(s) -round_string(s::String, ::RoundingMode{:Down}) = - startswith(s, '-') ? string('-', round_string_up(s[2:end])) : round_string_down(s) +_round_string(s::String, ::RoundingMode{:Down}) = + startswith(s, '-') ? string('-', _round_string_up(s[2:end])) : _round_string_down(s) -function round_string_up(s::String) - # NOTE: `s` has 1 extra significant digit to control the rounding +function _round_string_up(s::String) + # `s` has one extra significant digit to control the rounding mantissa, exponent = eachsplit(s, 'e') mantissa = mantissa[1:end-1] len = length(mantissa) idx = findlast(d -> (d !== '9') & (d !== '.'), mantissa) - if idx == len # Last significant digit is not 9 - d = parse(Int, mantissa[len]) + 1 # Increase the last significant digit + if idx == len # last significant digit is not `9` + d = parse(Int, mantissa[len]) + 1 # increase the last significant digit return string(view(mantissa, 1:len-1), d, 'e', exponent) - else - if isnothing(idx) # All significant digits are 9 - expo = parse(Int, exponent) + 1 # Increase the exponent by 1 + if isnothing(idx) # all significant digits are `9` + expo = parse(Int, exponent) + 1 # increase the exponent by `1` expo_str = string(expo; pad = 2) exponent = expo < 0 ? expo_str : string('+', expo_str) return string("1.", '0'^(len - 2), 'e', exponent) - else new_mantissa = string( view(mantissa, 1:idx-1), parse(Int, mantissa[idx]) + 1, - # Add "." if the last significant digit not equal to 9 is before the decimal point + # add `"."` if the last significant digit not equal to `9` is before the decimal point idx == 1 ? "." : "", '0'^(len - idx)) return string(new_mantissa, 'e', exponent) - end end end -function round_string_down(s::String) - # NOTE: `s` has 1 extra significant digit to control the rounding +function _round_string_down(s::String) + # `s` has one extra significant digit to control the rounding mantissa, exponent = eachsplit(s, 'e') len = length(mantissa) idx = findlast(d -> (d !== '0') & (d !== '.'), mantissa) - if idx == len # The extra significant digit is not 0 - return string(view(mantissa, 1:len-1), 'e', exponent) # Truncate - + if idx == len # last significant digit is not `0` + return string(view(mantissa, 1:len-1), 'e', exponent) # truncate else - if isnothing(idx) # All significant digits are 0 - expo = parse(Int, exponent) - 1 # Decrease the exponent by 1 + if isnothing(idx) # all significant digits are `0` + expo = parse(Int, exponent) - 1 # decrease the exponent by `1` expo_str = string(expo; pad = 2) exponent = expo < 0 ? expo_str : string('+', expo_str) return string("9.", '9'^(len - 3), 'e', exponent) - else new_mantissa = string( view(mantissa, 1:idx-1), parse(Int, mantissa[idx]) - 1, - # Add '.' if the last significant digit not equal to 0 is before the decimal point + # add `"."` if the last significant digit not equal to `0` is before the decimal point idx == 1 ? "." : "", '9'^(len - (idx + 1))) return string(new_mantissa, 'e', exponent) @@ -282,64 +353,33 @@ function round_string_down(s::String) end end -# Utilities - -function subscriptify(n::Integer) - if 0 ≤ n ≤ 9 - return subscript_digit(n) - else - len = ndigits(n) - x = Vector{String}(undef, len) - i = 0 - while n > 0 - n, d = divrem(n, 10) - x[len-i] = subscript_digit(d) - i += 1 - end - return join(x) - end -end +# -function supscriptify(n::Integer) +function _subscriptify(n::Integer) if 0 ≤ n ≤ 9 - return supscript_digit(n) + return _subscript_digit(n) else len = ndigits(n) - x = Vector{String}(undef, len) + x = Vector{Char}(undef, len) i = 0 while n > 0 n, d = divrem(n, 10) - x[len-i] = supscript_digit(d) + x[len-i] = _subscript_digit(d) i += 1 end return join(x) end end -function supscript_digit(i::Integer) - i == 0 && return "⁰" - i == 1 && return "¹" - i == 2 && return "²" - i == 3 && return "³" - i == 4 && return "⁴" - i == 5 && return "⁵" - i == 6 && return "⁶" - i == 7 && return "⁷" - i == 8 && return "⁸" - i == 9 && return "⁹" - return throw(DomainError(i, "supscript_digit only accept integers between 0 and 9 (included)")) -end - -function subscript_digit(i::Integer) - i == 0 && return "₀" - i == 1 && return "₁" - i == 2 && return "₂" - i == 3 && return "₃" - i == 4 && return "₄" - i == 5 && return "₅" - i == 6 && return "₆" - i == 7 && return "₇" - i == 8 && return "₈" - i == 9 && return "₉" - return throw(DomainError(i, "subscript_digit only accept integers between 0 and 9 (included)")) +function _subscript_digit(i::Integer) + i == 0 && return '₀' + i == 1 && return '₁' + i == 2 && return '₂' + i == 3 && return '₃' + i == 4 && return '₄' + i == 5 && return '₅' + i == 6 && return '₆' + i == 7 && return '₇' + i == 8 && return '₈' + return '₉' end diff --git a/src/intervals/arithmetic/absmax.jl b/src/intervals/arithmetic/absmax.jl index d62200531..a01d90731 100644 --- a/src/intervals/arithmetic/absmax.jl +++ b/src/intervals/arithmetic/absmax.jl @@ -3,39 +3,48 @@ # Section 10.5.3 """ + abs(a::BareInterval) abs(a::Interval) Implement the `abs` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function abs(a::Interval{T}) where {T<:NumTypes} +function abs(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - return unsafe_interval(T, mig(a), mag(a)) + return _unsafe_bareinterval(T, mig(a), mag(a)) end -abs2(a::Interval) = a^2 +abs(a::Interval) = _unsafe_interval(abs(bareinterval(a)), decoration(a), isguaranteed(a)) """ - min(a::Interval, b::Interval) + abs2(a::BareInterval) + abs2(a::Interval) -Implement the `min` function of the IEEE Standard 1788-2015 (Table 9.1). +Implement the square absolute value; this is semantically equivalent to `nthpow(a, 2)`. """ -function min(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return a - isempty_interval(b) && return b - return unsafe_interval(T, min(inf(a), inf(b)), min(sup(a), sup(b))) +abs2(a::BareInterval) = nthpow(a, 2) # not in the IEEE Standard 1788-2015 + +abs2(a::Interval) = _unsafe_interval(abs2(bareinterval(a)), decoration(a), isguaranteed(a)) + +for f ∈ (:min, :max) + @eval begin + """ + $($f)(a::BareInterval, b::BareInterval) + $($f)(a::Interval, b::Interval) + + Implement the `$($f)` function of the IEEE Standard 1788-2015 (Table 9.1). + """ + function $f(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} + isempty_interval(a) && return a + isempty_interval(b) && return b + return _unsafe_bareinterval(T, $f(inf(a), inf(b)), $f(sup(a), sup(b))) + end + $f(a::BareInterval, b::BareInterval) = $f(promote(a, b)...) + + function $f(a::Interval, b::Interval) + r = $f(bareinterval(a), bareinterval(b)) + d = min(decoration(a), decoration(b)) + t = isguaranteed(a) & isguaranteed(b) + return _unsafe_interval(r, d, t) + end + end end - -min(a::Interval, b::Interval) = min(promote(a, b)...) - -""" - max(a::Interval, b::Interval) - -Implement the `max` function of the IEEE Standard 1788-2015 (Table 9.1). -""" -function max(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return a - isempty_interval(b) && return b - return unsafe_interval(T, max(inf(a), inf(b)), max(sup(a), sup(b))) -end - -max(a::Interval, b::Interval) = max(promote(a, b)...) diff --git a/src/intervals/arithmetic/basic.jl b/src/intervals/arithmetic/basic.jl index aadde81cc..d7e8f2d49 100644 --- a/src/intervals/arithmetic/basic.jl +++ b/src/intervals/arithmetic/basic.jl @@ -2,120 +2,95 @@ # Section 9.1 of the IEEE Standard 1788-2015 and required for set-based flavor # in Section 10.5.3 -+(a::Interval) = a # not in the IEEE Standard 1788-2015 ++(a::BareInterval) = a # not in the IEEE Standard 1788-2015 + ++(a::Interval) = a """ + +(a::BareInterval, b::BareInterval) +(a::Interval, b::Interval) - +(a::Interval, b::Real) - +(a::Real, b::Interval) Implement the `add` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function +(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function +(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a isempty_interval(b) && return b return @round(T, inf(a) + inf(b), sup(a) + sup(b)) end ++(a::BareInterval, b::BareInterval) = +(promote(a, b)...) -+(a::Interval, b::Interval) = +(promote(a, b)...) - -function +(a::Interval{T}, b::T) where {T<:NumTypes} - isempty_interval(a) && return a - isfinite(b) || return emptyinterval(T) - return @round(T, inf(a) + b, sup(a) + b) +function +(a::Interval, b::Interval) + r = bareinterval(a) + bareinterval(b) + d = min(decoration(a), decoration(b), decoration(r)) + t = isguaranteed(a) & isguaranteed(b) + return _unsafe_interval(r, d, t) end -+(a::Interval{T}, b::Real) where {T<:NumTypes} = a + interval(T, b) - -+(a::Real, b::Interval{T}) where {T<:NumTypes} = b + a - """ + -(a::BareInterval) -(a::Interval) Implement the `neg` function of the IEEE Standard 1788-2015 (Table 9.1). """ --(a::Interval{T}) where {T<:NumTypes} = unsafe_interval(T, -sup(a), -inf(a)) +-(a::BareInterval{T}) where {T<:NumTypes} = _unsafe_bareinterval(T, -sup(a), -inf(a)) + +-(a::Interval) = _unsafe_interval(-bareinterval(a), decoration(a), isguaranteed(a)) """ + -(a::BareInterval, b::BareInterval) -(a::Interval, b::Interval) - -(a::Interval, b::Real) - -(a::Real, b::Interval) Implement the `sub` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function -(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function -(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a isempty_interval(b) && return b return @round(T, inf(a) - sup(b), sup(a) - inf(b)) end +-(a::BareInterval, b::BareInterval) = -(promote(a, b)...) --(a::Interval, b::Interval) = -(promote(a, b)...) - -function -(a::Interval{T}, b::T) where {T<:NumTypes} - isempty_interval(a) && return a - return @round(T, inf(a) - b, sup(a) - b) +function -(a::Interval, b::Interval) + r = bareinterval(a) - bareinterval(b) + d = min(decoration(a), decoration(b), decoration(r)) + t = isguaranteed(a) & isguaranteed(b) + return _unsafe_interval(r, d, t) end -function -(b::T, a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return a - return @round(T, b - sup(a), b - inf(a)) -end - --(a::Interval{T}, b::Real) where {T<:NumTypes} = a - interval(T, b) - --(a::Real, b::Interval{T}) where {T<:NumTypes} = interval(T, a) - b - -""" - unsafe_scale(a::Interval, α) - -Multiply an interval by a positive scalar. For efficiency, does not check that -the constant is positive. -""" -unsafe_scale(a::Interval{T}, α::T) where {T<:NumTypes} = @round(T, inf(a) * α, sup(a) * α) - """ + *(a::BareInterval, b::BareInterval) *(a::Interval, b::Interval) - *(a::Interval, b::Real) - *(a::Real, b::Interval) Implement the `mul` function of the IEEE Standard 1788-2015 (Table 9.1). !!! note - The behavior of the multiplication is flavor dependent for some edge cases. + The behavior of `*` is flavor dependent for some edge cases. """ -function *(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function *(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a isempty_interval(b) && return b isthinzero(a) && return a isthinzero(b) && return b - isbounded(a) && isbounded(b) && return mult(*, a, b) - return mult((x, y, r) -> unbounded_mult(T, x, y, r), a, b) + isbounded(a) && isbounded(b) && return _mult(*, a, b) + return _mult((x, y, r) -> _unbounded_mult(x, y, r), a, b) end +*(a::BareInterval, b::BareInterval) = *(promote(a, b)...) -*(a::Interval, b::Interval) = *(promote(a, b)...) - -function *(a::Interval{T}, b::T) where {T<:NumTypes} - (isempty_interval(a) || isthinzero(a) || isone(b)) && return a - isfinite(b) || return emptyinterval(T) - if b ≥ 0 - return @round(T, inf(a) * b, sup(a) * b) - else - return @round(T, sup(a) * b, inf(a) * b) - end +function *(a::Interval, b::Interval) + r = bareinterval(a) * bareinterval(b) + d = min(decoration(a), decoration(b), decoration(r)) + t = isguaranteed(a) & isguaranteed(b) + return _unsafe_interval(r, d, t) end -*(a::Interval{T}, b::Real) where {T<:NumTypes} = a * interval(T, b) - -*(a::Real, b::Interval{T}) where {T<:NumTypes} = b * a - # helper functions for multiplication -function unbounded_mult(::Type{T}, x::T, y::T, r::RoundingMode) where {T<:NumTypes} + +function _unbounded_mult(x::T, y::T, r::RoundingMode) where {T<:NumTypes} iszero(x) && return sign(y) * zero_times_infinity(T) iszero(y) && return sign(x) * zero_times_infinity(T) return *(x, y, r) end -function mult(op, a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function _mult(op, a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} if inf(b) ≥ 0 inf(a) ≥ 0 && return @round(T, op(inf(a), inf(b)), op(sup(a), sup(b))) sup(a) ≤ 0 && return @round(T, op(inf(a), sup(b)), op(sup(a), inf(b))) @@ -133,16 +108,43 @@ function mult(op, a::Interval{T}, b::Interval{T}) where {T<:NumTypes} end """ + inv(a::BareInterval) + inv(a::Interval) + +Implement the `recip` function of the IEEE Standard 1788-2015 (Table 9.1). + +!!! note + The behavior of `inv` is flavor dependent for some edge cases. +""" +function inv(a::BareInterval{T}) where {T<:NumTypes} + isempty_interval(a) && return a + if in_interval(0, a) + inf(a) < 0 == sup(a) && return @round(T, typemin(T), inv(inf(a))) + inf(a) == 0 < sup(a) && return @round(T, inv(sup(a)), typemax(T)) + inf(a) < 0 < sup(a) && return entireinterval(BareInterval{T}) + isthinzero(a) && return div_by_thin_zero(_unsafe_bareinterval(T, one(T), one(T))) + end + return @round(T, inv(sup(a)), inv(inf(a))) +end + +function inv(a::Interval) + x = bareinterval(a) + r = inv(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(in_interval(0, x), trv, d)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +""" + /(a::BareInterval, b::BareInterval) /(a::Interval, b::Interval) - /(a::Interval, b::Real) - /(a::Real, b::Interval) Implement the `div` function of the IEEE Standard 1788-2015 (Table 9.1). !!! note - The behavior of the division is flavor dependent for some edge cases. + The behavior of `/` is flavor dependent for some edge cases. """ -function /(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function /(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a isempty_interval(b) && return b isthinzero(b) && return div_by_thin_zero(a) @@ -159,92 +161,71 @@ function /(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} if iszero(inf(b)) inf(a) ≥ 0 && return @round(T, inf(a)/sup(b), typemax(T)) sup(a) ≤ 0 && return @round(T, typemin(T), sup(a)/sup(b)) - return entireinterval(T) + return entireinterval(BareInterval{T}) elseif sup(b) == 0 inf(a) ≥ 0 && return @round(T, typemin(T), inf(a)/inf(b)) sup(a) ≤ 0 && return @round(T, sup(a)/inf(b), typemax(T)) - return entireinterval(T) + return entireinterval(BareInterval{T}) else - return entireinterval(T) + return entireinterval(BareInterval{T}) end end end - -/(a::Interval, b::Interval) = /(promote(a, b)...) - -function /(a::Interval{T}, b::T) where {T<:NumTypes} - isempty_interval(a) && return a - isfinite(b) || return emptyinterval(T) - iszero(b) && return div_by_thin_zero(a) - if b ≥ 0 - return @round(T, inf(a)/b, sup(a)/b) - else - return @round(T, sup(a)/b, inf(a)/b) - end +/(a::BareInterval, b::BareInterval) = /(promote(a, b)...) +\(a::BareInterval, b::BareInterval) = /(b, a) + +function /(a::Interval, b::Interval) + x = bareinterval(b) + r = bareinterval(a) / x + d = min(decoration(a), decoration(b), decoration(r)) + d = min(d, ifelse(in_interval(0, x), trv, d)) + t = isguaranteed(a) & isguaranteed(b) + return _unsafe_interval(r, d, t) end -/(a::Interval{T}, b::Real) where {T<:NumTypes} = a / interval(T, b) - -/(a::Real, b::Interval{T}) where {T<:NumTypes} = interval(T, a) / b - """ - inv(a::Interval) - -Implement the `recip` function of the IEEE Standard 1788-2015 (Table 9.1). + //(a::BareInterval, b::BareInterval) + //(a::Interval, b::Interval) -!!! note - The behavior of the division is flavor dependent for some edge cases. +Implement the rational division; this is semantically equivalent to `a / b`. """ -function inv(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return a - if in_interval(0, a) - inf(a) < 0 == sup(a) && return @round(T, typemin(T), inv(inf(a))) - inf(a) == 0 < sup(a) && return @round(T, inv(sup(a)), typemax(T)) - inf(a) < 0 < sup(a) && return entireinterval(T) - isthinzero(a) && return div_by_thin_zero(one(Interval{T})) - end - return @round(T, inv(sup(a)), inv(inf(a))) -end - -# rational division -//(a::Interval, b::Interval) = a / b - -min_ignore_nans(args...) = minimum(filter(x -> !isnan(x), args)) - -max_ignore_nans(args...) = maximum(filter(x -> !isnan(x), args)) +//(a::BareInterval, b::BareInterval) = a / b # not in the IEEE Standard 1788-2015 +//(a::Interval, b::Interval) = /(a, b) +""" + muladd(a::BareInterval, b::BareInterval c::BareInterval) + muladd(a::Interval, b::Interval c::Interval) -muladd(a::F, b::F, c::F) where {F<:Interval} = a * b + c - -muladd(a::Interval, b::Interval, c::Interval) = muladd(promote(a, b, c)...) - -muladd(a::Interval{T}, b::Interval{S}, c::Number) where {T<:NumTypes,S<:NumTypes} = muladd(promote(a, b, interval(promote_numtype(T, S), c))...) -muladd(a::Interval{T}, b::Number, c::Interval{S}) where {T<:NumTypes,S<:NumTypes} = muladd(promote(a, interval(promote_numtype(T, S), b), c)...) -muladd(a::Number, b::Interval{T}, c::Interval{S}) where {T<:NumTypes,S<:NumTypes} = muladd(promote(interval(promote_numtype(T, S), a), b, c)...) - -muladd(a::Interval{T}, b::Number, c::Number) where {T<:NumTypes} = muladd(a, interval(T, b), interval(T, c)) -muladd(a::Number, b::Interval{T}, c::Number) where {T<:NumTypes} = muladd(interval(T, a), b, interval(T, c)) -muladd(a::Number, b::Number, c::Interval{T}) where {T<:NumTypes} = muladd(interval(T, a), interval(T, b), c) +Implement the combined multiply-add; this is semantically equivalent to `a * b + c` +""" +muladd(a::F, b::F, c::F) where {F<:BareInterval} = a * b + c # not in the IEEE Standard 1788-2015 +muladd(a::BareInterval, b::BareInterval, c::BareInterval) = muladd(promote(a, b, c)...) + +function muladd(a::Interval, b::Interval, c::Interval) + r = muladd(bareinterval(a), bareinterval(b), bareinterval(c)) + d = min(decoration(a), decoration(b), decoration(c), decoration(r)) + t = isguaranteed(a) & isguaranteed(b) & isguaranteed(c) + return _unsafe_interval(r, d, t) +end """ + fma(a::BareInterval, b::BareInterval, c::BareInterval) fma(a::Interval, b::Interval, c::Interval) -Fused multiply-add. - Implement the `fma` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function fma(a::Interval{T}, b::Interval{T}, c::Interval{T}) where {T<:NumTypes} +function fma(a::BareInterval{T}, b::BareInterval{T}, c::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a isempty_interval(b) && return b isempty_interval(c) && return c if isentire_interval(a) isthinzero(b) && return c - return entireinterval(T) + return entireinterval(BareInterval{T}) elseif isentire_interval(b) isthinzero(a) && return c - return entireinterval(T) + return entireinterval(BareInterval{T}) end lo = setrounding(T, RoundDown) do @@ -252,7 +233,7 @@ function fma(a::Interval{T}, b::Interval{T}, c::Interval{T}) where {T<:NumTypes} lo2 = fma(inf(a), sup(b), inf(c)) lo3 = fma(sup(a), inf(b), inf(c)) lo4 = fma(sup(a), sup(b), inf(c)) - min_ignore_nans(lo1, lo2, lo3, lo4) + return minimum(filter(x -> !isnan(x), (lo1, lo2, lo3, lo4))) end hi = setrounding(T, RoundUp) do @@ -260,25 +241,38 @@ function fma(a::Interval{T}, b::Interval{T}, c::Interval{T}) where {T<:NumTypes} hi2 = fma(inf(a), sup(b), sup(c)) hi3 = fma(sup(a), inf(b), sup(c)) hi4 = fma(sup(a), sup(b), sup(c)) - max_ignore_nans(hi1, hi2, hi3, hi4) + return maximum(filter(x -> !isnan(x), (hi1, hi2, hi3, hi4))) end - return unsafe_interval(T, lo, hi) + return _unsafe_bareinterval(T, lo, hi) end +fma(a::BareInterval, b::BareInterval, c::BareInterval) = fma(promote(a, b, c)...) -fma(a::Interval, b::Interval, c::Interval) = fma(promote(a, b, c)...) +function fma(a::Interval, b::Interval, c::Interval) + r = fma(bareinterval(a), bareinterval(b), bareinterval(c)) + d = min(decoration(a), decoration(b), decoration(c), decoration(r)) + t = isguaranteed(a) & isguaranteed(b) & isguaranteed(c) + return _unsafe_interval(r, d, t) +end """ - sqrt(a::Interval) - -Square root of an interval. + sqrt(a::BareInterval) Implement the `sqrt` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function sqrt(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, zero(T), typemax(T)) +function sqrt(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, zero(T), typemax(T)) x = intersect_interval(a, domain) isempty_interval(x) && return x lo, hi = bounds(x) - return @round(T, sqrt(lo), sqrt(hi)) # `sqrt` is correctly-rounded + return @round(T, sqrt(lo), sqrt(hi)) +end + +function sqrt(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, zero(T), typemax(T)) + x = bareinterval(a) + r = sqrt(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(issubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) end diff --git a/src/intervals/arithmetic/hyperbolic.jl b/src/intervals/arithmetic/hyperbolic.jl index 7db58c0ca..f3c752c23 100644 --- a/src/intervals/arithmetic/hyperbolic.jl +++ b/src/intervals/arithmetic/hyperbolic.jl @@ -2,58 +2,93 @@ # Section 9.1 of the IEEE Standard 1788-2015 and required for set-based flavor # in Section 10.5.3 -for f in (:sinh, :tanh, :asinh) + +# Float64 versions of functions missing from CRlibm + +for f ∈ (:tanh, :coth, :sech, :csch, :asinh, :acosh, :atanh, :acoth) + @eval function $f(a::BareInterval{Float64}) + isempty_interval(a) && return a + return BareInterval{Float64}($f(_bigequiv(a))) + end +end + +# + +for f ∈ (:sinh, :tanh, :asinh) @eval begin """ + $($f)(a::BareInterval) $($f)(a::Interval) Implement the `$($f)` function of the IEEE Standard 1788-2015 (Table 9.1). """ - function ($f)(a::Interval{T}) where {T<:NumTypes} + function $f(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a lo, hi = bounds(a) - return @round(T, ($f)(lo), ($f)(hi)) + return @round(T, $f(lo), $f(hi)) + end + + function $f(a::Interval) + r = $f(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) end end end """ + cosh(a::BareInterval) cosh(a::Interval) Implement the `cosh` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function cosh(a::Interval{T}) where {T<:NumTypes} +function cosh(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a return @round(T, cosh(mig(a)), cosh(mag(a))) end +function cosh(a::Interval) + r = cosh(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + coth(a::BareInterval) coth(a::Interval) Implement the `coth` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function coth(a::Interval{T}) where {T<:NumTypes} +function coth(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - isthinzero(a) && return emptyinterval(T) + isthinzero(a) && return emptyinterval(BareInterval{T}) lo, hi = bounds(a) - if hi > 0 > lo - return entireinterval(T) + if lo < 0 < hi + return entireinterval(BareInterval{T}) + elseif lo == 0 + return @round(T, coth(hi), typemax(T)) elseif hi == 0 return @round(T, typemin(T), coth(lo)) - elseif hi > 0 && lo == 0 - return @round(T, coth(hi), typemax(T)) else - res_lo, res_hi = bounds(@round(T, coth(hi), coth(lo))) - return interval(T, res_lo, res_hi) + return @round(T, coth(hi), coth(lo)) end end +function coth(a::Interval) + x = bareinterval(a) + r = coth(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(in_interval(0, x), trv, d)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + sech(a::BareInterval) sech(a::Interval) Implement the `sech` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function sech(a::Interval{T}) where {T<:NumTypes} +function sech(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a lo, hi = bounds(a) if lo ≥ 0 # decreasing function @@ -65,74 +100,117 @@ function sech(a::Interval{T}) where {T<:NumTypes} end end +function sech(a::Interval) + r = sech(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + csch(a::BareInterval) csch(a::Interval) Implement the `csch` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function csch(a::Interval{T}) where {T<:NumTypes} +function csch(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - isthinzero(a) && return emptyinterval(T) + isthinzero(a) && return emptyinterval(BareInterval{T}) lo, hi = bounds(a) - if in_interval(0, a) - if hi > 0 > lo - return entireinterval(T) - elseif lo == 0 - return @round(T, csch(hi), typemax(T)) - else - return @round(T, typemin(T), csch(lo)) - end + if lo < 0 < hi + return entireinterval(BareInterval{T}) + elseif lo == 0 + return @round(T, csch(hi), typemax(T)) + elseif hi == 0 + return @round(T, typemin(T), csch(lo)) else return @round(T, csch(hi), csch(lo)) end end +function csch(a::Interval) + x = bareinterval(a) + r = csch(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(in_interval(0, x), trv, d)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + acosh(a::BareInterval) acosh(a::Interval) Implement the `acosh` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function acosh(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, one(T), typemax(T)) +function acosh(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, one(T), typemax(T)) x = intersect_interval(a, domain) isempty_interval(x) && return x lo, hi = bounds(x) return @round(T, acosh(lo), acosh(hi)) end +function acosh(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, one(T), typemax(T)) + x = bareinterval(a) + r = acosh(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(issubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + atanh(a::BareInterval) atanh(a::Interval) Implement the `atanh` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function atanh(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, -one(T), one(T)) +function atanh(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) x = intersect_interval(a, domain) isempty_interval(x) && return x lo, hi = bounds(x) res_lo, res_hi = bounds(@round(T, atanh(lo), atanh(hi))) - return interval(T, res_lo, res_hi) + return bareinterval(T, res_lo, res_hi) +end + +function atanh(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) + x = bareinterval(a) + r = atanh(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(isstrictsubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) end """ + acoth(a::BareInterval) acoth(a::Interval) Implement the `acoth` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function acoth(a::Interval{T}) where {T<:NumTypes} +function acoth(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - domain_excluded = unsafe_interval(T, -one(T), one(T)) - isstrictsubset_interval(a, domain_excluded) && return emptyinterval(T) - !isempty_interval(intersect_interval(a, domain_excluded)) && return entireinterval(T) + singular_domain = _unsafe_bareinterval(T, -one(T), one(T)) + issubset_interval(a, singular_domain) && return emptyinterval(BareInterval{T}) lo, hi = bounds(a) - res_lo, res_hi = bounds(@round(T, acoth(hi), acoth(lo))) - return interval(T, res_lo, res_hi) + if lo ≤ -1 && 1 ≤ hi + return entireinterval(BareInterval{T}) + elseif lo < -1 < hi || lo < 1 < hi + return emptyinterval(BareInterval{T}) + elseif lo == 1 + return @round(T, acoth(hi), typemax(T)) + elseif hi == -1 + return @round(T, typemin(T), acoth(lo)) + else + return @round(T, acoth(hi), acoth(lo)) + end end -# Float64 versions of functions missing from CRlibm -for f in (:tanh, :coth, :sech, :csch, :asinh, :acosh, :atanh, :acoth) - @eval function ($f)(a::Interval{Float64}) - isempty_interval(a) && return a - return Interval{Float64}(($f)(bigequiv(a))) - end +function acoth(a::Interval{T}) where {T<:NumTypes} + singular_domain = _unsafe_bareinterval(T, -one(T), one(T)) + x = bareinterval(a) + r = acoth(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(isempty_interval(intersect_interval(x, singular_domain)), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) end diff --git a/src/intervals/arithmetic/integer.jl b/src/intervals/arithmetic/integer.jl index f54b77efd..2ccce8fcc 100644 --- a/src/intervals/arithmetic/integer.jl +++ b/src/intervals/arithmetic/integer.jl @@ -2,49 +2,56 @@ # 9.1 of the IEEE Standard 1788-2015 and required for set-based flavor in # Section 10.5.3 -for f in (:sign, :ceil, :floor, :trunc) +for f ∈ (:sign, :ceil, :floor, :trunc) @eval begin """ + $($f)(a::BareInterval) $($f)(a::Interval) Implement the `$($f)` function of the IEEE Standard 1788-2015 (Table 9.1). """ - function ($f)(a::Interval{T}) where {T<:NumTypes} + function $f(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a lo, hi = bounds(a) - return unsafe_interval(T, ($f)(lo), ($f)(hi)) + return _unsafe_bareinterval(T, $f(lo), $f(hi)) + end + + function $f(a::Interval) + r = $f(bareinterval(a)) + d = decoration(a) + d = min(d, ifelse(isthin(r), d, def)) + return _unsafe_interval(r, d, isguaranteed(a)) end end end -# not strictly required by the IEEE Standard 1788-2015 -const RoundTiesToEven = RoundNearest -const RoundTiesToAway = RoundNearestTiesAway - """ + round(a::BareInterval[, RoundingMode]) round(a::Interval[, RoundingMode]) Return the interval with limits rounded to an integer. -Implement the functions `roundTiesToEven` and `roundTiesToAway` of the IEEE -Standard 1788-2015. +Implement the functions `roundTiesToEven` and `roundTiesToAway` of the +IEEE Standard 1788-2015. """ -round(a::Interval) = round(a, RoundNearest) - -round(a::Interval, ::RoundingMode{:ToZero}) = trunc(a) +round(a::Union{BareInterval,Interval}) = round(a, RoundNearest) +round(a::Union{BareInterval,Interval}, ::RoundingMode{:ToZero}) = trunc(a) +round(a::Union{BareInterval,Interval}, ::RoundingMode{:Up}) = ceil(a) +round(a::Union{BareInterval,Interval}, ::RoundingMode{:Down}) = floor(a) -round(a::Interval, ::RoundingMode{:Up}) = ceil(a) - -round(a::Interval, ::RoundingMode{:Down}) = floor(a) - -function round(a::Interval{T}, ::RoundingMode{:Nearest}) where {T<:NumTypes} - isempty_interval(a) && return a - lo, hi = bounds(a) - return unsafe_interval(T, round(lo), round(hi)) -end +for (S, R) ∈ ((:(:Nearest), :RoundNearest), (:(:NearestTiesAway), :RoundNearestTiesAway)) + @eval begin + function round(a::BareInterval{T}, ::RoundingMode{$S}) where {T<:NumTypes} + isempty_interval(a) && return a + lo, hi = bounds(a) + return _unsafe_bareinterval(T, round(lo, $R), round(hi, $R)) + end -function round(a::Interval{T}, ::RoundingMode{:NearestTiesAway}) where {T<:NumTypes} - isempty_interval(a) && return a - lo, hi = bounds(a) - return unsafe_interval(T, round(lo, RoundNearestTiesAway), round(hi, RoundNearestTiesAway)) + function round(a::Interval, ::RoundingMode{$S}) + r = round(bareinterval(a), $R) + d = decoration(a) + d = min(d, ifelse(isthin(r), d, def)) + return _unsafe_interval(r, d, isguaranteed(a)) + end + end end diff --git a/src/intervals/arithmetic/power.jl b/src/intervals/arithmetic/power.jl index 5e7f9f52f..9f3290401 100644 --- a/src/intervals/arithmetic/power.jl +++ b/src/intervals/arithmetic/power.jl @@ -2,36 +2,43 @@ # of the IEEE Standard 1788-2015 and required for set-based flavor in Section # 10.5.3 -# CRlibm does not contain a correctly-rounded `^` function for Float64 -# use the BigFloat version from MPFR instead, which is correctly-rounded -for T in (:Integer, :Float64, :BigFloat, :Interval) # need explicit signatures to avoid method ambiguities - @eval ^(a::Interval{Float64}, x::$T) = Interval{Float64}((bigequiv(a))^x) -end - -# overwrite behaviour for small integer powers from -# https://github.com/JuliaLang/julia/pull/24240 -Base.literal_pow(::typeof(^), x::Interval{T}, ::Val{p}) where {T<:NumTypes,p} = x^p - -""" - ^(a::Interval, b::Interval) - ^(a::Interval, b) -Implement the `pow` function of the IEEE Standard 1788-2015 (Table 9.1). -""" -^(a::F, b::F) where {F<:Interval} = F(bigequiv(a)^b) +# bare intervals -for T ∈ (:AbstractFloat, :Integer) - @eval ^(a::F, b::$T) where {F<:Interval} = F(bigequiv(a)^b) +# code inspired by `power_by_squaring(::Any, ::Integer)` in base/intfuncs.jl +Base.@assume_effects :terminates_locally function _positive_power_by_squaring(x::BareInterval, p::Integer) + if p == 1 + return x + elseif p == 0 + return one(x) + elseif p == 2 + return x*x + end + t = trailing_zeros(p) + 1 + p >>= t + while (t -= 1) > 0 + x *= x + end + y = x + while p > 0 + t = trailing_zeros(p) + 1 + p >>= t + while (t -= 1) >= 0 + x *= x + end + y *= x + end + return y end -^(a::F, b::AbstractFloat) where {F<:Interval{BigFloat}} = a^big(b) +nthpow(x::BareInterval{T}, n::Integer) where {T<:NumTypes} = BareInterval{T}(nthpow(_bigequiv(x), n)) -function ^(a::Interval{BigFloat}, n::Integer) +function nthpow(a::BareInterval{BigFloat}, n::Integer) isempty_interval(a) && return a - iszero(n) && return one(Interval{BigFloat}) + iszero(n) && return one(BareInterval{BigFloat}) n == 1 && return a - (n < 0 && isthinzero(a)) && return emptyinterval(BigFloat) + (n < 0 && isthinzero(a)) && return emptyinterval(BareInterval{BigFloat}) if isodd(n) # odd power isentire_interval(a) && return a @@ -74,22 +81,46 @@ function ^(a::Interval{BigFloat}, n::Integer) end end -function ^(a::Interval{BigFloat}, x::BigFloat) - domain = unsafe_interval(BigFloat, zero(BigFloat), typemax(BigFloat)) +""" + ^(x::BareInterval, y::BareInterval) + +Implement the `pow` function of the IEEE Standard 1788-2015 (Table 9.1). +""" +^(x::BareInterval{T}, y::BareInterval{T}) where {T<:NumTypes} = BareInterval{T}(_bigequiv(x)^y) + +^(x::BareInterval, y::BareInterval) = ^(promote(x, y)...) + +function ^(x::BareInterval{BigFloat}, y::BareInterval) + isempty_interval(y) && return y + domain = _unsafe_bareinterval(BigFloat, zero(BigFloat), typemax(BigFloat)) + x = intersect_interval(x, domain) + isempty_interval(x) && return x + return hull(_pow(x, inf(y)), _pow(x, sup(y))) +end + +# function _pow(a::BareInterval{T}, x::AbstractFloat) where {T<:Rational} +# a = unsafe_interval(float(T), inf(a).num/inf(a).den, sup(a).num/sup(a).den) +# return BareInterval{T}(a^x) +# end + +_pow(a::BareInterval{BigFloat}, b::AbstractFloat) = _pow(a, big(b)) + +function _pow(a::BareInterval{BigFloat}, x::BigFloat) + domain = _unsafe_bareinterval(BigFloat, zero(BigFloat), typemax(BigFloat)) if isthinzero(a) - x > 0 && return zero(Interval{BigFloat}) - return emptyinterval(BigFloat) + x > 0 && return zero(BareInterval{BigFloat}) + return emptyinterval(BareInterval{BigFloat}) end - isinteger(x) && return a^(round(Int, x)) + isinteger(x) && return nthpow(a, Integer(x)) x == 0.5 && return sqrt(a) a = intersect_interval(a, domain) isempty_interval(a) && return a M = typemax(BigFloat) - MM = typemax(Interval{BigFloat}) + MM = typemax(BareInterval{BigFloat}) lo = @round(BigFloat, inf(a)^x, inf(a)^x) lo = (inf(lo) == M) ? MM : lo @@ -109,153 +140,86 @@ function ^(a::Interval{BigFloat}, x::BigFloat) return hull(lo, hi) end -function ^(a::Interval{T}, x::AbstractFloat) where {T<:Rational} - a = unsafe_interval(float(T), inf(a).num/inf(a).den, sup(a).num/sup(a).den) - return Interval{T}(a^x) -end - -# Rational power -function ^(a::F, x::Rational{R}) where {T<:NumTypes,F<:Interval{T},R<:Integer} +function _pow(a::BareInterval{BigFloat}, x::Rational{T}) where {T<:Integer} p = x.num q = x.den isempty_interval(a) && return a iszero(x) && return one(a) - # x < 0 && return inv(a^(-x)) - x < 0 && return F( inv( (bigequiv(a))^(-x) ) ) + x < 0 && return inv(_pow(a, -x)) if isthinzero(a) x > zero(x) && return zero(a) return emptyinterval(a) end - isinteger(x) && return a^R(x) + isinteger(x) && return nthpow(a, T(x)) x == (1//2) && return sqrt(a) alo, ahi = bounds(a) if ahi < 0 - return emptyinterval(T) + return emptyinterval(BareInterval{BigFloat}) end if alo < 0 && ahi ≥ 0 - a = intersect_interval(a, unsafe_interval(T, zero(T), typemax(T))) + a = intersect_interval(a, _unsafe_bareinterval(BigFloat, zero(BigFloat), typemax(BigFloat))) end - b = nthroot( bigequiv(a), q) - - p == 1 && return F(b) - - return F(b^p) -end - -# Interval power of an interval: -function ^(a::Interval{BigFloat}, x::Interval) - isempty_interval(x) && return x - domain = unsafe_interval(BigFloat, zero(BigFloat), typemax(BigFloat)) - a = intersect_interval(a, domain) - isempty_interval(a) && return a - return hull(a^inf(x), a^sup(x)) -end - -""" - hypot(x::Interval, n::Integer) - -Direct implemntation of `hypot` using intervals. -""" -hypot(x::Interval, y::Interval) = sqrt(x^2 + y^2) - - -""" - pow(x::Interval, n::Integer) - -A faster implementation of `x^n`, currently using `power_by_squaring`. -`pow(x, n)` will usually return an interval that is slightly larger than that -calculated by `x^n`, but is guaranteed to be a correct -enclosure when using multiplication with correct rounding. -""" -function pow(x::Interval{T}, n::Integer) where {T<:NumTypes} - n < 0 && return 1/pow(x, -n) - isempty_interval(x) && return x - - if iseven(n) && in_interval(0, x) - xmig = mig(x) - xmag = mag(x) - return hull(zero(x), - Base.power_by_squaring(unsafe_interval(T, xmig, xmig), n), - Base.power_by_squaring(unsafe_interval(T, xmag, xmag), n)) - else - xinf = inf(x) - xsup = sup(x) - return hull(Base.power_by_squaring(unsafe_interval(T, xinf, xinf), n), - Base.power_by_squaring(unsafe_interval(T, xsup, xsup), n)) - end -end + b = nthroot(a, q) -function pow(x::Interval, y::Interval) # fast real power, including for y an Interval - isempty_interval(x) && return x - isthininteger(y) && return pow(x, Int(inf(y))) - return exp(y * log(x)) -end + p == 1 && return b -function pow(x::Interval, y) # fast real power, including for y an Interval - isempty_interval(x) && return x - isinteger(y) && return pow(x, Int(inf(y))) - return exp(y * log(x)) + return nthpow(b, p) end -for f in (:exp, :expm1) +for f ∈ (:exp, :expm1) @eval begin - function ($f)(a::Interval{T}) where {T<:NumTypes} + function $f(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - return @round( T, ($f)(inf(a)), ($f)(sup(a)) ) + return @round( T, $f(inf(a)), $f(sup(a)) ) end end end +for f ∈ (:exp2, :exp10, :cbrt) + @eval begin + $f(a::BareInterval{T}) where {T<:NumTypes} = BareInterval{T}($f(_bigequiv(a))) # no CRlibm version -for f in (:exp2, :exp10, :cbrt) - @eval function ($f)(x::BigFloat, r::RoundingMode) # add BigFloat functions with rounding: - setrounding(BigFloat, r) do - ($f)(x) - end - end - - @eval ($f)(a::F) where {F<:Interval} = F($f(bigequiv(a))) # no CRlibm version - - @eval function ($f)(a::Interval{BigFloat}) + function $f(a::BareInterval{BigFloat}) isempty_interval(a) && return a - return @round( BigFloat, ($f)(inf(a)), ($f)(sup(a)) ) + return @round( BigFloat, $f(inf(a)), $f(sup(a)) ) end + end end -for f in (:log, :log2, :log10) - @eval function ($f)(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, zero(T), typemax(T)) - a = intersect_interval(a, domain) +for f ∈ (:log, :log2, :log10) + @eval function $f(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, zero(T), typemax(T)) + a = intersect_interval(a, domain) - (isempty_interval(a) || sup(a) ≤ zero(T)) && return emptyinterval(T) + (isempty_interval(a) || sup(a) ≤ 0) && return emptyinterval(BareInterval{T}) - return @round( T, ($f)(inf(a)), ($f)(sup(a)) ) - end + return @round( T, $f(inf(a)), $f(sup(a)) ) + end end -function log1p(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, -one(T), typemax(T)) +function log1p(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), typemax(T)) a = intersect_interval(a, domain) - (isempty_interval(a) || sup(a) ≤ -1) && return emptyinterval(T) + (isempty_interval(a) || sup(a) ≤ -1) && return emptyinterval(BareInterval{T}) @round( T, log1p(inf(a)), log1p(sup(a)) ) end """ - nthroot(a::Interval, n::Integer) + nthroot(a::BareInterval, n::Integer) -Compute the real n-th root of Interval. +Compute the real `n`-th root of `a`. """ -function nthroot(a::Interval{BigFloat}, n::Integer) +function nthroot(a::BareInterval{BigFloat}, n::Integer) isempty_interval(a) && return a n == 1 && return a n == 2 && return sqrt(a) @@ -264,9 +228,9 @@ function nthroot(a::Interval{BigFloat}, n::Integer) n < 0 && return inv(nthroot(a, -n)) alo, ahi = bounds(a) - ahi < 0 && iseven(n) && return emptyinterval(BigFloat) + ahi < 0 && iseven(n) && return emptyinterval(BareInterval{BigFloat}) if alo < 0 && ahi ≥ 0 && iseven(n) - a = intersect_interval(a, unsafe_interval(BigFloat, zero(BigFloat), typemax(BigFloat))) + a = intersect_interval(a, _unsafe_bareinterval(BigFloat, zero(BigFloat), typemax(BigFloat))) alo, ahi = bounds(a) end ui = convert(Culong, n) @@ -274,19 +238,175 @@ function nthroot(a::Interval{BigFloat}, n::Integer) high = BigFloat() ccall((:mpfr_rootn_ui, :libmpfr), Int32 , (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode) , low , alo , ui, MPFRRoundDown) ccall((:mpfr_rootn_ui, :libmpfr), Int32 , (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode) , high , ahi , ui, MPFRRoundUp) - return interval(BigFloat, low , high) + return bareinterval(BigFloat, low , high) end -function nthroot(a::F, n::Integer) where {F<:Interval} +function nthroot(a::BareInterval{T}, n::Integer) where {T<:NumTypes} n == 1 && return a n == 2 && return sqrt(a) - abig = bigequiv(a) + abig = _bigequiv(a) if n < 0 issubnormal(mag(a)) && return inv(nthroot(a, -n)) - return F( inv(nthroot(abig, -n)) ) + return BareInterval{T}(inv(nthroot(abig, -n))) end b = nthroot(abig, n) - return F(b) + return BareInterval{T}(b) +end + +""" + hypot(x::BareInterval, n::BareInterval) + +Compute the hypotenuse. +""" +hypot(x::BareInterval, y::BareInterval) = sqrt(nthpow(x, 2) + nthpow(y, 2)) + +""" + fastpow(x::BareInterval, n::Integer) + +A faster implementation of `x^n`, currently using `power_by_squaring`. +`fastpow(x, n)` will usually return an interval that is slightly larger than that +calculated by `x^n`, but is guaranteed to be a correct +enclosure when using multiplication with correct rounding. +""" +function fastpow(x::BareInterval{T}, n::Integer) where {T<:NumTypes} + n < 0 && return inv(fastpow(x, -n)) + isempty_interval(x) && return x + + if iseven(n) && in_interval(0, x) + xmig = mig(x) + xmag = mag(x) + return hull(zero(x), + _positive_power_by_squaring(_unsafe_bareinterval(T, xmig, xmig), n), + _positive_power_by_squaring(_unsafe_bareinterval(T, xmag, xmag), n)) + else + xinf = inf(x) + xsup = sup(x) + return hull(_positive_power_by_squaring(_unsafe_bareinterval(T, xinf, xinf), n), + _positive_power_by_squaring(_unsafe_bareinterval(T, xsup, xsup), n)) + end +end + +function fastpow(x::BareInterval, y::BareInterval) + isempty_interval(x) && return x + isthininteger(y) && return fastpow(x, Integer(sup(y))) + return exp(y * log(x)) +end + +fastpow(x::BareInterval{T}, y::S) where {T<:NumTypes,S<:Real} = + fastpow(x, bareinterval(promote_numtype(T, S), y)) + + + +# decorated intervals + +# overwrite behaviour for small integer powers from https://github.com/JuliaLang/julia/pull/24240 +Base.literal_pow(::typeof(^), x::Interval, ::Val{p}) where {p} = x^p + +function nthpow(x::Interval, n::Integer) + r = nthpow(bareinterval(x), n) + d = min(decoration(x), decoration(r)) + d = min(d, ifelse(n < 0 && in_interval(0, x), trv, d)) + return _unsafe_interval(r, d, isguaranteed(x)) +end + +function ^(xx::Interval, qq::Interval) + x = bareinterval(xx) + q = bareinterval(qq) + r = x^q + d = min(decoration(xx), decoration(qq), decoration(r)) + t = isguaranteed(xx) & isguaranteed(qq) + if inf(x) > 0 || (inf(x) ≥ 0 && inf(q) > 0) || + (isthininteger(q) && inf(q) > 0) || + (isthininteger(q) && !in_interval(0, x)) + return _unsafe_interval(r, d, t) + end + return _unsafe_interval(r, trv, t) +end +^(x::Interval, y::Real) = ^(promote(x, y)...) +^(x::Real, y::Interval) = ^(promote(x, y)...) +# needed to resolve ambiguities +^(x::Interval, n::Integer) = x ^ (n//1) +for S ∈ (:Rational, :AbstractFloat) + @eval function ^(x::Interval{T}, y::$S) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, zero(T), typemax(T)) + bx = bareinterval(x) + bx = intersect_interval(bx, domain) + isempty_interval(x) && return x + r = BareInterval{T}(_pow(_bigequiv(bx), y)) + d = min(decoration(x), decoration(r)) + if inf(x) > 0 || (inf(x) ≥ 0 && y > 0) || + (isinteger(y) && y > 0) || + (isinteger(y) && !in_interval(0, x)) + return _unsafe_interval(r, d, false) + end + return _unsafe_interval(r, min(d, trv), false) + end +end + +for f ∈ (:exp, :exp2, :exp10, :expm1, :cbrt) + @eval function $f(xx::Interval) + x = bareinterval(xx) + r = $f(x) + d = min(decoration(r), decoration(xx)) + return _unsafe_interval(r, d, isguaranteed(xx)) + end +end + +for f ∈ (:log, :log2, :log10) + @eval function $f(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, zero(T), typemax(T)) + x = bareinterval(a) + r = $f(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(isstrictsubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) + end +end + +function log1p(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), typemax(T)) + x = bareinterval(a) + r = log1p(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(isstrictsubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +function nthroot(a::Interval{T}, n::Integer) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, ifelse(iseven(n), zero(T), typemin(T)), typemax(T)) + x = bareinterval(a) + r = nthroot(x, n) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(issubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +hypot(x::Interval, y::Interval) = sqrt(x^2 + y^2) + +function fastpow(xx::Interval, qq::Interval) + x = bareinterval(xx) + q = bareinterval(qq) + r = fastpow(x, q) + d = min(decoration(xx), decoration(qq), decoration(r)) + t = isguaranteed(xx) & isguaranteed(qq) + if inf(x) > 0 || (inf(x) ≥ 0 && inf(q) > 0) || + (isthininteger(q) && inf(q) > 0) || + (isthininteger(q) && !in_interval(0, x)) + return _unsafe_interval(r, d, t) + end + return _unsafe_interval(r, trv, t) +end + +function fastpow(xx::Interval, q::Real) + x = bareinterval(xx) + r = fastpow(x, q) + d = min(decoration(xx), decoration(r)) + if inf(x) > 0 || (inf(x) ≥ 0 && q > 0) || + (isinteger(q) && q > 0) || + (isinteger(q) && !in_interval(0, x)) + return _unsafe_interval(r, d, false) + end + return _unsafe_interval(r, trv, false) end diff --git a/src/intervals/arithmetic/signbit.jl b/src/intervals/arithmetic/signbit.jl deleted file mode 100644 index 7a7135a26..000000000 --- a/src/intervals/arithmetic/signbit.jl +++ /dev/null @@ -1,40 +0,0 @@ -""" - signbit(a::Interval) - -Return an interval containing 1 if any element in `a` is negative and containing -0 if any element in `a` is positive. An empty interval is returned if `a` is -empty. - -# Examples -```jldoctest -julia> setformat(:full); - -julia> signbit(interval(-4.0)) -Interval{Float64}(1.0, 1.0) - -julia> signbit(interval(5.0)) -Interval{Float64}(0.0, 0.0) - -julia> signbit(interval(-4.0, 5.0)) -Interval{Float64}(0.0, 1.0) -``` -""" -function signbit(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return a - lo, hi = bounds(a) - return interval(T, signbit(hi), signbit(lo)) -end - -for T ∈ (:Interval, :Real, :Float64, :Float32, :Signed, :Unsigned) - @eval begin - copysign(a::$T, b::Interval) = abs(a) * (1 - 2 * signbit(b)) - flipsign(a::$T, b::Interval) = a * (1 - 2 * signbit(b)) - end -end - -for T ∈ (:Real, :Float64, :Float32, :Signed, :Unsigned) - @eval begin - copysign(a::Interval, b::$T) = abs(a) * (1 - 2 * signbit(b)) - flipsign(a::Interval, b::$T) = a * (1 - 2 * signbit(b)) - end -end diff --git a/src/intervals/arithmetic/trigonometric.jl b/src/intervals/arithmetic/trigonometric.jl index fe803d295..b2a15137d 100644 --- a/src/intervals/arithmetic/trigonometric.jl +++ b/src/intervals/arithmetic/trigonometric.jl @@ -2,30 +2,33 @@ # Section 9.1 of the IEEE Standard 1788-2015 and required for set-based flavor # in Section 10.5.3 -# needed to prevent stack overflow +# not in the IEEE Standard 1788-2015 -rad2deg(x::Interval) = (x / π) * 180 +rad2deg(a::BareInterval{T}) where {T<:NumTypes} = (a / bareinterval(T, π)) * bareinterval(T, 180) +rad2deg(a::Interval{T}) where {T<:NumTypes} = (a / interval(T, π)) * interval(T, 180) -deg2rad(x::Interval) = (x * π) / 180 +deg2rad(a::BareInterval{T}) where {T<:NumTypes} = (a * bareinterval(T, π)) / bareinterval(T, 180) +deg2rad(a::Interval{T}) where {T<:NumTypes} = (a * interval(T, π)) / interval(T, 180) -sincospi(x::Interval) = (sinpi(x), cospi(x)) +sincospi(a::BareInterval) = (sinpi(a), cospi(a)) +sincospi(a::Interval) = (sinpi(a), cospi(a)) # -const halfpi = π / 2 +_unsafe_scale(a::BareInterval{T}, α::T) where {T<:NumTypes} = @round(T, inf(a) * α, sup(a) * α) # assumes `α` is postive -half_pi(::Type{T}) where {T<:NumTypes} = unsafe_scale(interval(T, π), convert(T, 0.5)) -two_pi(::Type{T}) where {T<:NumTypes} = unsafe_scale(interval(T, π), convert(T, 2)) +_half_pi(::Type{T}) where {T<:NumTypes} = _unsafe_scale(bareinterval(T, π), convert(T, 0.5)) +_two_pi(::Type{T}) where {T<:NumTypes} = _unsafe_scale(bareinterval(T, π), convert(T, 2)) -function range_atan(::Type{T}) where {T<:NumTypes} - temp = sup(interval(T, π)) - return unsafe_interval(T, -temp, temp) +function _range_atan(::Type{T}) where {T<:NumTypes} + temp = sup(bareinterval(T, π)) + return _unsafe_bareinterval(T, -temp, temp) end -half_range_atan(::Type{T}) where {T<:NumTypes} = range_atan(T) / 2 +_half_range_atan(::Type{T}) where {T<:NumTypes} = _unsafe_scale(_range_atan(T), convert(T, 0.5)) """ - find_quadrants(x) + _find_quadrants(x) Finds the quadrant(s) corresponding to a given floating-point number. The quadrants are labelled as 0 for x ∈ [0, π/2], etc. @@ -36,39 +39,40 @@ This is a rather indirect way to determine if π/2 and 3π/2 are contained in the interval; cf. the formula for sine of an interval in Tucker, *Validated Numerics*. """ -function find_quadrants(::Type{T}, x) where {T<:NumTypes} - temp = unsafe_interval(T, x, x) / half_pi(T) +function _find_quadrants(::Type{T}, x) where {T<:NumTypes} + temp = _unsafe_bareinterval(T, x, x) / _half_pi(T) return floor(inf(temp)), floor(sup(temp)) end # Quadrant function for Float64 specialized methods -function quadrant(x::Float64) +function _quadrant(x::Float64) x_mod2pi = rem2pi(x, RoundNearest) # gives result in [-pi, pi] - x_mod2pi < -halfpi && return (2, x_mod2pi) + x_mod2pi < -(π/2) && return (2, x_mod2pi) x_mod2pi < 0 && return (3, x_mod2pi) - x_mod2pi <= halfpi && return (0, x_mod2pi) + x_mod2pi ≤ (π/2) && return (0, x_mod2pi) return 1, x_mod2pi end """ + sin(a::BareInterval) sin(a::Interval) Implement the `sin` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function sin(a::Interval{T}) where {T<:NumTypes} +function sin(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - whole_range = unsafe_interval(T, -one(T), one(T)) + whole_range = _unsafe_bareinterval(T, -one(T), one(T)) - diam(a) > inf(two_pi(T)) && return whole_range + diam(a) > inf(_two_pi(T)) && return whole_range - # The following is equivalent to doing temp = a / half_pi and + # The following is equivalent to doing temp = a / _half_pi and # taking floor(inf(a)), floor(sup(a)) alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) if hi_quadrant - lo_quadrant > 4 # close to limits return whole_range @@ -79,7 +83,7 @@ function sin(a::Interval{T}) where {T<:NumTypes} # Different cases depending on the two quadrants: if lo_quadrant == hi_quadrant - ahi - alo > inf(interval(T, π)) && return whole_range # in same quadrant but separated by almost 2pi + ahi - alo > inf(bareinterval(T, π)) && return whole_range # in same quadrant but separated by almost 2pi lo = @round(T, sin(alo), sin(alo)) hi = @round(T, sin(ahi), sin(ahi)) return hull(lo, hi) @@ -101,22 +105,22 @@ function sin(a::Interval{T}) where {T<:NumTypes} end end -function sin(a::Interval{Float64}) +function sin(a::BareInterval{Float64}) isempty_interval(a) && return a - whole_range = unsafe_interval(Float64, -1.0, 1.0) + whole_range = _unsafe_bareinterval(Float64, -1.0, 1.0) - diam(a) > inf(two_pi(Float64)) && return whole_range + diam(a) > inf(_two_pi(Float64)) && return whole_range alo, ahi = bounds(a) - lo_quadrant, lo = quadrant(alo) - hi_quadrant, hi = quadrant(ahi) + lo_quadrant, lo = _quadrant(alo) + hi_quadrant, hi = _quadrant(ahi) lo, hi = alo, ahi # should be able to use the modulo version of a, but doesn't seem to work # Different cases depending on the two quadrants: if lo_quadrant == hi_quadrant - ahi - alo > inf(interval(Float64, π)) && return whole_range + ahi - alo > inf(bareinterval(Float64, π)) && return whole_range if lo_quadrant == 1 || lo_quadrant == 2 # negative slope @@ -137,28 +141,36 @@ function sin(a::Interval{Float64}) elseif ( lo_quadrant == 1 || lo_quadrant == 2 ) && ( hi_quadrant == 3 || hi_quadrant == 0 ) return @round(Float64, -1.0, max(sin(lo), sin(hi))) - else #if( iszero(lo_quadrant) && hi_quadrant == 3 ) || ( lo_quadrant == 2 && hi_quadrant == 1 ) + else # if ( iszero(lo_quadrant) && hi_quadrant == 3 ) || ( lo_quadrant == 2 && hi_quadrant == 1 ) return whole_range end end -sinpi(a::Interval) = sin(a * π) +function sin(a::Interval) + r = sin(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +sinpi(a::BareInterval{T}) where {T<:NumTypes} = sin(a * bareinterval(T, π)) # not in the IEEE Standard 1788-2015 +sinpi(a::Interval{T}) where {T<:NumTypes} = sin(a * interval(T, π)) """ + cos(a::BareInterval) cos(a::Interval) Implement the `cos` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function cos(a::Interval{T}) where {T<:NumTypes} +function cos(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - whole_range = unsafe_interval(T, -one(T), one(T)) + whole_range = _unsafe_bareinterval(T, -one(T), one(T)) - diam(a) > inf(two_pi(T)) && return whole_range + diam(a) > inf(_two_pi(T)) && return whole_range alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) if hi_quadrant - lo_quadrant > 4 # close to limits return whole_range @@ -169,7 +181,7 @@ function cos(a::Interval{T}) where {T<:NumTypes} # Different cases depending on the two quadrants: if lo_quadrant == hi_quadrant # Interval limits in the same quadrant - ahi - alo > inf(interval(T, π)) && return whole_range + ahi - alo > inf(bareinterval(T, π)) && return whole_range lo = @round(T, cos(alo), cos(alo)) hi = @round(T, cos(ahi), cos(ahi)) return hull(lo, hi) @@ -191,22 +203,22 @@ function cos(a::Interval{T}) where {T<:NumTypes} end end -function cos(a::Interval{Float64}) +function cos(a::BareInterval{Float64}) isempty_interval(a) && return a - whole_range = unsafe_interval(Float64, -1.0, 1.0) + whole_range = _unsafe_bareinterval(Float64, -1.0, 1.0) - diam(a) > inf(two_pi(Float64)) && return whole_range + diam(a) > inf(_two_pi(Float64)) && return whole_range alo, ahi = bounds(a) - lo_quadrant, lo = quadrant(alo) - hi_quadrant, hi = quadrant(ahi) + lo_quadrant, lo = _quadrant(alo) + hi_quadrant, hi = _quadrant(ahi) lo, hi = alo, ahi # should be able to use the modulo version of a, but doesn't seem to work # Different cases depending on the two quadrants: if lo_quadrant == hi_quadrant # Interval limits in the same quadrant - ahi - alo > inf(interval(Float64, π)) && return whole_range + ahi - alo > inf(bareinterval(Float64, π)) && return whole_range if lo_quadrant == 2 || lo_quadrant == 3 # positive slope @@ -232,78 +244,94 @@ function cos(a::Interval{Float64}) end end -cospi(a::Interval) = cos(a * π) +function cos(a::Interval) + r = cos(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +cospi(a::BareInterval{T}) where {T<:NumTypes} = cos(a * bareinterval(T, π)) # not in the IEEE Standard 1788-2015 +cospi(a::Interval{T}) where {T<:NumTypes} = cos(a * interval(T, π)) """ + tan(a::BareInterval) tan(a::Interval) Implement the `tan` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function tan(a::Interval{T}) where {T<:NumTypes} +function tan(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - diam(a) > inf(interval(T, π)) && return entireinterval(T) + diam(a) > inf(bareinterval(T, π)) && return entireinterval(BareInterval{T}) alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) lo_quadrant_mod = mod(lo_quadrant, 2) hi_quadrant_mod = mod(hi_quadrant, 2) if iszero(lo_quadrant_mod) && hi_quadrant_mod == 1 # check if really contains singularity: - if issubset_interval(hi_quadrant * half_pi(T), a) - return entireinterval(T) # crosses singularity + if issubset_interval(_unsafe_scale(_half_pi(T), hi_quadrant), a) + return entireinterval(BareInterval{T}) # crosses singularity end elseif lo_quadrant_mod == hi_quadrant_mod && hi_quadrant > lo_quadrant # must cross singularity - return entireinterval(T) + return entireinterval(BareInterval{T}) end return @round(T, tan(alo), tan(ahi)) end -function tan(a::Interval{Float64}) +function tan(a::BareInterval{Float64}) isempty_interval(a) && return a - diam(a) > inf(interval(Float64, π)) && return entireinterval(Float64) + diam(a) > inf(bareinterval(Float64, π)) && return entireinterval(BareInterval{Float64}) alo, ahi = bounds(a) - lo_quadrant, lo = quadrant(alo) - hi_quadrant, hi = quadrant(ahi) + lo_quadrant, lo = _quadrant(alo) + hi_quadrant, hi = _quadrant(ahi) lo_quadrant_mod = mod(lo_quadrant, 2) hi_quadrant_mod = mod(hi_quadrant, 2) if iszero(lo_quadrant_mod) && hi_quadrant_mod == 1 - return entireinterval(Float64) # crosses singularity + return entireinterval(BareInterval{Float64}) # crosses singularity elseif lo_quadrant_mod == hi_quadrant_mod && hi_quadrant != lo_quadrant # must cross singularity - return entireinterval(Float64) + return entireinterval(BareInterval{Float64}) end return @round(Float64, tan(alo), tan(ahi)) end +function tan(a::Interval) + r = tan(bareinterval(a)) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(isbounded(r), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + cot(a::BareInterval) cot(a::Interval) Implement the `cot` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function cot(a::Interval{T}) where {T<:NumTypes} +function cot(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - diam(a) > inf(interval(T, π)) && return entireinterval(T) + diam(a) > inf(bareinterval(T, π)) && return entireinterval(BareInterval{T}) - isthinzero(a) && return emptyinterval(T) + isthinzero(a) && return emptyinterval(BareInterval{T}) alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) lo_quadrant = mod(lo_quadrant, 4) hi_quadrant = mod(hi_quadrant, 4) @@ -317,7 +345,7 @@ function cot(a::Interval{T}) where {T<:NumTypes} elseif (lo_quadrant == 3 && iszero(hi_quadrant)) || (lo_quadrant == 1 && hi_quadrant ==2) iszero(ahi) && return @round(T, typemin(T), cot(alo)) - return entireinterval(T) + return entireinterval(BareInterval{T}) elseif (iszero(lo_quadrant) && hi_quadrant == 1) || (lo_quadrant == 2 && hi_quadrant == 3) return @round(T, cot(ahi), cot(alo)) @@ -325,28 +353,28 @@ function cot(a::Interval{T}) where {T<:NumTypes} elseif ( lo_quadrant == 2 && iszero(hi_quadrant)) iszero(ahi) && return @round(T, typemin(T), cot(alo)) - return entireinterval(T) + return entireinterval(BareInterval{T}) else - return entireinterval(T) + return entireinterval(BareInterval{T}) end end -cot(a::Interval{Float64}) = atomic(Float64, cot(big(a))) +cot(a::BareInterval{Float64}) = atomic(Float64, cot(_bigequiv(a))) """ - sec(a::Interval) + sec(a::BareInterval) Implement the `sec` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function sec(a::Interval{T}) where {T<:NumTypes} +function sec(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - diam(a) > inf(interval(T, π)) && return entireinterval(T) + diam(a) > inf(interval(T, π)) && return entireinterval(BareInterval{T}) alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) lo_quadrant = mod(lo_quadrant, 4) hi_quadrant = mod(hi_quadrant, 4) @@ -358,7 +386,7 @@ function sec(a::Interval{T}) where {T<:NumTypes} return hull(lo, hi) elseif (iszero(lo_quadrant) && hi_quadrant == 1) || (lo_quadrant == 2 && hi_quadrant ==3) - return entireinterval(T) + return entireinterval(BareInterval{T}) elseif lo_quadrant == 3 && iszero(hi_quadrant) return @round(T, one(T), max(sec(alo), sec(ahi))) @@ -367,27 +395,27 @@ function sec(a::Interval{T}) where {T<:NumTypes} return @round(T, min(sec(alo), sec(ahi)), -one(T)) else - return entireinterval(T) + return entireinterval(BareInterval{T}) end end -sec(a::Interval{Float64}) = atomic(Float64, sec(big(a))) +sec(a::BareInterval{Float64}) = atomic(Float64, sec(_bigequiv(a))) """ - csc(a::Interval) + csc(a::BareInterval) Implement the `csc` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function csc(a::Interval{T}) where {T<:NumTypes} +function csc(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - diam(a) > inf(interval(T, π)) && return entireinterval(T) + diam(a) > inf(bareinterval(T, π)) && return entireinterval(BareInterval{T}) - isthinzero(a) && return emptyinterval(T) + isthinzero(a) && return emptyinterval(BareInterval{T}) alo, ahi = bounds(a) - lo_quadrant = minimum(find_quadrants(T, alo)) - hi_quadrant = maximum(find_quadrants(T, ahi)) + lo_quadrant = minimum(_find_quadrants(T, alo)) + hi_quadrant = maximum(_find_quadrants(T, ahi)) lo_quadrant = mod(lo_quadrant, 4) hi_quadrant = mod(hi_quadrant, 4) @@ -403,7 +431,7 @@ function csc(a::Interval{T}) where {T<:NumTypes} elseif (lo_quadrant == 3 && iszero(hi_quadrant)) || (lo_quadrant == 1 && hi_quadrant == 2) iszero(ahi) && return @round(T, typemin(T), csc(alo)) - return entireinterval(T) + return entireinterval(BareInterval{T}) elseif iszero(lo_quadrant) && hi_quadrant == 1 return @round(T, one(T), max(csc(alo), csc(ahi))) @@ -414,59 +442,86 @@ function csc(a::Interval{T}) where {T<:NumTypes} elseif ( lo_quadrant == 2 && iszero(hi_quadrant)) iszero(ahi) && return @round(T, typemin(T), -one(T)) - return entireinterval(T) + return entireinterval(BareInterval{T}) else - return entireinterval(T) + return entireinterval(BareInterval{T}) end end -csc(a::Interval{Float64}) = atomic(Float64, csc(big(a))) +csc(a::BareInterval{Float64}) = atomic(Float64, csc(_bigequiv(a))) """ + asin(a::BareInterval) asin(a::Interval) Implement the `asin` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function asin(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, -one(T), one(T)) +function asin(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) a = intersect_interval(a, domain) isempty_interval(a) && return a alo, ahi = bounds(a) return @round(T, asin(alo), asin(ahi)) end +function asin(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) + x = bareinterval(a) + r = asin(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(issubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + acos(a::BareInterval) acos(a::Interval) Implement the `acos` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function acos(a::Interval{T}) where {T<:NumTypes} - domain = unsafe_interval(T, -one(T), one(T)) +function acos(a::BareInterval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) a = intersect_interval(a, domain) isempty_interval(a) && return a alo, ahi = bounds(a) return @round(T, acos(ahi), acos(alo)) end +function acos(a::Interval{T}) where {T<:NumTypes} + domain = _unsafe_bareinterval(T, -one(T), one(T)) + x = bareinterval(a) + r = acos(x) + d = min(decoration(a), decoration(r)) + d = min(d, ifelse(issubset_interval(x, domain), d, trv)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ + atan(a::BareInterval) atan(a::Interval) Implement the `atan` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function atan(a::Interval{T}) where {T<:NumTypes} +function atan(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a alo, ahi = bounds(a) return @round(T, atan(alo), atan(ahi)) end -function atan(y::Interval{T}, x::Interval{S}) where {T<:NumTypes,S<:NumTypes} - F = Interval{promote_type(T, S)} +function atan(a::Interval) + r = atan(bareinterval(a)) + d = min(decoration(a), decoration(r)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + +function atan(y::BareInterval{T}, x::BareInterval{S}) where {T<:NumTypes,S<:NumTypes} + F = BareInterval{promote_type(T, S)} (isempty_interval(y) || isempty_interval(x)) && return emptyinterval(F) - return F(atan(big(y), big(x))) + return F(atan(_bigequiv(y), _bigequiv(x))) end -function atan(y::Interval{BigFloat}, x::Interval{BigFloat}) +function atan(y::BareInterval{BigFloat}, x::BareInterval{BigFloat}) isempty_interval(y) && return y isempty_interval(x) && return x @@ -476,19 +531,19 @@ function atan(y::Interval{BigFloat}, x::Interval{BigFloat}) # Prevent nonsense results when y has a signed zero: if iszero(ylo) - y = unsafe_interval(BigFloat, z, yhi) + y = _unsafe_bareinterval(BigFloat, z, yhi) end if iszero(yhi) - y = unsafe_interval(BigFloat, ylo, z) + y = _unsafe_bareinterval(BigFloat, ylo, z) end # Check cases based on x if isthinzero(x) - isthinzero(y) && return emptyinterval(BigFloat) - ylo ≥ z && return half_pi(BigFloat) - yhi ≤ z && return -half_pi(BigFloat) - return half_range_atan(BigFloat) + isthinzero(y) && return emptyinterval(BareInterval{BigFloat}) + ylo ≥ z && return _half_pi(BigFloat) + yhi ≤ z && return -_half_pi(BigFloat) + return _half_range_atan(BigFloat) elseif xlo > z isthinzero(y) && return y @@ -499,46 +554,58 @@ function atan(y::Interval{BigFloat}, x::Interval{BigFloat}) return @round(BigFloat, atan(ylo, xlo), atan(yhi, xlo)) elseif xhi < z - isthinzero(y) && return interval(BigFloat, π) + isthinzero(y) && return bareinterval(BigFloat, π) ylo ≥ z && return @round(BigFloat, atan(yhi, xhi), atan(ylo, xlo)) yhi < z && return @round(BigFloat, atan(yhi, xlo), atan(ylo, xhi)) - return range_atan(BigFloat) + return _range_atan(BigFloat) else # z ∈ x if iszero(xlo) isthinzero(y) && return y ylo ≥ z && - return unsafe_interval(BigFloat, atan(ylo, xhi, RoundDown), sup(half_range_atan(BigFloat))) + return _unsafe_bareinterval(BigFloat, atan(ylo, xhi, RoundDown), sup(_half_range_atan(BigFloat))) yhi ≤ z && - return unsafe_interval(BigFloat, inf(half_range_atan(BigFloat)), atan(yhi, xhi, RoundUp)) - return half_range_atan(BigFloat) + return _unsafe_bareinterval(BigFloat, inf(_half_range_atan(BigFloat)), atan(yhi, xhi, RoundUp)) + return _half_range_atan(BigFloat) elseif iszero(xhi) - isthinzero(y) && return interval(BigFloat, π) + isthinzero(y) && return bareinterval(BigFloat, π) ylo ≥ z && - return unsafe_interval(BigFloat, inf(half_pi(BigFloat)), atan(ylo, xlo, RoundUp)) + return _unsafe_bareinterval(BigFloat, inf(_half_pi(BigFloat)), atan(ylo, xlo, RoundUp)) yhi < z && - return unsafe_interval(BigFloat, atan(yhi, xlo, RoundDown), inf(-half_pi(BigFloat))) - return range_atan(BigFloat) + return _unsafe_bareinterval(BigFloat, atan(yhi, xlo, RoundDown), inf(-_half_pi(BigFloat))) + return _range_atan(BigFloat) else ylo ≥ z && return @round(BigFloat, atan(ylo, xhi), atan(ylo, xlo)) yhi < z && return @round(BigFloat, atan(yhi, xlo), atan(yhi, xhi)) - return range_atan(BigFloat) + return _range_atan(BigFloat) end end end +function atan(b::Interval, a::Interval) + y = bareinterval(b) + x = bareinterval(a) + r = atan(y, x) + d = min(decoration(b), decoration(a), decoration(r)) + d = min(d, ifelse(in_interval(0, y), + ifelse(in_interval(0, x), trv, + ifelse(sup(x) < 0, ifelse(inf(y) < 0, def, dac), d)), + d)) + return _unsafe_interval(r, d, isguaranteed(a)) +end + """ - acot(a::Interval) + acot(a::BareInterval) Implement the `acot` function of the IEEE Standard 1788-2015 (Table 9.1). """ -function acot(a::Interval{T}) where {T<:NumTypes} +function acot(a::BareInterval{T}) where {T<:NumTypes} isempty_interval(a) && return a - return atomic(T, interval(acot(bigequiv(sup(a))), acot(bigequiv(inf(a))))) - # return atomic(T, @round(Interval{BigFloat}, acot(bigequiv(sup(a))), acot(bigequiv(inf(a))))) + return atomic(T, bareinterval(T, acot(_bigequiv(sup(a))), acot(_bigequiv(inf(a))))) + # return atomic(T, @round(BigFloat, acot(_bigequiv(sup(a))), acot(_bigequiv(inf(a))))) end diff --git a/src/intervals/complex.jl b/src/intervals/complex.jl index f28549ed8..0caba49c3 100644 --- a/src/intervals/complex.jl +++ b/src/intervals/complex.jl @@ -117,10 +117,3 @@ abs(z::Complex{<:Interval}) = sqrt(abs2(z)) # function norm(z::Complex{T}, p=2) where T<:Interval # return (abs(z)^(p))^(1 / p) # end - -mid(z::Complex) = complex(mid(real(z)), mid(imag(z))) -diam(z::Complex) = max(diam(real(z)), diam(imag(z))) -radius(z::Complex) = max(radius(real(z)), radius(imag(z))) -midradius(z::Complex) = (mid(z), radius(z)) -mag(z::Complex) = sup(abs(z)) -mig(z::Complex) = inf(abs(z)) diff --git a/src/intervals/construction.jl b/src/intervals/construction.jl index 589a6e63b..11add2562 100644 --- a/src/intervals/construction.jl +++ b/src/intervals/construction.jl @@ -1,67 +1,19 @@ -# allowed bound types for an interval -const NumTypes = Union{Rational,AbstractFloat} +# bound type mechanism """ - Interval{T<:NumTypes} <: Real - -Interval type for guaranteed computation with interval arithmetic according to -the IEEE Standard 1788-2015. - -Fields: -- `lo::T` -- `hi::T` + NumTypes -Constructors compliant with the IEEE Standard 1788-2015: -- [`interval`](@ref) -- [`..`](@ref) -- [`±`](@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) and [`@I_str`](@ref). +Constant for the supported types of interval bounds. This is set to +`Union{Rational,AbstractFloat}`. """ -struct Interval{T<:NumTypes} <: Real - lo::T - hi::T - - # need explicit signatures to avoid method ambiguities - - global unsafe_interval(::Type{T}, a::T, b::T) where {S<:Integer,T<:Rational{S}} = - new{T}(_normalisezero(a), _normalisezero(b)) - - unsafe_interval(::Type{T}, a::T, b::T) where {T<:AbstractFloat} = - new{T}(_normalisezero(a), _normalisezero(b)) -end - -_normalisezero(a) = ifelse(iszero(a), zero(a), a) # required by the IEEE Standard 1788-2015 - -Interval{T}(x::Interval) where {T<:NumTypes} = interval(T, inf(x), sup(x)) - -unsafe_interval(::Type{T}, a::Rational, b::Rational) where {S<:Integer,T<:Rational{S}} = - unsafe_interval(T, T(a), T(b)) -unsafe_interval(::Type{T}, a::Rational, b) where {S<:Integer,T<:Rational{S}} = - unsafe_interval(T, T(a), rationalize(S, nextfloat(float(S)(b, RoundUp)))) -unsafe_interval(::Type{T}, a, b::Rational) where {S<:Integer,T<:Rational{S}} = - unsafe_interval(T, rationalize(S, nextfloat(float(S)(a, RoundDown))), T(b)) -function unsafe_interval(::Type{T}, a, b) where {S<:Integer,T<:Rational{S}} - R = float(S) - return unsafe_interval(T, rationalize(S, prevfloat(R(a, RoundDown))), rationalize(S, nextfloat(R(b, RoundUp)))) -end - -unsafe_interval(::Type{T}, a, b) where {T<:AbstractFloat} = unsafe_interval(T, T(a, RoundDown), T(b, RoundUp)) - -# bound type mechanism +const NumTypes = Union{Rational,AbstractFloat} """ default_numtype() Return the default bound type used in [`promote_numtype`](@ref). By default, `default_numtype()` is set to `Float64`. It can be modified by redefining the -function, however it should be set to a concrete subtype of `Rational` or -`AbstractFloat`. +function, however it should be set to a concrete subtype of [`NumTypes`](@ref). # Examples ```jldoctest @@ -88,142 +40,184 @@ default_numtype() = Float64 promote_numtype(T, S) Return the bound type used to construct intervals. The bound type is given by -`promote_type(T, S)` if `T` or `S` is a `Rational` or an `AbstractFloat`; -except when `T` is a `Rational{R}` and `S` is an `AbstractIrrational` -(or vice-versa), in which case the bound type is given by -`Rational{promote_type(R, Int64)}`. In all other cases, the bound type is given -by `promote_type(default_numtype(), T, S)`. +`promote_type(T, S)` if `T` or `S` is a `Rational` or an `AbstractFloat`; except +when `T` is a `Rational{R}` and `S` is an `AbstractIrrational` (or vice-versa), +in which case the bound type is given by `Rational{promote_type(R, Int64)}`. In +all other cases, the bound type is given by +`promote_type(default_numtype(), T, S)`. """ promote_numtype(::Type{T}, ::Type{S}) where {T<:NumTypes,S<:NumTypes} = promote_type(T, S) -promote_numtype(::Type{T}, ::Type{S}) where {T<:NumTypes,S} = promote_type(T, S) -promote_numtype(::Type{T}, ::Type{S}) where {T,S<:NumTypes} = promote_type(T, S) -promote_numtype(::Type{T}, ::Type{S}) where {T,S} = promote_type(default_numtype(), T, S) +promote_numtype(::Type{T}, ::Type{S}) where {T<:NumTypes,S} = promote_type(numtype(T), numtype(S)) +promote_numtype(::Type{T}, ::Type{S}) where {T,S<:NumTypes} = promote_type(numtype(T), numtype(S)) +promote_numtype(::Type{T}, ::Type{S}) where {T,S} = promote_type(default_numtype(), numtype(T), numtype(S)) + promote_numtype(::Type{Rational{T}}, ::Type{<:AbstractIrrational}) where {T<:Integer} = Rational{promote_type(T, Int64)} promote_numtype(::Type{<:AbstractIrrational}, ::Type{Rational{T}}) where {T<:Integer} = Rational{promote_type(T, Int64)} -# promotion -Base.promote_rule(::Type{Interval{T}}, ::Type{Interval{S}}) where {T<:NumTypes,S<:NumTypes} = - Interval{promote_type(T, S)} -# constructors -""" - interval([T<:Union{Rational,AbstractFloat}=default_numtype()], a, b) -Create the interval ``[a, b]`` according to the IEEE Standard 1788-2015. The -validity of the interval is checked by [`is_valid_interval`](@ref): if `true` -then an `Interval{T}` is constructed, otherwise a warning is printed and the -empty interval is returned. +# bare interval, i.e. interval with no decoration -!!! warning - Nothing is done to compensate for the fact that floating point literals are - 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. +""" + BareInterval{T<:NumTypes} -See also: [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref). +Interval type for guaranteed computation with interval arithmetic according to +the IEEE Standard 1788-2015. Unlike [`Interval`](@ref), this bare interval does +not have decorations, is not a subtype of `Real` and errors on operations mixing +`BareInterval` and `Number`. -# Examples -```jldoctest -julia> setformat(:full); +Fields: +- `lo :: T` +- `hi :: T` -julia> interval(1//1, π) -Interval{Rational{Int64}}(1//1, 85563208//27235615) +Constructor compliant with the IEEE Standard 1788-2015: [`bareinterval`](@ref). -julia> interval(Rational{Int32}, 1//1, π) -Interval{Rational{Int32}}(1//1, 85563208//27235615) +See also: [`Interval`](@ref). +""" +struct BareInterval{T<:NumTypes} + lo :: T + hi :: T -julia> interval(1, π) -Interval{Float64}(1.0, 3.1415926535897936) + # need explicit signatures to avoid method ambiguities -julia> interval(BigFloat, 1, π) -Interval{BigFloat}(1.0, 3.141592653589793238462643383279502884197169399375105820974944592307816406286233) -``` -""" -function interval(::Type{T}, a, b) where {T<:NumTypes} - lo = inf(a) - hi = sup(b) - is_valid_interval(T, lo, hi) && return unsafe_interval(T, lo, hi) - @warn "invalid input, empty interval is returned" - return emptyinterval(T) -end + """ + _unsafe_bareinterval(::Type{<:NumTypes}, lo, hi) -interval(a, b) = interval(promote_numtype(numtype(a), numtype(b)), a, b) + Internal constructor which assumes that `is_valid_interval(lo, hi) == true`. + + !!! warning + This constructor is *not* compliant with the IEEE Standard 1788-2015. + Since misuse of this function can deeply corrupt code, its usage is + *strongly discouraged* in favour of [`bareinterval`](@ref). + """ + global _unsafe_bareinterval(::Type{T}, a::T, b::T) where {S<:Integer,T<:Rational{S}} = + new{T}(_normalisezero(a), _normalisezero(b)) + _unsafe_bareinterval(::Type{T}, a::T, b::T) where {S<:Union{Int8,UInt8},T<:Rational{S}} = + new{T}(_normalisezero(a), _normalisezero(b)) + _unsafe_bareinterval(::Type{T}, a::T, b::T) where {S<:Union{Int16,UInt16},T<:Rational{S}} = + new{T}(_normalisezero(a), _normalisezero(b)) -# `is_valid_interval(a, a)` may not be true -interval(::Type{T}, a) where {T<:NumTypes} = interval(T, a, a) -interval(a) = interval(promote_numtype(numtype(a), numtype(a)), a) + _unsafe_bareinterval(::Type{T}, a::T, b::T) where {T<:AbstractFloat} = + new{T}(_normalisezero(a), _normalisezero(b)) +end -# complex -interval(::Type{T}, a::Complex, b::Complex) where {T<:NumTypes} = complex(interval(T, real(a), real(b)), interval(T, imag(a), imag(b))) -interval(a::Complex, b::Complex) = complex(interval(real(a), real(b)), interval(imag(a), imag(b))) -interval(::Type{T}, a::Complex, b) where {T<:NumTypes} = complex(interval(T, real(a), b), interval(T, imag(a))) -interval(a::Complex, b) = complex(interval(real(a), b), interval(imag(a))) -interval(::Type{T}, a, b::Complex) where {T<:NumTypes} = complex(interval(T, a, real(b)), interval(T, imag(b))) -interval(a, b::Complex) = complex(interval(a, real(b)), interval(imag(b))) -interval(::Type{T}, a::Complex) where {T<:NumTypes} = complex(interval(T, real(a)), interval(T, imag(a))) -interval(a::Complex) = complex(interval(real(a)), interval(imag(a))) +_normalisezero(a) = ifelse(iszero(a), zero(a), a) + +_unsafe_bareinterval(::Type{T}, a::Rational, b::Rational) where {S<:Integer,T<:Rational{S}} = + _unsafe_bareinterval(T, T(a), T(b)) +_unsafe_bareinterval(::Type{T}, a::Rational, b::Rational) where {S<:Union{Int8,UInt8},T<:Rational{S}} = + _unsafe_bareinterval(T, T(a), T(b)) +_unsafe_bareinterval(::Type{T}, a::Rational, b::Rational) where {S<:Union{Int16,UInt16},T<:Rational{S}} = + _unsafe_bareinterval(T, T(a), T(b)) +_unsafe_bareinterval(::Type{T}, a::Rational, b) where {S<:Integer,T<:Rational{S}} = + _unsafe_bareinterval(T, T(a), rationalize(S, nextfloat(float(S)(b, RoundUp)))) +_unsafe_bareinterval(::Type{T}, a, b::Rational) where {S<:Integer,T<:Rational{S}} = + _unsafe_bareinterval(T, rationalize(S, nextfloat(float(S)(a, RoundDown))), T(b)) +function _unsafe_bareinterval(::Type{T}, a, b) where {S<:Integer,T<:Rational{S}} + R = float(S) + return _unsafe_bareinterval(T, rationalize(S, prevfloat(R(a, RoundDown))), rationalize(S, nextfloat(R(b, RoundUp)))) +end +# need the following since `float(Int8) == float(Int16) == Float64` +_unsafe_bareinterval(::Type{T}, a, b) where {S<:Union{Int8,UInt8},T<:Rational{S}} = + _unsafe_bareinterval(T, rationalize(S, prevfloat(Float16(a, RoundDown))), rationalize(S, nextfloat(Float16(b, RoundUp)))) +_unsafe_bareinterval(::Type{T}, a, b) where {S<:Union{Int16,UInt16},T<:Rational{S}} = + _unsafe_bareinterval(T, rationalize(S, prevfloat(Float32(a, RoundDown))), rationalize(S, nextfloat(Float32(b, RoundUp)))) -# some useful extra constructor -interval(a::Tuple) = interval(a...) +_unsafe_bareinterval(::Type{T}, a, b) where {T<:AbstractFloat} = _unsafe_bareinterval(T, T(a, RoundDown), T(b, RoundUp)) -# irrational # by-pass the absence of `BigFloat(..., ROUNDING_MODE)` (cf. base/irrationals.jl) # for some irrationals defined in MathConstants (cf. base/mathconstants.jl) for sym ∈ (:(:ℯ), :(:φ)) @eval begin - unsafe_interval(::Type{BigFloat}, a::Irrational{:ℯ}, b::Irrational{$sym}) = - unsafe_interval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) - unsafe_interval(::Type{BigFloat}, a::Irrational{:φ}, b::Irrational{$sym}) = - unsafe_interval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) - unsafe_interval(::Type{BigFloat}, a::Irrational{$sym}, b) = - unsafe_interval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(b, RoundUp)) - unsafe_interval(::Type{BigFloat}, a, b::Irrational{$sym}) = - unsafe_interval(BigFloat, BigFloat(a, RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + _unsafe_bareinterval(::Type{BigFloat}, a::Irrational{:ℯ}, b::Irrational{$sym}) = + _unsafe_bareinterval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + _unsafe_bareinterval(::Type{BigFloat}, a::Irrational{:φ}, b::Irrational{$sym}) = + _unsafe_bareinterval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + _unsafe_bareinterval(::Type{BigFloat}, a::Irrational{$sym}, b) = + _unsafe_bareinterval(BigFloat, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(b, RoundUp)) + _unsafe_bareinterval(::Type{BigFloat}, a, b::Irrational{$sym}) = + _unsafe_bareinterval(BigFloat, BigFloat(a, RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + + _unsafe_bareinterval(::Type{Rational{BigInt}}, a::Irrational{:ℯ}, b::Irrational{$sym}) = + _unsafe_bareinterval(Rational{BigInt}, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + _unsafe_bareinterval(::Type{Rational{BigInt}}, a::Irrational{:φ}, b::Irrational{$sym}) = + _unsafe_bareinterval(Rational{BigInt}, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) + _unsafe_bareinterval(::Type{Rational{BigInt}}, a::Irrational{$sym}, b) = + _unsafe_bareinterval(Rational{BigInt}, BigFloat(Float64(a, RoundDown), RoundDown), BigFloat(b, RoundUp)) + _unsafe_bareinterval(::Type{Rational{BigInt}}, a, b::Irrational{$sym}) = + _unsafe_bareinterval(Rational{BigInt}, BigFloat(a, RoundDown), BigFloat(Float64(b, RoundUp), RoundUp)) end end -# the following function is put here because generated functions must be defined -# after all the methods they use -@generated function interval(::Type{T}, a::AbstractIrrational) where {T<:NumTypes} - res = unsafe_interval(T, a(), a()) # precompute the interval - return :($res) # set body of the function to return the precomputed result -end + +BareInterval{T}(x::BareInterval) where {T<:NumTypes} = bareinterval(T, x) """ - ±(m, r) - m ± r + bareinterval([T<:Union{Rational,AbstractFloat}=default_numtype()], a, b) -Create the interval ``[m - r, m + r]`` according to the IEEE Standard 1788-2015. -Despite using the midpoint-radius notation, the returned interval is still an -`Interval` represented by its bounds. +Create the bare interval ``[a, b]`` according to the IEEE Standard 1788-2015. +The validity of the interval is checked by [`is_valid_interval`](@ref): if +`true` then a `BareInterval{T}` is constructed, otherwise a warning is printed +and the empty interval is returned. !!! warning Nothing is done to compensate for the fact that floating point literals are 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) and [`@I_str`](@ref). +See also: [`interval`](@ref), [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref). # Examples ```jldoctest -julia> setformat(:full); +julia> setdisplay(:full); -julia> 0 ± π -Interval{Float64}(-3.1415926535897936, 3.1415926535897936) +julia> bareinterval(1//1, π) +BareInterval{Rational{Int64}}(1//1, 85563208//27235615) -julia> 0//1 ± π -Interval{Rational{Int64}}(-85563208//27235615, 85563208//27235615) +julia> bareinterval(Rational{Int32}, 1//1, π) +BareInterval{Rational{Int32}}(1//1, 85563208//27235615) + +julia> bareinterval(1, π) +BareInterval{Float64}(1.0, 3.1415926535897936) + +julia> bareinterval(BigFloat, 1, π) +BareInterval{BigFloat}(1.0, 3.141592653589793238462643383279502884197169399375105820974944592307816406286233) ``` """ -function ±(m, r) - x = interval(m) - return interval(inf(x - r), sup(x + r)) +function bareinterval(::Type{T}, a, b) where {T<:NumTypes} + lo = inf(a) + hi = sup(b) + is_valid_interval(lo, hi) && return _unsafe_bareinterval(T, lo, hi) + return emptyinterval(BareInterval{T}) end -±(m::Complex, r) = complex(±(real(m), r), ±(imag(m), r)) -±(::Any, r::Complex) = throw(DomainError(r, "± does not accept complex radius. Try ±(m, real(r)).")) -±(::Complex, r::Complex) = throw(DomainError(r, "± does not accept complex radius. Try ±(m, real(r)).")) +bareinterval(a, b) = bareinterval(promote_numtype(numtype(a), numtype(b)), a, b) -# +bareinterval(::Type{T}, a) where {T<:NumTypes} = bareinterval(T, a, a) +bareinterval(a) = bareinterval(promote_numtype(numtype(a), numtype(a)), a) + +bareinterval(::Type{T}, a::BareInterval) where {T<:NumTypes} = + _unsafe_bareinterval(T, inf(a), sup(a)) # assumes valid interval + +# some useful extra constructor +bareinterval(::Type{T}, a::Tuple) where {T<:NumTypes} = bareinterval(T, a...) +bareinterval(a::Tuple) = bareinterval(T, a...) + +# note: generated functions must be defined after all the methods they use +@generated function bareinterval(::Type{T}, a::AbstractIrrational) where {T<:NumTypes} + res = _unsafe_bareinterval(T, a(), a()) # precompute the interval + return :($res) # set body of the function to return the precomputed result +end + +# promotion + +Base.promote_rule(::Type{BareInterval{T}}, ::Type{BareInterval{S}}) where {T<:NumTypes,S<:NumTypes} = + BareInterval{promote_numtype(T, S)} + +# conversion + +Base.convert(::Type{BareInterval{T}}, a::BareInterval) where {T<:NumTypes} = + bareinterval(T, a) """ atomic(T<:Union{Rational,AbstractFloat}, a) @@ -233,22 +227,22 @@ Create an interval according to the IEEE Standard 1788-2015. The returned type. If `a` is an `AbstractString`, then the interval is constructed by calling [`parse`](@ref). If `a` is an `AbstractFloat`, the interval is widen to two eps to be sure to contain the number that was typed in. In all other cases, this is -semantically equivalent to `interval(T, a)`. +semantically equivalent to `bareinterval(T, a)`. # Examples ```jldoctest -julia> setformat(:full); +julia> setdisplay(:full); julia> IntervalArithmetic.atomic(Float64, 0.1) -Interval{Float64}(0.09999999999999999, 0.10000000000000002) +BareInterval{Float64}(0.09999999999999999, 0.10000000000000002) julia> IntervalArithmetic.atomic(Float64, 0.3) -Interval{Float64}(0.29999999999999993, 0.30000000000000004) +BareInterval{Float64}(0.29999999999999993, 0.30000000000000004) ``` """ -atomic(::Type{T}, a) where {T<:NumTypes} = interval(T, a) +atomic(::Type{T}, a) where {T<:NumTypes} = bareinterval(T, a) -atomic(::Type{T}, a::AbstractString) where {T<:NumTypes} = parse(Interval{T}, a) +atomic(::Type{T}, a::AbstractString) where {T<:NumTypes} = parse(BareInterval{T}, a) function atomic(::Type{T}, a::AbstractFloat) where {T<:AbstractFloat} lo = T(a, RoundDown) @@ -259,31 +253,287 @@ function atomic(::Type{T}, a::AbstractFloat) where {T<:AbstractFloat} if a == hi hi = nextfloat(hi) end - return unsafe_interval(T, lo, hi) + return _unsafe_bareinterval(T, lo, hi) +end + + + +# decorations + +""" + Decoration + +Enumeration constant for the types of interval decorations described in +Section 11.2 of the IEEE Standard 1788-2015: +- `com -> 4`: non-empty, continuous and bounded (common) +- `dac -> 3`: non-empty and continuous (defined and continuous) +- `def -> 2`: non-empty (defined) +- `trv -> 1`: always true (trivial) +- `ill -> 0`: not an interval (ill-formed) +""" +@enum Decoration ill=0 trv=1 def=2 dac=3 com=4 +# note: `isless`, and hence `<`, `min` and `max`, are automatically defined + +function decoration(x::BareInterval) + isnai(x) && return ill + isempty_interval(x) && return trv + isunbounded(x) && return dac + return com end -# prevents multiple threads from calling setprecision() concurrently; it is used -# in `bigequiv` -const precision_lock = ReentrantLock() + + + + +# decorated intervals """ - bigequiv(x::Interval) - bigequiv(x::Union{Rational,AbstractFloat}) + Interval{T<:NumTypes} <: Real -Create a `BigFloat` equivalent with the same underlying precision as `x`. +Interval type for guaranteed computation with interval arithmetic according to +the IEEE Standard 1788-2015. This structure combines a [`BareInterval`](@ref) +together with a [`Decoration`](@ref). The decoration records the validity of the +operations that produced this interval. + +Fields: +- `bareinterval :: BareInterval{T}` +- `decoration :: Decoration` +- `isguaranteed :: Bool` + +Constructors compliant with the IEEE Standard 1788-2015: +- [`interval`](@ref) +- [`..`](@ref) +- [`±`](@ref) +- [`@I_str`](@ref) + +See also: [`±`](@ref), [`..`](@ref) and [`@I_str`](@ref). """ -function bigequiv(x::Interval{T}) where {T<:NumTypes} - lock(precision_lock) do - setprecision(precision(float(T))) do - return Interval{BigFloat}(x) - end - end +struct Interval{T<:NumTypes} <: Real + bareinterval :: BareInterval{T} + decoration :: Decoration + isguaranteed :: Bool + + """ + _unsafe_interval(bareinterval::BareInterval, ::Decoration, ::Bool) + + Internal constructor which assumes that `bareinterval` is an interval + compliant with the IEEE Standard 1788-2015. + + !!! warning + This constructor is *not* compliant with the IEEE Standard 1788-2015. + Since misuse of this function can deeply corrupt code, its usage is + *strongly discouraged* in favour of [`interval`](@ref). + """ + global _unsafe_interval(bareinterval::BareInterval{T}, decoration::Decoration, isguaranteed::Bool) where {T<:NumTypes} = + new{T}(bareinterval, decoration, isguaranteed) end -function bigequiv(x::T) where {T<:NumTypes} - lock(precision_lock) do - setprecision(precision(float(T))) do - return BigFloat(x) - end +bareinterval(x::Interval) = x.bareinterval +bareinterval(::Type{T}, x::Interval) where {T<:NumTypes} = bareinterval(T, bareinterval(x)) +decoration(x::Interval) = x.decoration + +""" + isguaranteed(::Interval) + isguaranteed(::BareInterval) + isguaranteed(::Complex{<:Interval}) + +Test whether the interval is not guaranteed to encompass all possible numerical +errors. This happens whenever an `Interval` is constructed using +`convert(::Type{<:Interval}, ::Number)`, for instance when operations mix +intervals and other `Number` types. + +Since conversion between `BareInterval` and `Number` is prohibited, this implies +that `isguaranteed(::BareInterval) == true`. + +In the case of a complex interval `x`, this is semantically equivalent to +`isguaranteed(x) == isguaranteed(real(x)) & isguaranteed(imag(x))`. +""" +isguaranteed(x::Interval) = x.isguaranteed +isguaranteed(::BareInterval) = true +isguaranteed(x::Complex{<:Interval}) = isguaranteed(real(x)) & isguaranteed(imag(x)) + +Interval{T}(a::Union{BareInterval,Interval}, d::Decoration) where {T<:NumTypes} = interval(T, bareinterval(T, a), d) +Interval{T}(a::Union{BareInterval,Interval}) where {T<:NumTypes} = interval(T, bareinterval(T, a)) +Interval(a::Union{BareInterval,Interval}, d::Decoration) = interval(bareinterval(a), d) +Interval(a::Union{BareInterval,Interval}) = interval(bareinterval(a)) + +# + +function interval(::Type{T}, a, b, d::Decoration; format::Symbol = :standard) where {T<:NumTypes} + format === :standard && return _interval_standard(T, a, b, d) + format === :midpoint && return _interval_midpoint(T, a, b, d) + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +interval(a, b, d::Decoration; format::Symbol = :standard) = interval(promote_numtype(numtype(a), numtype(b)), a, b, d; format = format) + +function interval(::Type{T}, a, b; format::Symbol = :standard) where {T<:NumTypes} + format === :standard && return _interval_standard(T, a, b) + format === :midpoint && return _interval_midpoint(T, a, b) + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +interval(a, b; format::Symbol = :standard) = interval(promote_numtype(numtype(a), numtype(b)), a, b; format = format) + +function interval(::Type{T}, a, d::Decoration; format::Symbol = :standard) where {T<:NumTypes} + ((format === :standard) | (format === :midpoint)) && return _interval_standard(T, a, a, d) + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +function interval(::Type{T}, x::Union{BareInterval,Interval}, d::Decoration; format::Symbol = :standard) where {T<:NumTypes} + ((format === :standard) | (format === :midpoint)) && return _unsafe_interval(bareinterval(T, x), min(decoration(x), d), isguaranteed(x)) # assumes valid interval + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +interval(a, d::Decoration; format::Symbol = :standard) = interval(promote_numtype(numtype(a), numtype(a)), a, d; format = format) + +function interval(::Type{T}, a; format::Symbol = :standard) where {T<:NumTypes} + ((format === :standard) | (format === :midpoint)) && return _interval_standard(T, a, a) + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +function interval(::Type{T}, x::Union{BareInterval,Interval}; format::Symbol = :standard) where {T<:NumTypes} + ((format === :standard) | (format === :midpoint)) && return _unsafe_interval(bareinterval(T, x), decoration(x), isguaranteed(x)) # assumes valid interval + return throw(ArgumentError("`format` must be `:standard` or `:midpoint`.")) +end +interval(a; format::Symbol = :standard) = interval(promote_numtype(numtype(a), numtype(a)), a; format = format) + +# some useful extra constructor +interval(::Type{T}, a::Tuple, d::Decoration; format::Symbol = :standard) where {T<:NumTypes} = interval(T, a..., d; format = format) +interval(a::Tuple, d::Decoration; format::Symbol = :standard) = interval(a..., d; format = format) +interval(::Type{T}, a::Tuple; format::Symbol = :standard) where {T<:NumTypes} = interval(T, a...; format = format) +interval(a::Tuple; format::Symbol = :standard) = interval(a...; format = format) + +# standard format + +""" + _interval_standard(T<:NumTypes, a, b, [d::Decoration]) + +Internal constructor for intervals described by their lower and upper bounds, +i.e. of the form ``[a, b]``. +""" +function _interval_standard(::Type{T}, a, b, d::Decoration) where {T<:NumTypes} + lo = inf(a) + hi = sup(b) + !is_valid_interval(lo, hi) && return nai(T) + x = _unsafe_bareinterval(T, lo, hi) + return _unsafe_interval(x, min(decoration(x), d), true) +end +function _interval_standard(::Type{T}, a, b) where {T<:NumTypes} + lo = inf(a) + hi = sup(b) + !is_valid_interval(lo, hi) && return nai(T) + x = _unsafe_bareinterval(T, lo, hi) + return _unsafe_interval(x, decoration(x), true) +end + +_interval_standard(::Type{T}, a::Complex, b::Complex, d::Decoration) where {T<:NumTypes} = + complex(_interval_standard(T, real(a), real(b), d), _interval_standard(T, imag(a), imag(b), d)) +_interval_standard(::Type{T}, a::Complex, b, d::Decoration) where {T<:NumTypes} = + complex(_interval_standard(T, real(a), b, d), _interval_standard(T, imag(a), d)) +_interval_standard(::Type{T}, a, b::Complex, d::Decoration) where {T<:NumTypes} = + complex(_interval_standard(T, a, real(b), d), _interval_standard(T, imag(b), d)) + +_interval_standard(::Type{T}, a::Complex, b::Complex) where {T<:NumTypes} = + complex(_interval_standard(T, real(a), real(b)), _interval_standard(T, imag(a), imag(b))) +_interval_standard(::Type{T}, a::Complex, b) where {T<:NumTypes} = + complex(_interval_standard(T, real(a), b), _interval_standard(T, imag(a))) +_interval_standard(::Type{T}, a, b::Complex) where {T<:NumTypes} = + complex(_interval_standard(T, a, real(b)), _interval_standard(T, imag(b))) + +# midpoint constructors + +""" + _interval_midpoint(T<:NumTypes, m, r, [d::Decoration]) + +Internal constructor for intervals described by their midpoint and radius, +i.e. of the form ``m \\pm r`. +""" +function _interval_midpoint(::Type{T}, m, r, d::Decoration) where {T<:NumTypes} + x = _interval_standard(T, m, m, d) + return _interval_standard(T, inf(x - r), sup(x + r), d) +end +function _interval_midpoint(::Type{T}, m, r) where {T<:NumTypes} + x = _interval_standard(T, m, m) + return _interval_standard(T, inf(x - r), sup(x + r)) +end + +_interval_midpoint(::Type{T}, m::Complex, r, d::Decoration) where {T<:NumTypes} = + complex(_interval_midpoint(T, real(m), r, d), _interval_midpoint(T, imag(m), r, d)) +_interval_midpoint(::Type{T}, m::Complex, r) where {T<:NumTypes} = + complex(_interval_midpoint(T, real(m), r), _interval_midpoint(T, imag(m), r)) + +function _interval_midpoint(::Type{T}, m, r::Complex{<:Interval}, d::Decoration) where {T<:NumTypes} + isthinzero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r), d) +end +function _interval_midpoint(::Type{T}, m, r::Complex{<:Interval}) where {T<:NumTypes} + isthinzero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r)) +end + +function _interval_midpoint(::Type{T}, m, r::Complex, d::Decoration) where {T<:NumTypes} + iszero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r), d) +end +function _interval_midpoint(::Type{T}, m, r::Complex) where {T<:NumTypes} + iszero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r)) +end + +function _interval_midpoint(::Type{T}, m::Complex, r::Complex{<:Interval}, d::Decoration) where {T<:NumTypes} + isthinzero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r), d) +end +function _interval_midpoint(::Type{T}, m::Complex, r::Complex{<:Interval}) where {T<:NumTypes} + isthinzero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r)) +end + +function _interval_midpoint(::Type{T}, m::Complex, r::Complex, d::Decoration) where {T<:NumTypes} + iszero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r), d) +end +function _interval_midpoint(::Type{T}, m::Complex, r::Complex) where {T<:NumTypes} + iszero(imag(r)) || return throw(DomainError(r, "imaginary part must be zero.")) + return _interval_midpoint(T, m, real(r)) +end + +# promotion + +Base.promote_rule(::Type{Interval{T}}, ::Type{Interval{S}}) where {T<:NumTypes,S<:NumTypes} = + Interval{promote_numtype(T, S)} + +Base.promote_rule(::Type{Interval{T}}, ::Type{S}) where {T<:NumTypes,S<:Real} = + Interval{promote_numtype(T, S)} + +Base.promote_rule(::Type{T}, ::Type{Interval{S}}) where {T<:Real,S<:NumTypes} = + Interval{promote_numtype(T, S)} + +# need explicit signatures to avoid method ambiguities +for S ∈ (:Bool, :BigFloat) + @eval begin + Base.promote_rule(::Type{Interval{T}}, ::Type{$S}) where {T<:NumTypes} = + Interval{promote_numtype(T, $S)} + Base.promote_rule(::Type{$S}, ::Type{Interval{T}}) where {T<:NumTypes} = + Interval{promote_numtype($S, T)} end end +Base.promote_rule(::Type{Interval{T}}, ::Type{S}) where {T<:NumTypes,S<:AbstractIrrational} = + Interval{promote_numtype(T, S)} +Base.promote_rule(::Type{T}, ::Type{Interval{S}}) where {T<:AbstractIrrational,S<:NumTypes} = + Interval{promote_numtype(T, S)} + +# conversion + +Base.convert(::Type{Interval{T}}, x::Interval) where {T<:NumTypes} = interval(T, x) + +function Base.convert(::Type{Interval{T}}, x::Complex{<:Interval}) where {T<:NumTypes} + isthinzero(imag(x)) || return throw(DomainError(x, "imaginary part must be zero.")) + return convert(Interval{T}, real(x)) +end + +function Base.convert(::Type{Interval{T}}, x::Real) where {T<:NumTypes} + y = interval(T, x) + return _unsafe_interval(bareinterval(y), decoration(y), false) +end + +function Base.convert(::Type{Interval{T}}, x::Complex) where {T<:NumTypes} + iszero(imag(x)) || return throw(DomainError(x, "imaginary part must be zero.")) + return convert(Interval{T}, real(x)) +end diff --git a/src/intervals/flavors.jl b/src/intervals/flavors.jl index 04970121c..525267236 100644 --- a/src/intervals/flavors.jl +++ b/src/intervals/flavors.jl @@ -46,29 +46,26 @@ zero_times_infinity(::Flavor{:set_based}, ::Type{T}) where {T<:NumTypes} = zero( zero_times_infinity(::Type{T}) where {T<:NumTypes} = zero_times_infinity(default_flavor(), T) """ - div_by_thin_zero(::Flavor, x::Interval) + div_by_thin_zero(::Flavor, x::BareInterval) Divide `x` by the interval containing only `0`. """ -div_by_thin_zero(::Flavor{:set_based}, ::Interval{T}) where {T<:NumTypes} = - emptyinterval(T) +div_by_thin_zero(::Flavor{:set_based}, ::BareInterval{T}) where {T<:NumTypes} = + emptyinterval(BareInterval{T}) -div_by_thin_zero(x::Interval) = div_by_thin_zero(default_flavor(), x) +div_by_thin_zero(x::BareInterval) = div_by_thin_zero(default_flavor(), x) -contains_infinity(::Flavor{:set_based}, ::Interval) = false +contains_infinity(::Flavor{:set_based}, ::BareInterval) = false -contains_infinity(x::Interval) = contains_infinity(default_flavor(), x) +contains_infinity(x::BareInterval) = contains_infinity(default_flavor(), x) """ is_valid_interval(a, b) Check if `(a, b)` constitute a valid interval. """ -is_valid_interval(::Flavor{:set_based}, ::Type{T}, a, b) where {T<:NumTypes} = - !(isnan(a) | isnan(b) | (a > b) | (a == typemax(T)) | (b == typemin(T))) +is_valid_interval(::Flavor{:set_based}, a, b) = b - a ≥ 0 -is_valid_interval(::Type{T}, a, b) where {T<:NumTypes} = is_valid_interval(default_flavor(), T, a, b) - -is_valid_interval(a, b) = is_valid_interval(default_numtype(), a, b) +is_valid_interval(a, b) = is_valid_interval(default_flavor(), a, b) is_valid_interval(a) = is_valid_interval(a, a) diff --git a/src/intervals/interval_operations/bisect.jl b/src/intervals/interval_operations/bisect.jl new file mode 100644 index 000000000..ddac0aefd --- /dev/null +++ b/src/intervals/interval_operations/bisect.jl @@ -0,0 +1,44 @@ +""" + bisect(x::BareInterval, α::Real=0.49609375) + bisect(x::Interval, α::Real=0.49609375) + +Split the interval `x` at position `α`, where `α = 0.5` corresponds to the +midpoint. +""" +function bisect(x::BareInterval{T}, α::Real=0.49609375) where {T<:NumTypes} + 0 ≤ α ≤ 1 || return throw(DomainError(α, "bisect only accepts a relative position α between 0 and 1.")) + m = scaled_mid(x, α) + return (_unsafe_bareinterval(T, inf(x), m), _unsafe_bareinterval(T, m, sup(x))) +end + +function bisect(x::Interval, α::Real=0.49609375) + bx = bareinterval(x) + r1, r2 = bisect(bx, α) + d1, d2 = min(decoration(x), decoration(r1), trv), min(decoration(x), decoration(r2), trv) + t = isguaranteed(x) + return (_unsafe_interval(r1, d1, t), _unsafe_interval(r2, d2, t)) +end + +""" + mince(x::BareInterval, n::Integer) + mince(x::Interval, n::Integer) + +Split `x` in `n` intervals of the same diameter. +""" +function mince(x::BareInterval{T}, n::Integer) where {T<:NumTypes} + nodes = LinRange(inf(x), sup(x), n+1) + return [_unsafe_bareinterval(T, nodes[i], nodes[i+1]) for i ∈ 1:n] +end + +function mince(x::Interval{T}, n::Integer) where {T<:NumTypes} + v = Vector{Interval{T}}(undef, n) + nodes = LinRange(inf(x), sup(x), n+1) + d = decoration(x) + t = isguaranteed(x) + @inbounds for i ∈ 1:n + rᵢ = _unsafe_bareinterval(T, nodes[i], nodes[i+1]) + dᵢ = min(d, decoration(rᵢ), trv) + v[i] = _unsafe_interval(rᵢ, dᵢ, t) + end + return v +end diff --git a/src/intervals/interval_operations/boolean.jl b/src/intervals/interval_operations/boolean.jl index 4fcf06cb8..72a92ef54 100644 --- a/src/intervals/interval_operations/boolean.jl +++ b/src/intervals/interval_operations/boolean.jl @@ -4,200 +4,331 @@ # Some other (non required) related functions are also present, as well as some of # the "Recommended operations" (Section 10.6.3) -# Equivalent to `<` but with Inf < Inf being true. -function _strictlessprime(a::Real, b::Real) - (isinf(a) || isinf(b)) && a == b && return true - return a < b +# equivalent to `<` but with `(Inf < Inf) == true` +function _strictlessprime(x::Real, y::Real) + (isinf(x) || isinf(y)) && x == y && return true + return x < y end """ - isequal_interval(a::Interval, b::Interval) + isequal_interval(x::BareInterval, y::BareInterval) + isequal_interval(x::Interval, y::Interval) -Checks if the intervals `a` and `b` are identical. +Test whether `x` and `y` are identical. -Typed as \\starequal. - -Implement the `equal` function of the IEEE Standard 1788-2015 (Table 9.3). - -The more common `==` operator is reserved for flavor dependent pointwise -equality. - -In most case this is equivalent to the built-in `===`. +Implement the `equal` function of the IEEE Standard 1788-2015 (Table 9.3). """ -function isequal_interval(a::Interval, b::Interval) - isempty_interval(a) && isempty_interval(b) && return true - return inf(a) == inf(b) && sup(a) == sup(b) +isequal_interval(x::BareInterval, y::BareInterval) = (inf(x) == inf(y)) & (sup(x) == sup(y)) + +function isequal_interval(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return isequal_interval(bareinterval(x), bareinterval(y)) end """ - issubset_interval(a, b) - -Checks if all the points of the interval `a` are within the interval `b`. + issubset_interval(x::BareInterval, y::BareInterval) + issubset_interval(x::Interval, y::Interval) -Typed with \\subseteq. +Test whether `x` is contained in `y`. Implement the `subset` function of the IEEE Standard 1788-2015 (Table 9.3). """ -function issubset_interval(a::Interval, b::Interval) - isempty_interval(a) && return true - return inf(b) ≤ inf(a) && sup(a) ≤ sup(b) +issubset_interval(x::BareInterval, y::BareInterval) = + (inf(y) ≤ inf(x)) & (sup(x) ≤ sup(y)) + +function issubset_interval(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return issubset_interval(bareinterval(x), bareinterval(y)) end """ - isstrictsubset_interval(a, b) + isstrictsubset_interval(x::BareInterval, y::BareInterval) + isstrictsubset_interval(x::Interval, y::Interval) + -Checks if all the points of the interval `a` are within the interior of -interval `b`. +Test whether `x` is in the interior of `y`. Implement the `interior` function of the IEEE Standard 1788-2015 (Table 9.3). """ -function isstrictsubset_interval(a::Interval, b::Interval) - isempty_interval(a) && return true - return _strictlessprime(inf(b), inf(a)) && _strictlessprime(sup(a), sup(b)) +isstrictsubset_interval(x::BareInterval, y::BareInterval) = + _strictlessprime(inf(y), inf(x)) & _strictlessprime(sup(x), sup(y)) + +function isstrictsubset_interval(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return isstrictsubset_interval(bareinterval(x), bareinterval(y)) end """ - isweakless(a, b) - -Checks if the interval `a` is weakly less than interval `b`. + isweakless(x::BareInterval, y::BareInterval) + isweakless(x::Interval, y::Interval) -Note that this is not equivalent as saying every element of `a` is less than -any element of `b`. +Test whether `inf(x) ≤ inf(y)` and `sup(x) ≤ sup(y)`, where `<` is replaced by +`≤` for infinite values. Implement the `less` function of the IEEE Standard 1788-2015 (Table 10.3). """ -function isweakless(a::Interval, b::Interval) - isempty_interval(a) && isempty_interval(b) && return true - (isempty_interval(a) || isempty_interval(b)) && return false - return (inf(a) ≤ inf(b)) && (sup(a) ≤ sup(b)) +isweakless(x::BareInterval, y::BareInterval) = + (inf(x) ≤ inf(y)) & (sup(x) ≤ sup(y)) + +function isweakless(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return isweakless(bareinterval(x), bareinterval(y)) end """ - isstrictless(a, b) - -Checks if the interval `a` is strictly less than interval `b`, which is true -if `inf(a) < inf(b)` and `sup(a) < sup(b)`. + isstrictless(x::BareInterval, y::BareInterval) + isstrictless(x::Interval, y::Interval) -For variants in the definition of "strictly less than" for intervals see -`strictprecedes` and `<`. +Test whether `inf(x) < inf(y)` and `sup(x) < sup(y)`, where `<` is replaced by +`≤` for infinite values. Implement the `strictLess` function of the IEEE Standard 1788-2015 (Table 10.3). """ -function isstrictless(a::Interval, b::Interval) - isempty_interval(a) && isempty_interval(b) && return true - (isempty_interval(a) || isempty_interval(b)) && return false - return _strictlessprime(inf(a), inf(b)) && _strictlessprime(sup(a), sup(b)) +isstrictless(x::BareInterval, y::BareInterval) = + _strictlessprime(inf(x), inf(y)) & _strictlessprime(sup(x), sup(y)) + +function isstrictless(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return isstrictless(bareinterval(x), bareinterval(y)) end """ - precedes(a, b) + precedes(x::BareInterval, y::BareInterval) + precedes(x::Interval, y::Interval) -Checks if the interval `a` is to the left of interval `b`. +Test whether any element of `x` is lesser or equal to every elements of `y`. Implement the `precedes` function of the IEEE Standard 1788-2015 (Table 10.3). """ -function precedes(a::Interval, b::Interval) - (isempty_interval(a) || isempty_interval(b)) && return true - return sup(a) ≤ inf(b) +precedes(x::BareInterval, y::BareInterval) = sup(x) ≤ inf(y) + +function precedes(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return precedes(bareinterval(x), bareinterval(y)) end """ - strictprecedes(a, b) + strictprecedes(x::BareInterval, y::BareInterval) + strictprecedes(x::Interval, y::Interval) -Checks if the interval `a` is strictly to the left of interval `b`. +Test whether any element of `x` is strictly lesser than every elements of `y`. Implement the `strictPrecedes` function of the IEEE Standard 1788-2015 (Table 10.3). """ -function strictprecedes(a::Interval, b::Interval) - (isempty_interval(a) || isempty_interval(b)) && return true - return sup(a) < inf(b) +function strictprecedes(x::BareInterval, y::BareInterval) + (isempty_interval(x) | isempty_interval(y)) && return true + return sup(x) < inf(y) +end + +function strictprecedes(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return strictprecedes(bareinterval(x), bareinterval(y)) end """ - isdisjoint_interval(a,b) + isdisjoint_interval(x::BareInterval, y::BareInterval) + isdisjoint_interval(x::Interval, y::Interval) -Checks if all the points of the interval `a` are within the interior of -interval `b`. +Test whether `x` and `y` have no common elements. Implement the `disjoint` function of the IEEE Standard 1788-2015 (Table 9.3). """ -function isdisjoint_interval(a::Interval, b::Interval) - (isempty_interval(a) || isempty_interval(b)) && return true - return _strictlessprime(sup(b), inf(a)) || _strictlessprime(sup(a), inf(b)) +function isdisjoint_interval(a::BareInterval, b::BareInterval) + (isempty_interval(a) | isempty_interval(b)) && return true + return _strictlessprime(sup(b), inf(a)) | _strictlessprime(sup(a), inf(b)) end -function isdisjoint_interval(a::Complex{F}, b::Complex{F}) where {F<:Interval} - return isdisjoint_interval(real(a), real(b)) || isdisjoint_interval(imag(a), imag(b)) +function isdisjoint_interval(x::Interval, y::Interval) + (isnai(x) | isnai(y)) && return false + return isdisjoint_interval(bareinterval(x), bareinterval(y)) end """ - in_interval(x, a) + in_interval(x::Real, y::BareInterval) + in_interval(x::Real, y::Interval) -Checks if the number `x` is a member of the interval `a`, treated as a set. +Test whether `x` is an element of `y`. -Implement the `isMember` function of the IEEE Standard 1788-2015 (section 10.6.3). +Implement the `isMember` function of the IEEE Standard 1788-2015 (Section 10.6.3). """ -function in_interval(x::Real, a::Interval) - isinf(x) && return contains_infinity(a) - return inf(a) ≤ x ≤ sup(a) +function in_interval(x::Real, y::BareInterval) + isinf(x) && return contains_infinity(y) + return inf(y) ≤ x ≤ sup(y) +end + +function in_interval(x::Real, y::Interval) + isnai(y) && return false + return in_interval(x, bareinterval(y)) end +in_interval(::BareInterval, ::BareInterval) = + throw(ArgumentError("`in_interval` is purposely not supported for two interval arguments. See instead `issubset_interval`.")) + in_interval(::Interval, ::Interval) = throw(ArgumentError("`in_interval` is purposely not supported for two interval arguments. See instead `issubset_interval`.")) -in_interval(x::Real, a::Complex{<:Interval}) = in_interval(x, real(a)) && in_interval(0, imag(a)) -in_interval(x::Complex, a::Complex{<:Interval}) = in_interval(real(x), real(a)) && in_interval(imag(x), imag(a)) -contains_zero(x::Interval{T}) where {T<:NumTypes} = in_interval(zero(T), x) +""" + isempty_interval(x::BareInterval) + isempty_interval(x::Interval) -isempty_interval(x::Interval{T}) where {T<:NumTypes} = (inf(x) == typemax(T)) && (sup(x) == typemin(T)) -isentire_interval(x::Interval{T}) where {T<:NumTypes} = (inf(x) == typemin(T)) && (sup(x) == typemax(T)) -isbounded(x::Interval) = (isfinite(inf(x)) && isfinite(sup(x))) || isempty_interval(x) -isunbounded(x::Interval) = !isbounded(x) +Test whether `x` contains no elements. +Implement the `isEmpty` function of the IEEE Standard 1788-2015 (Section 10.6.3). """ - isthin(x) +isempty_interval(x::BareInterval{T}) where {T<:NumTypes} = + (inf(x) == typemax(T)) & (sup(x) == typemin(T)) + +function isempty_interval(x::Interval) + isnai(x) && return false + return isempty_interval(bareinterval(x)) +end -Checks if `x` is the set consisting of a single exactly -representable float. Any float which is not exactly representable -does *not* yield a thin interval. Corresponds to `isSingleton` of -the standard. """ -isthin(x::Interval) = inf(x) == sup(x) + isentire_interval(x::BareInterval) + isentire_interval(x::Interval) +Test whether `x` is the entire real line. + +Implement the `isEntire` function of the IEEE Standard 1788-2015 (Section 10.6.3). """ - iscommon(x) +isentire_interval(x::BareInterval{T}) where {T<:NumTypes} = + (inf(x) == typemin(T)) & (sup(x) == typemax(T)) + +function isentire_interval(x::Interval) + isnai(x) && return false + return isentire_interval(bareinterval(x)) +end -Checks if `x` is a **common interval**, i.e. a non-empty, -bounded, real interval. """ -iscommon(x::Interval) = !(isentire_interval(x) || isempty_interval(x) || isunbounded(x)) + isbounded(x::BareInterval) + isbounded(x::Interval) +Test whether `x` is empty or has finite bounds. """ +isbounded(x::BareInterval) = (isfinite(inf(x)) & isfinite(sup(x))) | isempty_interval(x) + +function isbounded(x::Interval) + isnai(x) && return false + return isbounded(bareinterval(x)) +end + +""" + isbounded(x::BareInterval) + isbounded(x::Interval) + +Test whether `x` is not empty and has infinite bounds. +""" +isunbounded(x::BareInterval) = !isbounded(x) + +function isunbounded(x::Interval) + isnai(x) && return false + return isunbounded(bareinterval(x)) +end + +""" + isnai(x::BareInterval) + isnai(x::Interval) + +Test whether `x` is an NaI. +""" +isnai(::BareInterval) = false + +isnai(x::Interval) = decoration(x) == ill + +""" + iscommon(x::BareInterval) + iscommon(x::Interval) + +Test whether `x` is non-empty and bounded. +""" +iscommon(x::BareInterval) = !(isentire_interval(x) | isempty_interval(x) | isunbounded(x)) + +function iscommon(x::Interval) + isnai(x) && return false + return iscommon(bareinterval(x)) +end + +""" + isatomic(x::BareInterval) isatomic(x::Interval) -Check whether an interval `x` is *atomic*, i.e. is unable to be split. -This occurs when the interval is empty, or when the upper bound equals the lower -bound or the bounds are consecutive floating point numbers. +Test whether `x` is unable to be split. This occurs when the interval is empty, +or when the upper bound equals the lower bound or the bounds are consecutive +floating-point numbers. """ -isatomic(x::Interval) = isempty_interval(x) || (inf(x) == sup(x)) || (sup(x) == nextfloat(inf(x))) +isatomic(x::BareInterval) = isempty_interval(x) | (inf(x) == sup(x)) | (sup(x) == nextfloat(inf(x))) + +function isatomic(x::Interval) + isnai(x) && return false + return isatomic(bareinterval(x)) +end """ - isthinzero(x) + isthin(x::BareInterval) + isthin(x::Interval) + +Test whether `x` contains only a real. -Return whether the interval only contains zero. +Implement the `isSingleton` function of the IEEE Standard 1788-2015 (Table 9.3). """ -isthinzero(x::Interval) = iszero(inf(x)) && iszero(sup(x)) +isthin(x::BareInterval) = inf(x) == sup(x) + +function isthin(x::Interval) + isnai(x) && return false + return isthin(bareinterval(x)) +end """ - isthin(a::Interval, x::Number) + isthin(x::BareInterval, y::Number) + isthin(x::Interval, y::Number) -Check if the interval `a` contains exactly (and only) the number `x`. +Test whether `x` contains only `y`. """ -isthin(a::Interval, x::Real) = inf(a) == sup(a) == x +isthin(x::BareInterval, y::Number) = inf(x) == sup(x) == y + +function isthin(x::Interval, y::Number) + isnai(x) && return false + return isthin(bareinterval(x), y) +end + +""" + isthinzero(x::BareInterval) + isthinzero(x::Interval) + +Test whether `x` contains only zero. +""" +isthinzero(x::BareInterval) = iszero(inf(x)) & iszero(sup(x)) + +function isthinzero(x::Interval) + isnai(x) && return false + return isthinzero(bareinterval(x)) +end """ - isthininteger(x) + isthininteger(x::BareInterval) + isthininteger(x::Interval) -Return whether the inverval only contains a single integer. +Test whether `x` contains only an integer. """ -isthininteger(x::Interval) = (inf(x) == sup(x)) && isinteger(inf(x)) +isthininteger(x::BareInterval) = (inf(x) == sup(x)) & isinteger(inf(x)) + +function isthininteger(x::Interval) + isnai(x) && return false + return isthininteger(bareinterval(x)) +end + + + +# extension + +isequal_interval(x, y, z, w...) = isequal_interval(x, y) & isequal_interval(y, z, w...) +isequal_interval(x::Complex, y::Complex) = isequal_interval(real(x), real(y)) & isequal_interval(imag(x), imag(y)) +isequal_interval(x::Complex, y::Real) = isequal_interval(real(x), y) & isthinzero(imag(x)) +isequal_interval(x::Real, y::Complex) = isequal_interval(x, real(y)) & isthinzero(imag(y)) + +isdisjoint_interval(x::Complex, y::Complex) = + isdisjoint_interval(real(x), real(y)) | isdisjoint_interval(imag(x), imag(y)) + +in_interval(x::Complex, y::Complex) = in_interval(real(x), real(y)) & in_interval(imag(x), imag(y)) +in_interval(x::Complex, y::Real) = in_interval(real(x), y) & in_interval(imag(x), 0) +in_interval(x::Real, y::Complex) = in_interval(x, real(y)) & in_interval(0, imag(y)) diff --git a/src/intervals/interval_operations/cancellative.jl b/src/intervals/interval_operations/cancellative.jl index 2980f83b9..4119808b8 100644 --- a/src/intervals/interval_operations/cancellative.jl +++ b/src/intervals/interval_operations/cancellative.jl @@ -2,6 +2,10 @@ # "Cancellative addition and subtraction" in Section 9.2 of the # IEEE Standard 1788-2015 and required for set-based flavor in Section 10.5.6 + + +# bare intervals + """ cancelminus(a, b) @@ -9,30 +13,30 @@ Return the unique interval `c` such that `b + c = a`. Implement the `cancelMinus` function of the IEEE Standard 1788-2015 (Section 9.2). """ -function cancelminus(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} - (isempty_interval(a) && (isempty_interval(b) || !isunbounded(b))) && return emptyinterval(T) +function cancelminus(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} + (isempty_interval(a) && (isempty_interval(b) || !isunbounded(b))) && return emptyinterval(BareInterval{T}) - (isunbounded(a) || isunbounded(b) || isempty_interval(b)) && return entireinterval(T) + (isunbounded(a) || isunbounded(b) || isempty_interval(b)) && return entireinterval(BareInterval{T}) - diam(a) < diam(b) && return entireinterval(T) + diam(a) < diam(b) && return entireinterval(BareInterval{T}) c_lo, c_hi = bounds(@round(T, inf(a) - inf(b), sup(a) - sup(b))) - c_lo > c_hi && return entireinterval(T) + c_lo > c_hi && return entireinterval(BareInterval{T}) # Corner case 2 (page 62), involving unbounded c - c_lo == typemax(T) && return unsafe_interval(T, prevfloat(c_lo), c_hi) - c_hi == typemin(T) && return unsafe_interval(T, c_lo, nextfloat(c_hi)) + c_lo == typemax(T) && return _unsafe_bareinterval(T, prevfloat(c_lo), c_hi) + c_hi == typemin(T) && return _unsafe_bareinterval(T, c_lo, nextfloat(c_hi)) - c = unsafe_interval(T, c_lo, c_hi) + c = _unsafe_bareinterval(T, c_lo, c_hi) isunbounded(c) && return c # Corner case 1 (page 62) involving finite precision for diam(a) and diam(b) a_lo, a_hi = bounds(@round(T, inf(b) + c_lo, sup(b) + c_hi)) - (diam(a) == diam(b)) && (nextfloat(sup(a)) < a_hi || prevfloat(inf(a)) > a_lo) && return entireinterval(T) + (diam(a) == diam(b)) && (nextfloat(sup(a)) < a_hi || prevfloat(inf(a)) > a_lo) && return entireinterval(BareInterval{T}) return c end -cancelminus(a::Interval, b::Interval) = cancelminus(promote(a, b)...) +cancelminus(a::BareInterval, b::BareInterval) = cancelminus(promote(a, b)...) """ cancelplus(a, b) @@ -43,4 +47,25 @@ Equivalent to `cancelminus(a, -b)`. Implement the `cancelPlus` function of the IEEE Standard 1788-2015 (Section 9.2). """ -cancelplus(a::Interval, b::Interval) = cancelminus(a, -b) +cancelplus(a::BareInterval, b::BareInterval) = cancelminus(a, -b) + + + +# decorated intervals + +for f ∈ (:cancelplus, :cancelminus) + @eval begin + """ + $($f)(x, y) + + Decorated interval extension; the result is decorated by at most `trv`, + following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). + """ + function $f(x::Interval, y::Interval) + r = $f(bareinterval(x), bareinterval(y)) + d = min(decoration(x), decoration(y), decoration(r), trv) + t = isguaranteed(x) & isguaranteed(y) + return _unsafe_interval(r, d, t) + end + end +end diff --git a/src/intervals/interval_operations/constants.jl b/src/intervals/interval_operations/constants.jl index 61b126ba6..2e4f35653 100644 --- a/src/intervals/interval_operations/constants.jl +++ b/src/intervals/interval_operations/constants.jl @@ -4,40 +4,43 @@ """ emptyinterval -`emptyinterval`s are represented as the interval [∞, -∞]; note -that this interval is an exception to the fact that the lower bound is -larger than the upper one. - -Note that if the type of the returned interval can not be inferred from the -argument given, the default interval bound type is used. +Create an empty interval. This interval is an exception to the fact that the +lower bound is larger than the upper one. Implement the `empty` function of the IEEE Standard 1788-2015 (Section 10.5.2). """ -emptyinterval(::Type{Interval{T}}) where {T<:NumTypes} = unsafe_interval(T, typemax(T), typemin(T)) -emptyinterval(::Type{T}) where {T<:NumTypes} = emptyinterval(Interval{T}) -emptyinterval(::Type{<:Real}) = emptyinterval(default_numtype()) -emptyinterval() = emptyinterval(default_numtype()) +emptyinterval(::Type{BareInterval{T}}) where {T<:AbstractFloat} = _unsafe_bareinterval(T, convert(T, NaN), convert(T, NaN)) +emptyinterval(::Type{BareInterval{T}}) where {T<:Rational} = _unsafe_bareinterval(T, typemax(T), typemin(T)) +# note: `using Base.unsafe_rational(Int, 0, 0)` as an equivalent to `NaN` for `Rational` +# does not work well since most codes for `Rational` assume that the denominator cannot be zero +# e.g. `iszero(Base.unsafe_rational(Int, 0, 0)) == true` + +emptyinterval(::Type{Interval{T}}) where {T<:NumTypes} = _unsafe_interval(emptyinterval(BareInterval{T}), trv, true) +emptyinterval(::Type{T}=default_numtype()) where {T<:NumTypes} = emptyinterval(Interval{T}) emptyinterval(::Type{Complex{T}}) where {T<:Real} = complex(emptyinterval(T), emptyinterval(T)) emptyinterval(::T) where {T} = emptyinterval(T) - """ entireinterval -`RR` represent the entire real line [-Inf, Inf]. - -Depending on the flavor, `-Inf` and `Inf` may or may not be considerd inside this -interval. - -Note that if the type of the returned interval can not be inferred from the -argument given, the default interval flavor will be used. See the documentation -of `Interval` for more information about the default interval falvor. +Create an interval representing the entire real line. Depending on the flavor, +`-Inf` and `Inf` may or may not be considerd inside this interval. Implement the `entire` function of the IEEE Standard 1788-2015 (Section 10.5.2). """ -entireinterval(::Type{Interval{T}}) where {T<:NumTypes} = unsafe_interval(T, typemin(T), typemax(T)) -entireinterval(::Type{T}) where {T<:NumTypes} = entireinterval(Interval{T}) -entireinterval(::Type{<:Real}) = entireinterval(default_numtype()) -entireinterval() = entireinterval(default_numtype()) +entireinterval(::Type{BareInterval{T}}) where {T<:NumTypes} = _unsafe_bareinterval(T, typemin(T), typemax(T)) + +entireinterval(::Type{Interval{T}}) where {T<:NumTypes} = _unsafe_interval(entireinterval(BareInterval{T}), dac, true) +entireinterval(::Type{T}=default_numtype()) where {T<:NumTypes} = entireinterval(Interval{T}) entireinterval(::Type{Complex{T}}) where {T<:Real} = complex(entireinterval(T), entireinterval(T)) entireinterval(::T) where {T} = entireinterval(T) + +""" + nai + +Create an NaI. +""" +nai(::Type{Interval{T}}) where {T<:NumTypes} = _unsafe_interval(emptyinterval(BareInterval{T}), ill, true) +nai(::Type{T}=default_numtype()) where {T<:NumTypes} = nai(Interval{T}) +nai(::Type{Complex{T}}) where {T<:Real} = complex(nai(T), nai(T)) +nai(::T) where {T} = nai(T) diff --git a/src/intervals/interval_operations/extended_div.jl b/src/intervals/interval_operations/extended_div.jl index 1a33cad42..53e2b5cc7 100644 --- a/src/intervals/interval_operations/extended_div.jl +++ b/src/intervals/interval_operations/extended_div.jl @@ -1,30 +1,49 @@ # This file contains the two-output division requested for set-based flavor in # Section 10.5.5 of the IEEE Standard 1788-2015 + + +# bare intervals + """ - extended_div(a::Interval, b::Interval) + extended_div(a::BareInterval, b::BareInterval) Two-output division. Implement the `mulRevToPair` function of the IEEE Standard 1788-2015 (Section 10.5.5). """ -function extended_div(a::Interval{T}, b::Interval{T}) where {T<:NumTypes} +function extended_div(a::BareInterval{T}, b::BareInterval{T}) where {T<:NumTypes} alo, ahi = bounds(a) blo, bhi = bounds(b) z = zero(T) if 0 < bhi && 0 > blo && !in_interval(0, a) if ahi < 0 - return (a / unsafe_interval(T, z, bhi), a / unsafe_interval(T, blo, z)) - # return (unsafe_interval(T, T(-Inf), ahi / bhi), unsafe_interval(T, ahi / blo, T(Inf))) + return (a / _unsafe_bareinterval(T, z, bhi), a / _unsafe_bareinterval(T, blo, z)) + # return (_unsafe_bareinterval(T, T(-Inf), ahi / bhi), _unsafe_bareinterval(T, ahi / blo, T(Inf))) elseif alo > 0 - return (a / unsafe_interval(T, blo, z), a / unsafe_interval(T, z, bhi)) - # return (unsafe_interval(T, T(-Inf), alo / blo), unsafe_interval(T, alo / bhi, T(Inf))) + return (a / _unsafe_bareinterval(T, blo, z), a / _unsafe_bareinterval(T, z, bhi)) + # return (_unsafe_bareinterval(T, T(-Inf), alo / blo), _unsafe_bareinterval(T, alo / bhi, T(Inf))) end elseif in_interval(0, a) && in_interval(0, b) - return (entireinterval(T), emptyinterval(T)) + return (entireinterval(BareInterval{T}), emptyinterval(BareInterval{T})) else - return (a / b, emptyinterval(T)) + return (a / b, emptyinterval(BareInterval{T})) end end + + + +# decorated intervals + +function extended_div(x::Interval, y::Interval) + bx = bareinterval(x) + by = bareinterval(y) + r1, r2 = extended_div(bx, by) + d = min(decoration(x), decoration(y)) + d1 = min(d, decoration(r1), ifelse(!isempty_interval(bx) & !isempty_interval(by) & !in_interval(0, x), d, trv)) + d2 = min(d, decoration(r2), trv) + t = isguaranteed(x) & isguaranteed(y) + return _unsafe_interval(r1, d1, t), _unsafe_interval(r2, d2, t) +end diff --git a/src/intervals/interval_operations/numeric.jl b/src/intervals/interval_operations/numeric.jl index 7b3e0e3c1..2533e1719 100644 --- a/src/intervals/interval_operations/numeric.jl +++ b/src/intervals/interval_operations/numeric.jl @@ -1,165 +1,355 @@ -# This file contains the functions described as "Numeric functions" in Section 9.4 -# of the IEEE Std 1788-2015 and required for set-based flavor in Section 10.5.9 -# Some other (non required) related functions are also present -# By default the behavior mimics the required one for the set-based flavor, as -# defined in the standard (sections 10.5.9 and 12.12.8 for the functions in -# this file) +# This file contains the functions described as "Numeric functions" in Section +# 9.4 of the IEEE Std 1788-2015 and required for set-based flavor in Section +# 10.5.9 +# See also Section 12.12.8 """ - inf(a::Interval) + inf(x) -Infimum of an interval. For a zero `AbstractFloat` lower bound, a negative zero -is returned. +Lower bound, or infimum, of `x`. For a zero `AbstractFloat` lower bound, a +negative zero is returned. -Implement the `inf` function of the IEEE Standard 1788-2015 (Table 9.2 and -Section 12.12.8). +Implement the `inf` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`sup`](@ref), [`bounds`](@ref), [`mid`](@ref), [`scaled_mid`](@ref), +[`diam`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -inf(a::Interval) = ifelse(iszero(a.lo), copysign(a.lo, -1), a.lo) +inf(x::BareInterval{T}) where {T<:AbstractFloat} = ifelse(isnan(x.lo), typemax(T), ifelse(iszero(x.lo), copysign(x.lo, -1), x.lo)) +inf(x::BareInterval{<:Rational}) = x.lo -inf(a::Real) = a +function inf(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return inf(bareinterval(x)) +end +function inf(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the infimum of an NaI; cannot return a `Rational` NaN")) + return inf(bareinterval(x)) +end + +inf(x::Real) = x """ - sup(a::Interval) + sup(x) -Supremum of an interval. +Upper bound, or supremum, of `x`. Implement the `sup` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`inf`](@ref), [`bounds`](@ref), [`mid`](@ref), [`scaled_mid`](@ref), +[`diam`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -sup(a::Interval) = a.hi +sup(x::BareInterval{T}) where {T<:AbstractFloat} = ifelse(isnan(x.hi), typemin(T), x.hi) +sup(x::BareInterval{<:Rational}) = x.hi -sup(a::Real) = a +function sup(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return sup(bareinterval(x)) +end +function sup(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the supremum of an NaI; cannot return a `Rational` NaN")) + return sup(bareinterval(x)) +end + +sup(x::Real) = x """ - bounds(a::Interval) + bounds(x) + +Bounds of `x` given as a tuple. Unlike [`inf`](@ref), this function does +not normalize the infimum of the interval. -Bounds of an interval as a tuple. This is semantically equivalent to -`(a.lo, sup(a))`. In particular, this function does not normalize the lower -bound. +See also: [`inf`](@ref), [`sup`](@ref), [`mid`](@ref), [`scaled_mid`](@ref), +[`diam`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -bounds(a::Interval) = (a.lo, sup(a)) +bounds(x::BareInterval{T}) where {T<:AbstractFloat} = (ifelse(isnan(x.lo), typemax(T), x.lo), x.hi) +bounds(x::BareInterval{<:Rational}) = (inf(x), sup(x)) + +function bounds(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return (convert(T, NaN), convert(T, NaN)) + return bounds(bareinterval(x)) +end +function bounds(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the bounds of an NaI; cannot return a `Rational` NaN")) + return bounds(bareinterval(x)) +end + +bounds(x::Real) = (x, x) """ - mid(a::Interval) + mid(x) -Find the midpoint of the interval `a`. +Midpoint of `x`. Implement the `mid` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`inf`](@ref), [`sup`](@ref), [`bounds`](@ref), [`scaled_mid`](@ref), +[`diam`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -function mid(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return convert(T, NaN) - isentire_interval(a) && return zero(T) +function mid(x::BareInterval{T}) where {T<:AbstractFloat} + isempty_interval(x) && return convert(T, NaN) + isentire_interval(x) && return zero(T) - inf(a) == typemin(T) && return nextfloat(inf(a)) # IEEE-1788 section 12.12.8 - sup(a) == typemax(T) && return prevfloat(sup(a)) # IEEE-1788 section 12.12.8 + inf(x) == typemin(T) && return nextfloat(inf(x)) # cf. Section 12.12.8 + sup(x) == typemax(T) && return prevfloat(sup(x)) # cf. Section 12.12.8 - midpoint = (inf(a) + sup(a)) / 2 + midpoint = (inf(x) + sup(x)) / 2 isfinite(midpoint) && return _normalisezero(midpoint) - # Fallback in case of overflow: sup(a) + inf(a) == +∞ or sup(a) + inf(a) == -∞. - # This case can not be the default one as it does not pass several - # IEEE1788-2015 tests for small floats. - return _normalisezero(inf(a) / 2 + sup(a) / 2) + # fallback in case of overflow + # cannot be the default, since it does not pass several IEEE 1788-2015 tests for small floats + return _normalisezero(inf(x) / 2 + sup(x) / 2) end +function mid(x::BareInterval{T}) where {T<:Rational} + isempty_interval(x) && return throw(ArgumentError("cannot compute the midpoint of empty intervals; cannot return a `Rational` NaN")) + isentire_interval(x) && return zero(T) + + inf(x) == typemin(T) && return nextfloat(inf(x)) # cf. Section 12.12.8 + sup(x) == typemax(T) && return prevfloat(sup(x)) # cf. Section 12.12.8 -mid(a::Real) = a + midpoint = (inf(x) + sup(x)) / 2 + isfinite(midpoint) && return _normalisezero(midpoint) + # fallback in case of overflow + # cannot be the default, since it does not pass several IEEE 1788-2015 tests for small floats + return _normalisezero(inf(x) / 2 + sup(x) / 2) +end + +function mid(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return mid(bareinterval(x)) +end +function mid(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the midpoint of an NaI; cannot return a `Rational` NaN")) + return mid(bareinterval(x)) +end + +mid(x::Real) = x +mid(x::Complex) = complex(mid(real(x)), mid(imag(x))) """ - scaled_mid(a::Interval, α) + scaled_mid(x, α) -Find an intermediate point at a relative position `α` in the interval `a` -instead. +Intermediate midpoint of the interval `x` at a relative position `α`. -Assume 0 ≤ α ≤ 1. +!!! note + For unbounded intervals in `:set_based` flavor, `scaled_mid(x, 0.5) != mid(x)`. -Note that `scaled_mid(a, 0.5)` does not equal `mid(a)` for unbounded set-based -intervals. +See also: [`inf`](@ref), [`sup`](@ref), [`bounds`](@ref), [`mid`](@ref), +[`diam`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -function scaled_mid(a::Interval{T}, α) where {T<:NumTypes} - 0 ≤ α ≤ 1 || return throw(DomainError(α, "scaled_mid requires 0 ≤ α ≤ 1")) - isempty_interval(a) && return convert(T, NaN) +function scaled_mid(x::BareInterval{T}, α::Real) where {T<:AbstractFloat} + 0 ≤ α ≤ 1 || return throw(DomainError(α, "scaled_mid only accepts a relative position α between 0 and 1")) + isempty_interval(x) && return convert(T, NaN) + + lo = (inf(x) == typemin(T) ? nextfloat(inf(x)) : inf(x)) + hi = (sup(x) == typemax(T) ? prevfloat(sup(x)) : sup(x)) + + β = convert(T, α) + + midpoint = β * (hi - lo) + lo + isfinite(midpoint) && return midpoint + # fallback in case of overflow + # cannot be the default, since it does not pass several IEEE 1788-2015 tests for small floats + return (1 - β) * lo + β * hi +end +function scaled_mid(x::BareInterval{T}, α::Real) where {T<:Rational} + 0 ≤ α ≤ 1 || return throw(DomainError(α, "scaled_mid only accepts a relative position α between 0 and 1")) + isempty_interval(x) && return throw(ArgumentError("cannot compute the scaled midpoint of empty intervals; cannot return a `Rational` NaN")) - lo = (inf(a) == typemin(T) ? nextfloat(inf(a)) : inf(a)) - hi = (sup(a) == typemax(T) ? prevfloat(sup(a)) : sup(a)) + lo = (inf(x) == typemin(T) ? nextfloat(inf(x)) : inf(x)) + hi = (sup(x) == typemax(T) ? prevfloat(sup(x)) : sup(x)) β = convert(T, α) midpoint = β * (hi - lo) + lo isfinite(midpoint) && return midpoint - # Fallback in case of overflow: hi - lo == +∞. - # This case can not be the default one as it does not pass several - # IEEE1788-2015 tests for small floats. + # fallback in case of overflow + # cannot be the default, since it does not pass several IEEE 1788-2015 tests for small floats return (1 - β) * lo + β * hi end +function scaled_mid(x::Interval{T}, α::Real) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return scaled_mid(bareinterval(x), α) +end +function scaled_mid(x::Interval{<:Rational}, α::Real) + isnai(x) && return throw(ArgumentError("cannot compute the scaled midpoint of an NaI; cannot return a `Rational` NaN")) + return scaled_mid(bareinterval(x), α) +end + +scaled_mid(x::Real, ::Real) = x +scaled_mid(x::Complex, α::Real) = complex(scaled_mid(real(x), α), scaled_mid(imag(x), α)) + """ - diam(a::Interval) + diam(x) -Return the diameter (length) of the interval `a`. +Diameter of `x`. If `x` is complex, then the diameter is the maximum diameter +between its real and imaginary parts. Implement the `wid` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`inf`](@ref), [`sup`](@ref), [`bounds`](@ref), [`mid`](@ref), +[`scaled_mid`](@ref), [`radius`](@ref) and [`midradius`](@ref). """ -function diam(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return convert(T, NaN) - return -(sup(a), inf(a), RoundUp) # IEEE1788 section 12.12.8 +function diam(x::BareInterval{T}) where {T<:AbstractFloat} + isempty_interval(x) && return convert(T, NaN) + return -(sup(x), inf(x), RoundUp) # cf. Section 12.12.8 +end +function diam(x::BareInterval{<:Rational}) + isempty_interval(x) && return throw(ArgumentError("cannot compute the diameter of empty intervals; cannot return a `Rational` NaN")) + return -(sup(x), inf(x), RoundUp) # cf. Section 12.12.8 +end + +function diam(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return diam(bareinterval(x)) +end +function diam(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the diameter of an NaI; cannot return a `Rational` NaN")) + return diam(bareinterval(x)) end -diam(a::Real) = zero(a) +diam(x::Real) = zero(x) +diam(x::Complex) = max(diam(real(x)), diam(imag(x))) """ - radius(a::Interval) + radius(x) -Return the radius of the interval `a`, such that `a ⊆ m ± radius`, where -`m = mid(a)` is the midpoint. +Radius of `x`, such that `issubset_interval(x, mid(x) ± radius(x))`. If `x` is +complex, then the radius is the maximum radius between its real and imaginary +parts. Implement the `rad` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`inf`](@ref), [`sup`](@ref), [`bounds`](@ref), [`mid`](@ref), +[`scaled_mid`](@ref), [`diam`](@ref) and [`midradius`](@ref). """ -function radius(a::Interval) - _, r = midradius(a) +function radius(x::BareInterval) + _, r = midradius(x) return r end -radius(a::Real) = zero(a) +function radius(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return radius(bareinterval(x)) +end +function radius(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the radius of an NaI; cannot return a `Rational` NaN")) + return radius(bareinterval(x)) +end + +radius(x::Real) = zero(x) +radius(x::Complex) = max(radius(real(x)), radius(imag(x))) """ -midradius(a::Interval) + midradius(x) -Return the midpoint of an interval `a` together with its radius. +Midpoint and radius of `x`. Function required by the IEEE Standard 1788-2015 in Section 10.5.9 for the set-based flavor. + +See also: [`inf`](@ref), [`sup`](@ref), [`bounds`](@ref), [`mid`](@ref), +[`scaled_mid`](@ref), [`mid`](@ref) and [`radius`](@ref). """ -function midradius(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return convert(T, NaN), convert(T, NaN) - m = mid(a) - return m, max(m - inf(a), sup(a) - m) +function midradius(x::BareInterval) + m = mid(x) + return m, max(m - inf(x), sup(x) - m) +end + +function midradius(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return (convert(T, NaN), convert(T, NaN)) + return midradius(bareinterval(x)) +end +function midradius(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the midpoint and radius of an NaI; cannot return a `Rational` NaN")) + return midradius(bareinterval(x)) end -midradius(a::Real) = (mid(a), radius(a)) +midradius(x::Real) = (mid(x), radius(x)) +midradius(x::Complex) = (mid(x), radius(x)) """ - mag(a::Interval) + mag(x) -Magnitude of an interval. Return `NaN` for empty intervals. +Magnitude of `x`. Implement the `mag` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`mig`](@ref). """ -function mag(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return convert(T, NaN) - return max(abs(inf(a)), abs(sup(a))) +function mag(x::BareInterval{T}) where {T<:AbstractFloat} + isempty_interval(x) && return convert(T, NaN) + return max(abs(inf(x)), abs(sup(x))) +end +function mag(x::BareInterval{<:Rational}) + isempty_interval(x) && return throw(ArgumentError("cannot compute the magnitude of empty intervals; cannot return a `Rational` NaN")) + return max(abs(inf(x)), abs(sup(x))) +end + +function mag(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return mag(bareinterval(x)) +end +function mag(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the magnitude of an NaI; cannot return a `Rational` NaN")) + return mag(bareinterval(x)) end -mag(a::Real) = abs(a) +mag(x::Real) = abs(x) +mag(x::Complex) = max(mag(real(x)), mag(imag(x))) """ - mig(a::Interval) + mig(x) -Mignitude of an interval. Return `NaN` for empty intervals. +Mignitude of `x`. Implement the `mig` function of the IEEE Standard 1788-2015 (Table 9.2). + +See also: [`mag`](@ref). +""" +function mig(x::BareInterval{T}) where {T<:NumTypes} + isempty_interval(x) && return convert(T, NaN) + in_interval(0, x) && return zero(T) + return min(abs(inf(x)), abs(sup(x))) +end +function mig(x::BareInterval{T}) where {T<:Rational} + isempty_interval(x) && return throw(ArgumentError("cannot compute the mignitude of empty intervals; cannot return a `Rational` NaN")) + in_interval(0, x) && return zero(T) + return min(abs(inf(x)), abs(sup(x))) +end + +function mig(x::Interval{T}) where {T<:AbstractFloat} + isnai(x) && return convert(T, NaN) + return mig(bareinterval(x)) +end +function mig(x::Interval{<:Rational}) + isnai(x) && return throw(ArgumentError("cannot compute the mignitude of an NaI; cannot return a `Rational` NaN")) + return mig(bareinterval(x)) +end + +mig(x::Real) = abs(x) +mig(x::Complex) = min(mag(real(x)), mag(imag(x))) + +""" + dist(x, y) + +Distance between `x` and `y`. """ -function mig(a::Interval{T}) where {T<:NumTypes} - isempty_interval(a) && return convert(T, NaN) - in_interval(0, a) && return zero(T) - return min(abs(inf(a)), abs(sup(a))) +function dist(x::BareInterval{T}, y::BareInterval{T}) where {T<:AbstractFloat} + isempty_interval(x) | isempty_interval(y) && return convert(T, NaN) + return max(abs(inf(x) - inf(y)), abs(sup(x) - sup(y))) +end +function dist(x::BareInterval{T}, y::BareInterval{T}) where {T<:Rational} + isempty_interval(x) | isempty_interval(y) && return throw(ArgumentError("cannot compute the distance of empty intervals; cannot return a `Rational` NaN")) + return max(abs(inf(x) - inf(y)), abs(sup(x) - sup(y))) end +dist(x::BareInterval, y::BareInterval) = dist(promote(x, y)...) -mig(a::Real) = abs(a) +function dist(x::Interval{T}, y::Interval{T}) where {T<:AbstractFloat} + isnai(x) | isnai(y) && return convert(T, NaN) + return dist(bareinterval(x), bareinterval(y)) +end +function dist(x::Interval{T}, y::Interval{T}) where {T<:Rational} + isnai(x) | isnai(y) && return throw(ArgumentError("cannot compute the distance of an NaI; cannot return a `Rational` NaN")) + return dist(bareinterval(x), bareinterval(y)) +end +dist(x::Interval, y::Interval) = dist(promote(x, y)...) diff --git a/src/intervals/interval_operations/overlap.jl b/src/intervals/interval_operations/overlap.jl index 7839cdf66..31f37acd9 100644 --- a/src/intervals/interval_operations/overlap.jl +++ b/src/intervals/interval_operations/overlap.jl @@ -27,19 +27,23 @@ They are numerated starting on 1. To see the distinct instances, type after end + + +# bare intervals + """ - overlap(a::Interval, b::Interval) + overlap(a, b) Implement the `overlap` function according to the IEEE Standard 1788-2015 (Section 10.6.4 and Table 10.7). """ -function overlap(a::Interval, b::Interval) +function overlap(a::BareInterval, b::BareInterval) # At least one interval is empty isempty_interval(a) && isempty_interval(b) && return Overlap.both_empty isempty_interval(a) && return Overlap.first_empty isempty_interval(b) && return Overlap.second_empty - # States with both intervals nonempty + # States with both intervals non-empty sup(a) < inf(b) && return Overlap.before inf(a) != sup(a) && inf(b) != sup(b) && sup(a) == inf(b) && return Overlap.meets inf(a) < inf(b) && sup(a) < sup(b) && sup(a) > inf(b) && return Overlap.overlaps @@ -54,3 +58,10 @@ function overlap(a::Interval, b::Interval) inf(a) != sup(a) && inf(b) != sup(b) && inf(a) == sup(b) && return Overlap.met_by sup(b) < sup(a) && return Overlap.after end + + + +# decorated intervals +# TODO: handle NaI differently + +overlap(x::Interval, y::Interval) = overlap(bareinterval(x), bareinterval(y)) diff --git a/src/intervals/interval_operations/set_operations.jl b/src/intervals/interval_operations/set_operations.jl index d27fc614c..baf4cc07a 100644 --- a/src/intervals/interval_operations/set_operations.jl +++ b/src/intervals/interval_operations/set_operations.jl @@ -2,6 +2,10 @@ # of the IEEE Std 1788-2015 and required for set-based flavor in Section 10.5.7 # Some other related functions are also present + + +# bare intervals + """ intersect_interval(a, b) @@ -11,34 +15,12 @@ the points common in `a` and `b`. Implement the `intersection` function of the IEEE Standard 1788-2015 (Section 9.3). """ -function intersect_interval(a::Interval{T}, b::Interval{S}) where {T<:NumTypes,S<:NumTypes} - R = promote_numtype(T, S) - isdisjoint_interval(a, b) && return emptyinterval(R) - return unsafe_interval(R, max(inf(a), inf(b)), min(sup(a), sup(b))) -end - -function intersect_interval(a::Complex{Interval{T}}, b::Complex{Interval{S}}) where {T<:NumTypes,S<:NumTypes} +function intersect_interval(a::BareInterval{T}, b::BareInterval{S}) where {T<:NumTypes,S<:NumTypes} R = promote_numtype(T, S) - isdisjoint_interval(a, b) && return emptyinterval(Complex{R}) - a_re, a_im = reim(a) - b_re, b_im = reim(b) - x_re = unsafe_interval(R, max(inf(a_re), inf(b_re)), min(sup(a_re), sup(b_re))) - x_im = unsafe_interval(R, max(inf(a_im), inf(b_im)), min(sup(a_im), sup(b_im))) - return complex(x_re, x_im) + isdisjoint_interval(a, b) && return emptyinterval(BareInterval{R}) + return _unsafe_bareinterval(R, max(inf(a), inf(b)), min(sup(a), sup(b))) end -""" - intersect_interval(a::Interval{T}...) where T - -Return the n-ary intersect_interval of its arguments. - -This function is applicable to any number of input intervals, as in -`intersect_interval(a1, a2, a3, a4)` where `ai` is an interval. -If your use case needs to splat the input, as in `intersect_interval(a...)`, consider -`reduce(intersect_interval, a)` instead, because you save the cost of splatting. -""" -intersect_interval(a::Union{Interval,Complex{<:Interval}}, b::Union{Interval,Complex{<:Interval}}...) = reduce(intersect_interval, b; init = a) - """ hull(a, b) @@ -48,16 +30,11 @@ all of `a` and `b`. Implement the `convexHull` function of the IEEE Standard 1788-2015 (Section 9.3). """ -hull(a::Interval{T}, b::Interval{S}) where {T<:NumTypes,S<:NumTypes} = - unsafe_interval(promote_numtype(T, S), min(inf(a), inf(b)), max(sup(a), sup(b))) -hull(a::Complex{<:Interval}, b::Complex{<:Interval}) = - complex(hull(real(a), real(b)), hull(imag(a), imag(b))) -hull(a::Interval, b::Complex{<:Interval}) = complex(hull(a, real(b)), imag(b)) -hull(a::Complex{<:Interval}, b::Interval) = complex(hull(real(a), b), imag(a)) -hull(a::Union{Interval,Complex{<:Interval}}, b::Union{Interval,Complex{<:Interval}}...) = reduce(hull, b; init = a) +hull(a::BareInterval{T}, b::BareInterval{S}) where {T<:NumTypes,S<:NumTypes} = + _unsafe_bareinterval(promote_numtype(T, S), min(inf(a), inf(b)), max(sup(a), sup(b))) """ - setdiff_interval(x::Interval, y::Interval) + setdiff_interval(x::BareInterval, y::BareInterval) Calculate the set difference `x ∖ y`, i.e. the set of values that are inside the interval `x` but not inside `y`. @@ -69,15 +46,54 @@ The array may: - contain a single interval, if `y` overlaps `x` - contain two intervals, if `y` is strictly contained within `x`. """ -function setdiff_interval(x::Interval{T}, y::Interval{T}) where {T<:NumTypes} +function setdiff_interval(x::BareInterval{T}, y::BareInterval{T}) where {T<:NumTypes} inter = intersect_interval(x, y) isempty_interval(inter) && return [x] - isequal_interval(inter, x) && return Interval{T}[] # x is subset of y; setdiff is empty + isequal_interval(inter, x) && return BareInterval{T}[] # x is subset of y; setdiff is empty + + inf(x) == inf(inter) && return [_unsafe_bareinterval(T, sup(inter), sup(x))] + sup(x) == sup(inter) && return [_unsafe_bareinterval(T, inf(x), inf(inter))] + + return [_unsafe_bareinterval(T, inf(x), inf(y)), _unsafe_bareinterval(T, sup(y), sup(x))] +end + + + +# decorated intervals + +for f ∈ (:intersect_interval, :hull) + @eval begin + """ + $($f)(x, y) + + Decorated interval extension; the result is decorated by at most `trv`, + following the IEEE-1788 Standard (see Sect. 11.7.1, pp 47). + """ + function $f(x::Interval, y::Interval) + r = $f(bareinterval(x), bareinterval(y)) + d = min(decoration(x), decoration(y), decoration(r), trv) + t = isguaranteed(x) & isguaranteed(y) + return _unsafe_interval(r, d, t) + end + end +end + +function setdiff_interval(x::Interval, y::Interval) + r = setdiff_interval(bareinterval(x), bareinterval(y)) + t = isguaranteed(x) & isguaranteed(y) + return _unsafe_interval.(r, min.(decoration(x), decoration(y), decoration.(r), trv), t) +end + - inf(x) == inf(inter) && return [unsafe_interval(T, sup(inter), sup(x))] - sup(x) == sup(inter) && return [unsafe_interval(T, inf(x), inf(inter))] - return [unsafe_interval(T, inf(x), inf(y)), unsafe_interval(T, sup(y), sup(x))] +# extension +for f ∈ (:intersect_interval, :hull) + @eval begin + $f(x, y, z, w...) = reduce($f, (x, y, z, w...)) + $f(x::Complex, y::Complex) = complex($f(real(x), real(y)), $f(imag(x), imag(y))) + $f(x::Real, y::Complex) = complex($f(x, real(y)), $f(zero(x), imag(y))) + $f(x::Complex, y::Real) = complex($f(real(x), y), $f(imag(x), zero(y))) + end end diff --git a/src/intervals/intervals.jl b/src/intervals/intervals.jl index df56bacb8..b116493b0 100644 --- a/src/intervals/intervals.jl +++ b/src/intervals/intervals.jl @@ -1,5 +1,6 @@ # Construction and composability with numbers include("construction.jl") +include("parsing.jl") include("real_interface.jl") # Rounding @@ -15,7 +16,6 @@ include("arithmetic/basic.jl") include("arithmetic/hyperbolic.jl") include("arithmetic/integer.jl") include("arithmetic/power.jl") -include("arithmetic/signbit.jl") include("arithmetic/trigonometric.jl") # Other functions @@ -26,6 +26,7 @@ include("interval_operations/boolean.jl") include("interval_operations/overlap.jl") include("interval_operations/numeric.jl") include("interval_operations/set_operations.jl") +include("interval_operations/bisect.jl") # Multidimensional functions include("multidim.jl") diff --git a/src/intervals/multidim.jl b/src/intervals/multidim.jl index 3c1b22328..179a86a35 100644 --- a/src/intervals/multidim.jl +++ b/src/intervals/multidim.jl @@ -55,7 +55,7 @@ function setdiff_interval(A::T, B::T) where {T<:AbstractVector} N = length(A) (length(B) == N) || return throw(DimensionMismatch("A and B must have the same length")) inter = intersect_interval.(A, B) - any(isempty_interval, inter) && return [A] + any(x -> isempty_interval(x) | isnai(x), inter) && return [A] result_list = Vector{T}(undef, 2*N) offset = 0 x = copy(A) @@ -72,20 +72,26 @@ function setdiff_interval(A::T, B::T) where {T<:AbstractVector} offset += 2 x[i] = inter[i] end - return filter!(x -> !any(isempty_interval, x), result_list) + return filter!(x -> !any(x -> isempty_interval(x) | isnai(x), x), result_list) end # Computes the set difference x\\y and always returns a tuple of two intervals. # If the set difference is only one interval or is empty, then the returned tuple contains 1 # or 2 empty intervals. -function _setdiff_interval(x::Interval{T}, y::Interval{T}) where {T<:NumTypes} +function _setdiff_interval(x::BareInterval{T}, y::BareInterval{T}) where {T<:NumTypes} inter = intersect_interval(x, y) - isempty_interval(inter) && return (x, emptyinterval(T)) - isequal_interval(inter, x) && return (emptyinterval(T), emptyinterval(T)) # x is subset of y; setdiff is empty + isempty_interval(inter) && return (x, emptyinterval(BareInterval{T})) + isequal_interval(inter, x) && return (emptyinterval(BareInterval{T}), emptyinterval(BareInterval{T})) # x is subset of y; setdiff is empty xlo, xhi = bounds(x) ylo, yhi = bounds(y) interlo, interhi = bounds(inter) - xlo == interlo && return (unsafe_interval(T, interhi, xhi), emptyinterval(T)) - xhi == interhi && return (unsafe_interval(T, xlo, interlo), emptyinterval(T)) - return (unsafe_interval(T, xlo, ylo), unsafe_interval(T, yhi, xhi)) + xlo == interlo && return (_unsafe_bareinterval(T, interhi, xhi), emptyinterval(BareInterval{T})) + xhi == interhi && return (_unsafe_bareinterval(T, xlo, interlo), emptyinterval(BareInterval{T})) + return (_unsafe_bareinterval(T, xlo, ylo), _unsafe_bareinterval(T, yhi, xhi)) +end + +function _setdiff_interval(x::Interval{T}, y::Interval{T}) where {T<:NumTypes} + h1, h2 = _setdiff_interval(bareinterval(x), bareinterval(y)) + t = isguaranteed(x) & isguaranteed(y) + return (_unsafe_interval(h1, trv, t), _unsafe_interval(h2, trv, t)) end diff --git a/src/parsing.jl b/src/intervals/parsing.jl similarity index 64% rename from src/parsing.jl rename to src/intervals/parsing.jl index affb4adab..8f42f164f 100644 --- a/src/parsing.jl +++ b/src/intervals/parsing.jl @@ -2,34 +2,27 @@ 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)`. +semantically equivalent to `parse(Interval{default_numtype()}, str)`. # Examples ```jldoctest -julia> setformat(:full); +julia> setdisplay(:full); julia> I"[3, 4]" -Interval{Float64}(3.0, 4.0) +Interval{Float64}(3.0, 4.0, com) julia> I"0.1" -Interval{Float64}(0.09999999999999999, 0.1) +Interval{Float64}(0.09999999999999999, 0.1, com) ``` """ macro I_str(str) - if '_' ∈ str - return parse(DecoratedInterval{default_numtype()}, str) - else - return parse(Interval{default_numtype()}, str) - end + return parse(Interval{default_numtype()}, str) end # """ - parse(Interval, s::AbstractString) + parse(BareInterval, s::AbstractString) Create an interval according to the IEEE Standard 1788-2015. In contrast with constructors that do not use strings, this constructor guarantees that the @@ -55,33 +48,33 @@ For more details, see sections 9.7 and 12.11 of the IEEE Standard 1788-2015. # Examples ```jldoctest -julia> setformat(:full); +julia> setdisplay(:full); -julia> parse(Interval{Float64}, "[1, 2]") -Interval{Float64}(1.0, 2.0) +julia> parse(BareInterval{Float64}, "[1, 2]") +BareInterval{Float64}(1.0, 2.0) -julia> parse(Interval{Float64}, "[1, 2]") -Interval{Float64}(1.0, 2.0) +julia> parse(BareInterval{Float64}, "[1, 2]") +BareInterval{Float64}(1.0, 2.0) -julia> parse(Interval{Float64}, "[1,]") -Interval{Float64}(1.0, Inf) +julia> parse(BareInterval{Float64}, "[1,]") +BareInterval{Float64}(1.0, Inf) -julia> parse(Interval{Float64}, "[,]") -Interval{Float64}(-Inf, Inf) +julia> parse(BareInterval{Float64}, "[,]") +BareInterval{Float64}(-Inf, Inf) -julia> parse(Interval{Float64}, "6.42?2e2") -Interval{Float64}(640.0, 644.0) +julia> parse(BareInterval{Float64}, "6.42?2e2") +BareInterval{Float64}(640.0, 644.0) ``` """ -function parse(::Type{F}, str::AbstractString) where {F<:Interval} +function parse(::Type{BareInterval{T}}, str::AbstractString) where {T<:NumTypes} str = lowercase(strip(str)) try - ival, _ = _parse(F, str) + ival, _ = _parse(BareInterval{T}, str) return ival catch e if e isa ArgumentError - @warn "invalid input, empty interval is returned" - return emptyinterval(F) + @warn "invalid input, empty bare interval is returned" + return emptyinterval(BareInterval{T}) else rethrow(e) end @@ -89,34 +82,34 @@ function parse(::Type{F}, str::AbstractString) where {F<:Interval} end """ - parse(DecoratedInterval, s::AbstractString) + parse(Interval, s::AbstractString) -Parse a string of the form `"[a, b]_dec"` as a `DecoratedInterval` with decoration `dec`. +Parse a string of the form `"[a, b]_dec"` as an `Interval` with decoration `dec`. If the decoration is not specified, it is computed based on the parsed interval. -If the input is an invalid string, a warning is printed and [NaI] is returned. The parser is +If the input is an invalid string, a warning is printed and NaI is returned. The parser is case unsensitive. # Examples ```jldoctest -julia> setformat(:full); +julia> setdisplay(:full); -julia> parse(DecoratedInterval{Float64}, "[1, 2]") -DecoratedInterval(Interval{Float64}(1.0, 2.0), com) +julia> parse(Interval{Float64}, "[1, 2]") +Interval{Float64}(1.0, 2.0, com) -julia> parse(DecoratedInterval{Float64}, "[1, 2]_def") -DecoratedInterval(Interval{Float64}(1.0, 2.0), def) +julia> parse(Interval{Float64}, "[1, 2]_def") +Interval{Float64}(1.0, 2.0, def) ``` """ -function parse(::Type{DecoratedInterval{T}}, s::AbstractString) where {T<:NumTypes} +function parse(::Type{Interval{T}}, s::AbstractString) where {T<:NumTypes} s = lowercase(strip(s)) s == "[nai]" && return nai(T) try if '_' ∉ s - ival, _ = _parse(Interval{T}, s) - return DecoratedInterval{T}(ival) + ival, _ = _parse(BareInterval{T}, s) + return interval(T, ival) end - decorations = Dict( + decorations = Dict{String,Decoration}( "ill" => ill, "trv" => trv, "def" => def, @@ -125,26 +118,26 @@ function parse(::Type{DecoratedInterval{T}}, s::AbstractString) where {T<:NumTyp interval_string, dec = split(s, "_") - ival, isnotcom = _parse(Interval{T}, interval_string) + ival, isnotcom = _parse(BareInterval{T}, interval_string) dec_calc = decoration(ival) - haskey(decorations, dec) || throw(ArgumentError("invalid decoration $dec")) + haskey(decorations, dec) || return throw(ArgumentError("invalid decoration $dec")) dec_given = decorations[dec] #= If I try to give a decoration that is too high, e.g. [1, Inf]_com, then it - should error and return [NaI]. Exception to this is if the interval would be com + should error and return NaI. Exception to this is if the interval would be com but becomes dac because of finite precision, e.g. "[1e403]_com" when parse to Interval{Float64} is allowed to become [prevfloat(Inf), Inf]_dac without erroring. The isnotcom flag returned by _parse is used to track if the interval was originally smaller than com or became dac because of overflow. =# - dec_given > dec_calc && isnotcom && throw(ArgumentError("invalid decoration $dec for $ival")) + dec_given > dec_calc && isnotcom && return throw(ArgumentError("invalid decoration $dec for $ival")) - return DecoratedInterval{T}(ival, min(dec_given, dec_calc)) + return interval(T, ival, min(dec_given, dec_calc)) catch e if e isa ArgumentError - @warn "invalid input, returning [NaI]" + @warn "invalid input, NaI is returned" return nai(T) else rethrow(e) @@ -155,7 +148,7 @@ end """ _parse(::Type{Interval{T}}, s::AbstractString) where T -tries to parse the string `s` to an interval of type `Interval{T}` and throws an argument +Try to parse the string `s` to an interval of type `Interval{T}` and throws an argument error if an invalid string is given. ### Output @@ -166,22 +159,22 @@ error if an invalid string is given. unbounded (e.g. input `"[3, infinity]"`) or becomes unbounded because of overflow (e.g. the input `"[3, 1e400]", which is parse to `[3, ∞]` when using `Float64`). """ -function _parse(::Type{Interval{T}}, s::AbstractString) where {T<:NumTypes} +function _parse(::Type{BareInterval{T}}, s::AbstractString) where {T<:NumTypes} isnotcom = occursin("inf", s) if startswith(s, '[') && endswith(s, ']') # parse as interval s = strip(s[2:end-1]) - if ',' in s # infsupinterval + if ',' in s # inf-sup interval lo, hi = strip.(split(s, ',')) isempty(lo) && (lo = "-inf"; isnotcom = true) isempty(hi) && (hi = "inf"; isnotcom = true) - lo = parse_num(T, lo, RoundDown) - hi = parse_num(T, hi, RoundUp) + lo = _parse_num(T, lo, RoundDown) + hi = _parse_num(T, hi, RoundUp) else # point interval - (s == "empty" || isempty(s)) && return emptyinterval(T), true # emptyinterval - s == "entire" && return entireinterval(T), true # entireinterval - lo = parse_num(T, s, RoundDown) - hi = parse_num(T, s, RoundUp) + (s == "empty" || isempty(s)) && return emptyinterval(BareInterval{T}), true + s == "entire" && return entireinterval(BareInterval{T}), true + lo = _parse_num(T, s, RoundDown) + hi = _parse_num(T, s, RoundUp) end elseif '?' in s # uncertainty interval if occursin("??", s) # unbounded interval @@ -194,7 +187,7 @@ function _parse(::Type{Interval{T}}, s::AbstractString) where {T<:NumTypes} lo = typemin(T) hi = parse(T, m, RoundUp) else - return entireinterval(T), true + return entireinterval(BareInterval{T}), true end else m , vde = split(s, '?') @@ -236,17 +229,17 @@ function _parse(::Type{Interval{T}}, s::AbstractString) where {T<:NumTypes} end end else # number - lo = parse_num(T, s, RoundDown) - hi = parse_num(T, s, RoundUp) + lo = _parse_num(T, s, RoundDown) + hi = _parse_num(T, s, RoundUp) end - is_valid_interval(lo, hi) && return unsafe_interval(T, lo, hi), isnotcom - throw(ArgumentError("input $s can not be parsed as an interval.")) + is_valid_interval(lo, hi) && return _unsafe_bareinterval(T, lo, hi), isnotcom + return throw(ArgumentError("input $s can not be parsed as an interval.")) end """ Same as `parse(T, s, rounding_mode)`, but also accept string representing rational numbers. """ -function parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Down}) where {S<:Integer,T<:Rational{S}} +function _parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Down}) where {S<:Integer,T<:Rational{S}} '/' ∈ str && return parse(T, str) x = parse(BigFloat, str) y = prevfloat(x) @@ -254,7 +247,7 @@ function parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Down}) where z < x && return z return rationalize(S, prevfloat(y)) end -function parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Up}) where {S<:Integer,T<:Rational{S}} +function _parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Up}) where {S<:Integer,T<:Rational{S}} '/' ∈ str && return parse(T, str) x = parse(BigFloat, str) y = nextfloat(x) @@ -262,7 +255,7 @@ function parse_num(::Type{T}, str::AbstractString, ::RoundingMode{:Up}) where {S z > x && return z return rationalize(S, nextfloat(y)) end -function parse_num(::Type{T}, str::AbstractString, rounding_mode::RoundingMode) where {T<:AbstractFloat} +function _parse_num(::Type{T}, str::AbstractString, rounding_mode::RoundingMode) where {T<:AbstractFloat} if '/' ∈ str num, denum = parse.(BigInt, split(str, '/'; keepempty = false)) return T(num//denum, rounding_mode) diff --git a/src/intervals/real_interface.jl b/src/intervals/real_interface.jl index e1251ca56..3d4cccd90 100644 --- a/src/intervals/real_interface.jl +++ b/src/intervals/real_interface.jl @@ -1,107 +1,125 @@ """ - numtype(::T) - numtype(::Type{T}) + numtype(T) -Return the type `T` of the bounds of the interval. +Return the bounds type of the interval. -# Example -``` +# Examples + +```jldoctest julia> IntervalArithmetic.numtype(interval(1, 2)) Float64 + +julia> IntervalArithmetic.numtype(interval(Float32, 1, 2)) +Float32 ``` """ -numtype(::F) where {F} = numtype(F) +numtype(::Type{BareInterval{T}}) where {T<:NumTypes} = T numtype(::Type{Interval{T}}) where {T<:NumTypes} = T +numtype(::Type{Complex{T}}) where {T<:Real} = numtype(T) numtype(::Type{T}) where {T} = T +numtype(::T) where {T} = numtype(T) # standard `Real` functions -float(x::Interval{T}) where {T<:NumTypes} = Interval{float(T)}(x) -big(x::Interval{T}) where {T<:NumTypes} = Interval{big(T)}(x) - -zero(::F) where {F<:Interval} = zero(F) -function zero(::Type{Interval{T}}) where {T<:NumTypes} - x = zero(T) - return unsafe_interval(T, x, x) +for f ∈ (:float, :big) + @eval begin + Base.$f(x::BareInterval{T}) where {T<:NumTypes} = BareInterval{$f(T)}(x) + Base.$f(x::Interval{<:NumTypes}) = _unsafe_interval($f(bareinterval(x)), decoration(x), isguaranteed(x)) + end end -one(::F) where {F<:Interval} = one(F) -function one(::Type{Interval{T}}) where {T<:NumTypes} - x = one(T) - return unsafe_interval(T, x, x) +for f ∈ (:zero, :one) + @eval begin + Base.$f(::T) where {T<:BareInterval} = $f(T) + Base.$f(::Type{BareInterval{T}}) where {T<:NumTypes} = _unsafe_bareinterval(T, $f(T), $f(T)) + Base.$f(::T) where {T<:Interval} = $f(T) + Base.$f(::Type{Interval{T}}) where {T<:NumTypes} = _unsafe_interval($f(BareInterval{T}), com, true) + end end -typemin(::Type{Interval{T}}) where {T<:NumTypes} = unsafe_interval(T, typemin(T), nextfloat(typemin(T))) -typemax(::Type{Interval{T}}) where {T<:NumTypes} = unsafe_interval(T, prevfloat(typemax(T)), typemax(T)) +Base.typemin(::Type{BareInterval{T}}) where {T<:NumTypes} = + _unsafe_bareinterval(T, typemin(T), nextfloat(typemin(T))) +Base.typemin(::Type{Interval{T}}) where {T<:NumTypes} = + _unsafe_interval(typemin(BareInterval{T}), dac, true) -function eps(a::Interval{T}) where {T<:NumTypes} +Base.typemax(::Type{BareInterval{T}}) where {T<:NumTypes} = + _unsafe_bareinterval(T, prevfloat(typemax(T)), typemax(T)) +Base.typemax(::Type{Interval{T}}) where {T<:NumTypes} = + _unsafe_interval(typemax(BareInterval{T}), dac, true) + +function Base.eps(a::BareInterval{T}) where {T<:NumTypes} x = max(eps(inf(a)), eps(sup(a))) - return unsafe_interval(T, x, x) + return _unsafe_bareinterval(T, x, x) end -function eps(::Type{Interval{T}}) where {T<:NumTypes} +Base.eps(x::Interval) = _unsafe_interval(eps(bareinterval(x)), com, true) +function Base.eps(::Type{BareInterval{T}}) where {T<:NumTypes} x = eps(T) - return unsafe_interval(T, x, x) + return _unsafe_bareinterval(T, x, x) end +Base.eps(::Type{Interval{T}}) where {T<:NumTypes} = + _unsafe_interval(eps(BareInterval{T}), com, true) """ - hash(x::Interval, h) + hash(x::BareInterval, h::UInt) + hash(x::Interval, h::UInt) -Compute the integer hash code for an interval. Note that in -`IntervalArithmetic.jl`, equality of intervals is given by `isequal_interval` -rather than the `==` operator. +Compute the integer hash code for an interval. Note that equality of intervals +is given by [`isequal_interval`](@ref) rather than the `==` operator. """ -hash(x::Interval, h::UInt) = hash(sup(x), hash(inf(x), hash(Interval, h))) - -# TODO No idea where this comes from and if it is the correct place to put it. -dist(a::Interval, b::Interval) = max(abs(inf(a)-inf(b)), abs(sup(a)-sup(b))) +Base.hash(x::BareInterval, h::UInt) = hash(sup(x), hash(inf(x), hash(BareInterval, h))) +Base.hash(x::Interval, h::UInt) = hash(sup(x), hash(inf(x), hash(Interval, h))) # -Base.:(==)(::Interval, ::Interval) = # also returned when calling `≤`, `≥`, `isequal` - throw(ArgumentError("`==` is purposely not supported for intervals. See instead `isequal_interval`.")) +for T ∈ (:BareInterval, :Interval) + @eval begin + Base.:(==)(::$T, ::$T) = # also returned when calling `≤`, `≥`, `isequal` + throw(ArgumentError("`==` is purposely not supported for intervals. See instead `isequal_interval`")) -Base.:<(::Interval, ::Interval) = # also returned when calling `isless`, `>` - throw(ArgumentError("`<` is purposely not supported for intervals. See instead `isstrictless`, `strictprecedes`.")) + Base.:<(::$T, ::$T) = # also returned when calling `isless`, `>` + throw(ArgumentError("`<` is purposely not supported for intervals. See instead `isstrictless`, `strictprecedes`")) -Base.isdisjoint(::Interval, ::Interval) = - throw(ArgumentError("`isdisjoint` is purposely not supported for intervals. See instead `isdisjoint_interval`.")) + Base.isdisjoint(::$T, ::$T) = + throw(ArgumentError("`isdisjoint` is purposely not supported for intervals. See instead `isdisjoint_interval`")) -Base.issubset(::Interval, ::Interval) = - throw(ArgumentError("`issubset` is purposely not supported for intervals. See instead `issubset_interval`.")) + Base.issubset(::$T, ::$T) = + throw(ArgumentError("`issubset` is purposely not supported for intervals. See instead `issubset_interval`")) -Base.issetequal(::Interval, ::Interval) = - throw(ArgumentError("`issetequal` is purposely not supported for intervals. See instead `isequal_interval`.")) + Base.issetequal(::$T, ::$T) = + throw(ArgumentError("`issetequal` is purposely not supported for intervals. See instead `isequal_interval`")) -Base.in(::Interval, ::Interval) = - throw(ArgumentError("`in` is purposely not supported for intervals. See instead `in_interval`.")) + Base.in(::$T, ::$T) = + throw(ArgumentError("`in` is purposely not supported for intervals. See instead `in_interval`")) -Base.isempty(::Interval) = - throw(ArgumentError("`isempty` is purposely not supported for intervals. See instead `isempty_interval`.")) + Base.isempty(::$T) = + throw(ArgumentError("`isempty` is purposely not supported for intervals. See instead `isempty_interval`")) -Base.isfinite(::Interval) = # also returned when calling `isinf` - throw(ArgumentError("`isfinite` is purposely not supported for intervals. See instead `isbounded`.")) + Base.isfinite(::$T) = # also returned when calling `isinf` + throw(ArgumentError("`isfinite` is purposely not supported for intervals. See instead `isbounded`")) -Base.isnan(::Interval) = - throw(ArgumentError("`isnan` is purposely not supported for intervals. See instead `isnai`.")) + Base.isnan(::$T) = + throw(ArgumentError("`isnan` is purposely not supported for intervals. See instead `isnai`")) -Base.isinteger(::Interval) = - throw(ArgumentError("`isinteger` is purposely not supported for intervals. See instead `isthininteger`.")) + Base.isinteger(::$T) = + throw(ArgumentError("`isinteger` is purposely not supported for intervals. See instead `isthininteger`")) -Base.intersect(::Interval) = - throw(ArgumentError("`intersect` is purposely not supported for intervals. See instead `intersect_interval`.")) + Base.intersect(::$T) = + throw(ArgumentError("`intersect` is purposely not supported for intervals. See instead `intersect_interval`")) -Base.union!(::AbstractSet, ::Interval) = # also returned when calling `intersect`, `symdiff` with intervals - throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`.")) -Base.union!(::AbstractVector{T}, ::Interval) where {T} = - throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`.")) -Base.union!(::AbstractVector{T}, ::Interval, ::Any, ::Any...) where {T} = - throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`.")) -Base.union!(::AbstractVector{T}, ::Interval, ::Interval, ::Any...) where {T} = - throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`.")) -Base.union!(::AbstractVector{T}, ::Any, ::Interval, ::Any...) where {T} = - throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`.")) + Base.union!(::AbstractSet, ::$T) = # also returned when calling `intersect`, `symdiff` with intervals + throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`")) + Base.union!(::AbstractVector{S}, ::$T) where {S} = + throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`")) + Base.union!(::AbstractVector{S}, ::$T, ::Any, ::Any...) where {S} = + throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`")) + Base.union!(::AbstractVector{S}, ::$T, ::$T, ::Any...) where {S} = + throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`")) + Base.union!(::AbstractVector{S}, ::Any, ::$T, ::Any...) where {S} = + throw(ArgumentError("`union!` is purposely not supported for intervals. See instead `hull`")) -Base.setdiff(::Interval) = - throw(ArgumentError("`setdiff` is purposely not supported for intervals. See instead `setdiff_interval`.")) -Base.setdiff!(::AbstractSet, ::Interval) = - throw(ArgumentError("`setdiff!` is purposely not supported for intervals. See instead `setdiff_interval`.")) + Base.setdiff(::$T) = + throw(ArgumentError("`setdiff` is purposely not supported for intervals. See instead `setdiff_interval`")) + Base.setdiff!(::AbstractSet, ::$T) = + throw(ArgumentError("`setdiff!` is purposely not supported for intervals. See instead `setdiff_interval`")) + end +end diff --git a/src/intervals/rounding.jl b/src/intervals/rounding.jl index e0144786a..8bdac0b02 100644 --- a/src/intervals/rounding.jl +++ b/src/intervals/rounding.jl @@ -98,6 +98,16 @@ function sqrt(a::T, rounding_mode::RoundingMode) where {T<:Rational} end end + +for f in (:exp2, :exp10, :cbrt) + @eval function ($f)(x::BigFloat, r::RoundingMode) # add BigFloat functions with rounding: + setrounding(BigFloat, r) do + ($f)(x) + end + end +end + + rounding_directions = [ (:down, RoundingMode{:Down}, prevfloat), (:up, RoundingMode{:Up}, nextfloat) @@ -231,3 +241,27 @@ for f in (:+, :-, :*, :/, :^, :atan) return $f(a, b) end end + +# prevents multiple threads from calling `setprecision` concurrently, used in `_bigequiv` +const precision_lock = ReentrantLock() + +""" + _bigequiv(x) + +Create a `BigFloat` equivalent with the same underlying precision as `x`. +""" +function _bigequiv(x::BareInterval{T}) where {T<:NumTypes} + lock(precision_lock) do + setprecision(precision(float(T))) do + return BareInterval{BigFloat}(x) + end + end +end + +function _bigequiv(x::T) where {T<:NumTypes} + lock(precision_lock) do + setprecision(precision(float(T))) do + return BigFloat(x) + end + end +end diff --git a/src/intervals/rounding_macros.jl b/src/intervals/rounding_macros.jl index dd4a87335..425344594 100644 --- a/src/intervals/rounding_macros.jl +++ b/src/intervals/rounding_macros.jl @@ -44,5 +44,5 @@ The macro uses the internal `round_expr` function to transform e.g. `a + b` into `+(a, b, RoundDown)`. """ macro round(T, ex1, ex2) - return :(unsafe_interval($(esc(T)), $(round_expr(ex1, RoundDown)), $(round_expr(ex2, RoundUp)))) + return :(_unsafe_bareinterval($(esc(T)), $(round_expr(ex1, RoundDown)), $(round_expr(ex2, RoundUp)))) end diff --git a/src/symbols.jl b/src/symbols.jl index 7d09d0937..af44c9180 100644 --- a/src/symbols.jl +++ b/src/symbols.jl @@ -1,7 +1,7 @@ module Symbols using IntervalArithmetic - export .., ≛, ≺, ⪽, ∅, ℝ + export .., ±, ≛, ≺, ⪽, ∅, ℝ """ ..(a, b) @@ -17,38 +17,70 @@ julia> using IntervalArithmetic julia> using IntervalArithmetic.Symbols -julia> setformat(:full); +julia> setdisplay(:full); julia> (1//1)..π -Interval{Rational{Int64}}(1//1, 85563208//27235615) +Interval{Rational{Int64}}(1//1, 85563208//27235615, com) julia> 0.1..0.3 -Interval{Float64}(0.1, 0.3) +Interval{Float64}(0.1, 0.3, com) ``` ``` """ -const .. = interval +.. = interval + +""" + ±(m, r) + m ± r + +Create the interval ``[m - r, m + r]`` according to the IEEE Standard 1788-2015. +Despite using the midpoint-radius notation, the returned interval is still an +[`Interval`](@ref) represented by its bounds. + +!!! warning + Nothing is done to compensate for the fact that floating point literals are + 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) and [`@I_str`](@ref). + +# Examples +```jldoctest +julia> using IntervalArithmetic + +julia> using IntervalArithmetic.Symbols + +julia> setdisplay(:full); + +julia> 0 ± π +Interval{Float64}(-3.1415926535897936, 3.1415926535897936, com) + +julia> 0//1 ± π +Interval{Rational{Int64}}(-85563208//27235615, 85563208//27235615, com) +``` +""" +±(m, r) = interval(m, r; format = :midpoint) """ ≛(a, b) Unicode alias of [`isequal_interval`](@ref). """ -const ≛ = isequal_interval +≛ = isequal_interval """ ≺(a, b) Unicode alias of [`strictprecedes`](@ref). """ -const ≺ = strictprecedes +≺ = strictprecedes """ ⪽(a, b) Unicode alias of [`isstrictsubset_interval`](@ref). """ -const ⪽ = isstrictsubset_interval +⪽ = isstrictsubset_interval """ ∅ diff --git a/test/Project.toml b/test/Project.toml index 86a9a3eba..2c7156f6f 100644 --- a/test/Project.toml +++ b/test/Project.toml @@ -1,5 +1,4 @@ [deps] -LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" -Polynomials = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" diff --git a/test/decoration_tests/decoration_tests.jl b/test/decoration_tests/decoration_tests.jl deleted file mode 100644 index ac4e1fefc..000000000 --- a/test/decoration_tests/decoration_tests.jl +++ /dev/null @@ -1,65 +0,0 @@ -using Test -using IntervalArithmetic - -let b - -@testset "DecoratedInterval tests" begin - a = DecoratedInterval(interval(1, 2), com) - @test decoration(a) == com - - b = sqrt(a) - @test isequal_interval(interval(b), sqrt(interval(a))) - @test decoration(b) == com - - a = DecoratedInterval(interval(-1, 1), com) - b = sqrt(a) - @test isequal_interval(interval(b), sqrt(interval(0, 1))) - @test decoration(b) == trv - - d = DecoratedInterval(a, dac) - @test decoration(d) == dac - - @test decoration(DecoratedInterval(1.1)) == com - @test decoration(DecoratedInterval(1.1, dac)) == dac - - @test decoration(DecoratedInterval(2, 0.1, com)) == ill - @test decoration(DecoratedInterval(2, 0.1)) == ill - @test isnai(DecoratedInterval(2, 0.1)) - @test decoration(DecoratedInterval(big(2), big(1))) == ill - @test isnai((DecoratedInterval(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) - - # Tests related to powers of decorated Intervals - @test isequal_interval(DecoratedInterval(2, 3) ^ 2, DecoratedInterval(4, 9)) - @test isequal_interval(DecoratedInterval(2, 3) ^ -2, DecoratedInterval(1/9,1/4)) - @test isequal_interval(DecoratedInterval(-3, 2) ^ 3, DecoratedInterval(-27, 8)) - @test isequal_interval(DecoratedInterval(-3, -2) ^ -3, DecoratedInterval(-1/8, -1/27)) - @test isequal_interval(DecoratedInterval(0, 3) ^ 2, DecoratedInterval(0, 9)) - @test isequal_interval(DecoratedInterval(0, 3) ^ -2, DecoratedInterval(1/9, Inf, trv)) - @test isequal_interval(DecoratedInterval(2, 3)^interval(0, 1), DecoratedInterval(1, 3)) - @test isequal_interval(DecoratedInterval(2, 3)^DecoratedInterval(0, 1), DecoratedInterval(1, 3)) - @test isequal_interval(DecoratedInterval(0, 2)^interval(0, 1), DecoratedInterval(0, 2, trv)) - @test isequal_interval(DecoratedInterval(0, 2)^DecoratedInterval(0, 1), DecoratedInterval(0, 2, trv)) - @test isequal_interval(DecoratedInterval(-3, 2)^interval(0, 1), DecoratedInterval(0, 2, trv)) - @test isequal_interval(DecoratedInterval(-3, 2)^DecoratedInterval(0, 1), DecoratedInterval(0, 2, trv)) - @test isequal_interval(DecoratedInterval(-3, 2)^interval(-1, 1), DecoratedInterval(0, Inf, trv)) - @test isequal_interval(DecoratedInterval(-3, 2)^DecoratedInterval(-1, 1), DecoratedInterval(0, Inf, trv)) - - a = DecoratedInterval(1, 2) - b = DecoratedInterval(3, 4) - - @test dist(a, b) == 2.0 - - # invalid input - @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 diff --git a/test/display_tests/display.jl b/test/display_tests/display.jl deleted file mode 100644 index 59cd887df..000000000 --- a/test/display_tests/display.jl +++ /dev/null @@ -1,195 +0,0 @@ -using Test -using IntervalArithmetic - -let x, b - -@testset "setformat tests" begin - @testset "Interval" begin - a = interval(1, 2) - b = interval(-1.1, 1.3) - c = interval(π) - # large_expo = IntervalArithmetic.atomic(Interval{BigFloat}, -Inf) - # Use smaller exponent, cf. JuliaLang/julia#48678 - large_expo = interval(0, big"1e123456789") - - @testset "6 significant digits" begin - setformat(:standard; sigdigits = 6) - - @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]" - @test sprint(show, MIME("text/plain"), b) == "[-1.10001, 1.30001]" - @test sprint(show, MIME("text/plain"), c) == "[3.14159, 3.1416]" - @test sprint(show, MIME("text/plain"), large_expo) == - "[0.0, 1.00001e+123456789]₂₅₆" - end - - @testset "10 significant digits" begin - setformat(; sigdigits = 10) - - @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]" - @test sprint(show, MIME("text/plain"), b) == "[-1.100000001, 1.300000001]" - @test sprint(show, MIME("text/plain"), c) == "[3.141592653, 3.141592654]" - @test sprint(show, MIME("text/plain"), large_expo) == - "[0.0, 1.000000001e+123456789]₂₅₆" - end - - @testset "20 significant digits" begin - setformat(; sigdigits = 20) - - @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]" - @test sprint(show, MIME("text/plain"), b) == "[-1.1000000000000000889, 1.3000000000000000445]" - @test sprint(show, MIME("text/plain"), c) == "[3.1415926535897931159, 3.1415926535897935601]" - @test sprint(show, MIME("text/plain"), large_expo) == - "[0.0, 1.0000000000000000001e+123456789]₂₅₆" - end - - @testset "Full" begin - setformat(:full) - - @test sprint(show, MIME("text/plain"), a) == "Interval{Float64}(1.0, 2.0)" - @test sprint(show, MIME("text/plain"), b) == "Interval{Float64}(-1.1, 1.3)" - @test sprint(show, MIME("text/plain"), c) == "Interval{Float64}(3.141592653589793, 3.1415926535897936)" - @test sprint(show, MIME("text/plain"), large_expo) == - "Interval{BigFloat}(0.0, 1.000000000000000000000000000000000000000000000000000000000000000000000000000004e+123456789)" - end - - @testset "Midpoint" begin - setformat(:midpoint; sigdigits = 6) - - @test sprint(show, MIME("text/plain"), a) == "1.5 ± 0.5" - @test sprint(show, MIME("text/plain"), b) == "0.1 ± 1.20001" - @test sprint(show, MIME("text/plain"), c) == "3.14159 ± 4.4409e-16" - @test sprint(show, MIME("text/plain"), large_expo) == "(5.0e+123456788 ± 5.00001e+123456788)₂₅₆" - - # issue 175: - @test sprint(show, MIME("text/plain"), interval(BigFloat, 1, 2)) == "(1.5 ± 0.5)₂₅₆" - end - end - - @testset "Interval{Rational{T}}" begin - a = interval(Rational{Int}, 1//3, 5//4) - @test typeof(a) == Interval{Rational{Int}} - - setformat(:standard) - @test sprint(show, MIME("text/plain"), a) == "[1//3, 5//4]" - - setformat(:full) - @test sprint(show, MIME("text/plain"), a) == string(typeof(a), "(1//3, 5//4)") - - setformat(:midpoint) - @test sprint(show, MIME("text/plain"), a) == "19//24 ± 11//24" - end - - @testset "Interval{Float32}" begin - a = interval(Float32, 1, 2) - b = interval(Float32, -1, Inf) - - setformat(:standard) - @test sprint(show, MIME("text/plain"), a) == "[1.0f0, 2.0f0]" - @test sprint(show, MIME("text/plain"), b) == "[-1.0f0, ∞]" - - setformat(:full) - @test sprint(show, MIME("text/plain"), a) == "Interval{Float32}(1.0f0, 2.0f0)" - @test sprint(show, MIME("text/plain"), b) == "Interval{Float32}(-1.0f0, Inf32)" - - setformat(:midpoint) - @test sprint(show, MIME("text/plain"), a) == "1.5f0 ± 0.5f0" - end - - @testset "Complex{Interval}" begin - a = Complex(interval(0, 2), interval(1)) - @test typeof(a) == Complex{Interval{Float64}} - - setformat(:standard) - @test sprint(show, MIME("text/plain"), a) == "[0.0, 2.0] + [1.0, 1.0]im" - - setformat(:midpoint) - @test sprint(show, MIME("text/plain"), a) == "(1.0 ± 1.0) + (1.0 ± 0.0)im" - end - - setprecision(BigFloat, 256) - - @testset "DecoratedInterval" begin - a = DecoratedInterval(1, 2) - @test typeof(a) == DecoratedInterval{Float64} - - setformat(:standard; decorations = false) - @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]" - - setformat(; decorations = true) - @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]_com" - - setformat(:midpoint; decorations = true) - @test sprint(show, MIME("text/plain"), a) == "(1.5 ± 0.5)_com" - - # issue 131: - a = DecoratedInterval(big(2), big(3), com) - - setformat(:standard; decorations = false) - @test sprint(show, MIME("text/plain"), a) == "[2.0, 3.0]₂₅₆" - - setformat(; decorations = true) - @test sprint(show, MIME("text/plain"), a) == "[2.0, 3.0]₂₅₆_com" - - setformat(:full) - @test sprint(show, MIME("text/plain"), a) == "DecoratedInterval(Interval{BigFloat}(2.0, 3.0), com)" - - setformat(:midpoint) - @test sprint(show, MIME("text/plain"), a) == "(2.5 ± 0.5)₂₅₆_com" - - setformat(; decorations = false) - @test sprint(show, MIME("text/plain"), a) == "(2.5 ± 0.5)₂₅₆" - end - - setprecision(BigFloat, 128) - - @testset "BigFloat intervals" begin - a = interval(big(1)) - @test typeof(a) == Interval{BigFloat} - - setformat(:standard; decorations = false) - @test sprint(show, MIME("text/plain"), a) == "[1.0, 1.0]₁₂₈" - - setformat(:full) - @test sprint(show, MIME("text/plain"), a) == "Interval{BigFloat}(1.0, 1.0)" - - a = DecoratedInterval(big(2), big(3), com) - @test typeof(a) == DecoratedInterval{BigFloat} - - setformat(:standard; decorations = false) - @test sprint(show, MIME("text/plain"), a) == "[2.0, 3.0]₁₂₈" - - setformat(:standard; decorations = true) - @test sprint(show, MIME("text/plain"), a) == "[2.0, 3.0]₁₂₈_com" - - setformat(:full) - @test sprint(show, MIME("text/plain"), a) == "DecoratedInterval(Interval{BigFloat}(2.0, 3.0), com)" - end -end - -@testset "show" begin - setformat(:standard; decorations = false, sigdigits = 6) - setprecision(BigFloat, 128) - - x = interval(0, 1) - @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]" - @test sprint(show, x) == "Interval{Float64}(0.0, 1.0)" - - 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)" - - x = DecoratedInterval(0, 1, dac) - @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]" - @test sprint(show, x) == "DecoratedInterval(Interval{Float64}(0.0, 1.0), dac)" - - x = DecoratedInterval(big(0), big(1), def) - @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]₁₂₈" - @test sprint(show, x) == "DecoratedInterval(Interval{BigFloat}(0.0, 1.0), def)" - - setformat(; decorations = true) - @test sprint(show, MIME("text/plain"), x) == "[0.0, 1.0]₁₂₈_def" -end - -setprecision(BigFloat, 256) - -end diff --git a/test/interval_tests/bisect.jl b/test/interval_tests/bisect.jl index b59ac93eb..e73f7a26b 100644 --- a/test/interval_tests/bisect.jl +++ b/test/interval_tests/bisect.jl @@ -1,39 +1,13 @@ -using Test -using IntervalArithmetic - -@testset "`bisect` function" begin - X = interval(0, 1) - @test all(isequal_interval.(bisect(X, 0.5), (interval(0, 0.5), interval(0.5, 1)))) - @test all(isequal_interval.(bisect(X, 0.25), (interval(0, 0.25), interval(0.25, 1)))) - - @test all(isequal_interval.(bisect(X), (interval(0.0, 0.49609375), interval(0.49609375, 1.0)))) - - X = interval(-Inf, Inf) - @test all(isequal_interval.(bisect(X, 0.5), (interval(-Inf, 0), interval(0, Inf)))) - B = bisect(X, 0.75) - @test B[1].hi > 0 - @test B[1].hi == B[2].lo - B = bisect(X, 0.25) - @test B[1].hi < 0 - @test B[1].hi == B[2].lo - - X = [interval(0, 1), interval(0, 2)] - - tuple_starequal(x, y) = all(isequal_interval.(x, y)) - - @test all(tuple_starequal.(bisect(X, 2, 0.5), - ([interval(0, 1), interval(0, 1)], [interval(0, 1), interval(1, 2)]))) - @test all(tuple_starequal.(bisect(X, 2, 0.25), - ([interval(0, 1), interval(0, 0.5)], [interval(0, 1), interval(0.5, 2)]))) - @test all(tuple_starequal.(bisect(X, 1, 0.5), - ([interval(0, 0.5), interval(0, 2)], [interval(0.5, 1), interval(0, 2)]))) - @test all(tuple_starequal.(bisect(X, 1, 0.25), - ([interval(0, 0.25), interval(0, 2)], [interval(0.25, 1), interval(0, 2)]))) - - @test all(tuple_starequal.(bisect(X, 2), - ([interval(0, 1), interval(0.0, 0.9921875)], [interval(0, 1), interval(0.9921875, 2.0)]))) - - X = [interval(-Inf, Inf), interval(-Inf, Inf)] - @test all(tuple_starequal.(bisect(X, 1, 0.5), - ([interval(-Inf, 0), interval(-Inf, Inf)], [interval(0, Inf), interval(-Inf, Inf)]))) +@testset "Interval" begin + x = interval(0, 1) + @test all(isequal_interval.( bisect(x, 0.5), (interval(0, 0.5), interval(0.5, 1) ) )) + @test all(isequal_interval.( bisect(x, 0.25), (interval(0, 0.25), interval(0.25, 1) ) )) + @test all(isequal_interval.( bisect(x), (interval(0.0, 0.49609375), interval(0.49609375, 1.0)) )) + + x = interval(-Inf, Inf) + @test all(isequal_interval.( bisect(x, 0.5), (interval(-Inf, 0), interval(0, Inf)) )) + y = bisect(x, nextfloat(0.5)) + @test sup(y[1]) == inf(y[2]) > 0 + y = bisect(x, prevfloat(0.5)) + @test sup(y[1]) == inf(y[2]) < 0 end diff --git a/test/interval_tests/complex.jl b/test/interval_tests/complex.jl index aa4991565..b4be89011 100644 --- a/test/interval_tests/complex.jl +++ b/test/interval_tests/complex.jl @@ -1,10 +1,7 @@ -using Test -using IntervalArithmetic - @testset "Complex interval operations" begin a = interval(1im) b = interval(4im + 3) - c = interval(-1, 4) + interval(0, 2)*im + c = interval(-1, 4) + interval(0, 2)*interval(im) @test a ⊂ c @test a ⊆ c @@ -13,33 +10,33 @@ using IntervalArithmetic @test (b ⊆ c) == false @test typeof(a) == Complex{Interval{Float64}} - @test a == interval(0) + interval(1)*im + @test a == interval(0) + interval(1)*interval(im) @test a * a == interval(-1) - @test a + a == interval(2)*im + @test a + a == interval(2)*interval(im) @test a - a == 0 @test a / a == 1 @test 3+2im ∈ c - @test a ∪ b == interval(0, 3) + interval(1, 4)*im - @test c ∩ (a ∪ b) == interval(0, 3) + interval(1, 2)*im - @test a ∩ b == emptyinterval() + emptyinterval()*im + @test a ∪ b == interval(0, 3) + interval(1, 4)*interval(im) + @test c ∩ (a ∪ b) == interval(0, 3) + interval(1, 2)*interval(im) + @test a ∩ b == emptyinterval() + emptyinterval()*interval(im) @test isdisjoint(a,b) == true end @testset "Complex functions" begin - Z = (3 ± 1e-7) + (4 ± 1e-7)*im + Z = (3 ± 1e-7) + (4 ± 1e-7)*interval(im) @test sin(Z) == complex(sin(real(Z)) * cosh(imag(Z)), sinh(imag(Z)) * cos(real(Z))) z = exp(-im * interval(π)) @test -1 in real(z) @test 0 in imag(z) sZ = sqrt(Z) - @test sZ == interval(1.99999996999999951619,2.00000003000000070585) + interval(0.99999996999999984926,1.00000003000000048381)*im - @test sqrt(-Z) == imag(sZ) - real(sZ)*im + @test sZ == interval(1.99999996999999951619,2.00000003000000070585) + interval(0.99999996999999984926,1.00000003000000048381)*interval(im) + @test sqrt(-Z) == imag(sZ) - real(sZ)*interval(im) - @test sqrt(interval(-1, 0) + interval(0)*im) .== interval(0, 1)*im - @test sqrt(interval(-1, 1) + interval(0)*im) .== interval(0, 1) + interval(0, 1)*im - @test sqrt(interval(-9//32, Inf)*im) .== interval(0, Inf) + interval(-3//8, Inf)*im + @test sqrt(interval(-1, 0) + interval(0)*interval(im)) .== interval(0, 1)*interval(im) + @test sqrt(interval(-1, 1) + interval(0)*interval(im)) .== interval(0, 1) + interval(0, 1)*interval(im) + @test sqrt(interval(-9//32, Inf)*interval(im)) .== interval(0, Inf) + interval(-3//8, Inf)*interval(im) end @@ -54,17 +51,17 @@ end end @testset "abs2 and abs" begin - x = interval(0, 3) +interval(0, 4)*im + x = interval(0, 3) +interval(0, 4)*interval(im) @test abs2(x) == interval(0, 25) @test abs(x) == norm(x) == interval(0, 5) - y = interval(-1, 1) + interval(-2, 2)*im + y = interval(-1, 1) + interval(-2, 2)*interval(im) @test abs(y).lo == 0.0 @test abs2(y).lo == 0.0 end @testset "real functions" begin - x = interval(0, 3) + interval(0, 4)*im + x = interval(0, 3) + interval(0, 4)*interval(im) @test mag(x) == 5 @test mig(x) == 0 @test mid(x) == 1.5 + 2im diff --git a/test/interval_tests/consistency.jl b/test/interval_tests/consistency.jl index 8554737af..412649e8c 100644 --- a/test/interval_tests/consistency.jl +++ b/test/interval_tests/consistency.jl @@ -1,6 +1,4 @@ -using Test -using IntervalArithmetic -import IntervalArithmetic: unsafe_interval +@test size(interval(1)) == () # match the `size` behaviour of `Real` @testset "Consistency tests" begin @@ -25,16 +23,16 @@ import IntervalArithmetic: unsafe_interval @test isequal_interval(typemin(a), typemin(typeof(a))) @test isequal_interval(typemax(a), typemax(typeof(a))) - @test isequal_interval(a, interval(a.lo, a.hi)) + @test isequal_interval(a, interval(inf(a), sup(a))) @test isequal_interval(emptyinterval(Rational{Int}), emptyinterval()) - @test (zero(a) + one(b)).lo == 1 - @test (zero(a) + one(b)).hi == 1 + @test inf(zero(a) + one(b)) == 1 + @test sup(zero(a) + one(b)) == 1 @test isequal_interval(interval(0,1) + emptyinterval(a), emptyinterval(a)) - @test isequal_interval(interval(0.25) - one(c)/4, zero(c)) + @test isequal_interval(interval(0.25) - one(c)/interval(4), zero(c)) @test isequal_interval(emptyinterval(a) - interval(0, 1), emptyinterval(a)) @test isequal_interval(interval(0, 1) - emptyinterval(a), emptyinterval(a)) - @test isequal_interval(a*b, interval(*(a.lo, b.lo, RoundDown), *(a.hi, b.hi, RoundUp))) + @test isequal_interval(a*b, interval(*(inf(a), inf(b), RoundDown), *(sup(a), sup(b), RoundUp))) @test isequal_interval(interval(0, 1) * emptyinterval(a), emptyinterval(a)) @test isequal_interval(a * interval(0), zero(a)) end @@ -115,15 +113,15 @@ import IntervalArithmetic: unsafe_interval end @testset "Intersection tests" begin - @test isequal_interval(emptyinterval(), interval(Inf, -Inf)) + @test isequal_interval(emptyinterval(BareInterval{Float64}), bareinterval(Inf, -Inf)) @test isequal_interval(intersect_interval(a, interval(-1)), emptyinterval(a)) @test isempty_interval(intersect_interval(a, interval(-1))) @test !isempty_interval(a) @test !isequal_interval(emptyinterval(a), a) @test isequal_interval(emptyinterval(), emptyinterval()) - @test isequal_interval(intersect_interval(a, hull(a,b)), a) - @test isequal_interval(hull(a,b), interval(a.lo, b.hi)) + @test isequal_interval(intersect_interval(a, hull(a, b)), a) + @test isequal_interval(hull(a, b), interval(inf(a), sup(b))) # n-ary intersect_interval @test isequal_interval(intersect_interval(interval(1.0, 2.0), @@ -149,13 +147,13 @@ import IntervalArithmetic: unsafe_interval @test isstrictsubset_interval(interval(-Inf, Inf), interval(-Inf, Inf)) @test !isequal_interval(nai(a), nai(a)) - @test isnai(DecoratedInterval(NaN)) - @test isnan(interval(nai(BigFloat)).lo) + @test isnai(interval(NaN)) & isnai(convert(Interval{Float64}, NaN)) + @test isnan(inf(nai(BigFloat))) @test isnai(nai()) @test !isnai(a) - @test inf(a) == a.lo - @test sup(a) == a.hi + @test inf(a) == bareinterval(a).lo + @test sup(a) == bareinterval(a).hi @test inf(emptyinterval(a)) == Inf @test sup(emptyinterval(a)) == -Inf @test inf(entireinterval(a)) == -Inf @@ -204,7 +202,7 @@ import IntervalArithmetic: unsafe_interval @test mig(interval(-2, 2)) == BigFloat(0.0) @test mig( interval(Rational{Int}, 1//2) ) == 1//2 @test isnan(mig(emptyinterval())) - @test mag(-b) == b.hi + @test mag(-b) == sup(b) @test mag( interval(Rational{Int}, 1//2) ) == 1//2 @test isnan(mag(emptyinterval())) end @@ -238,12 +236,12 @@ import IntervalArithmetic: unsafe_interval @test isequal_interval(cancelplus(interval(0.0), interval(1.0)), interval(1.0)) @test isequal_interval(cancelminus(interval(-5.0, 0.0), interval(0.0, 5.0)), interval(-5.0)) @test isequal_interval(cancelplus(interval(-5.0, 0.0), interval(0.0, 5.0)), interval(0.0)) - @test isequal_interval(cancelminus(interval(1e308), -interval(1e308)), IntervalArithmetic.atomic(Float64, Inf)) - @test isequal_interval(cancelplus(interval(1e308), interval(1e308)), IntervalArithmetic.atomic(Float64, Inf)) - @test isequal_interval(cancelminus(interval(nextfloat(1e308)), -interval(nextfloat(1e308))), IntervalArithmetic.atomic(Float64, Inf)) - @test isequal_interval(cancelplus(interval(nextfloat(1e308)), interval(nextfloat(1e308))), IntervalArithmetic.atomic(Float64, Inf)) - @test isequal_interval(cancelminus(interval(prevfloat(big(Inf))), -interval(prevfloat(big(Inf)))), IntervalArithmetic.atomic(BigFloat, Inf)) - @test isequal_interval(cancelplus(interval(prevfloat(big(Inf))), interval(prevfloat(big(Inf)))), IntervalArithmetic.atomic(BigFloat, Inf)) + @test isequal_interval(cancelminus(bareinterval(1e308), -bareinterval(1e308)), IntervalArithmetic.atomic(Float64, Inf)) + @test isequal_interval(cancelplus(bareinterval(1e308), bareinterval(1e308)), IntervalArithmetic.atomic(Float64, Inf)) + @test isequal_interval(cancelminus(bareinterval(nextfloat(1e308)), -bareinterval(nextfloat(1e308))), IntervalArithmetic.atomic(Float64, Inf)) + @test isequal_interval(cancelplus(bareinterval(nextfloat(1e308)), bareinterval(nextfloat(1e308))), IntervalArithmetic.atomic(Float64, Inf)) + @test isequal_interval(cancelminus(bareinterval(prevfloat(big(Inf))), -bareinterval(prevfloat(big(Inf)))), IntervalArithmetic.atomic(BigFloat, Inf)) + @test isequal_interval(cancelplus(bareinterval(prevfloat(big(Inf))), bareinterval(prevfloat(big(Inf)))), IntervalArithmetic.atomic(BigFloat, Inf)) end @testset "mid and radius" begin @@ -306,7 +304,7 @@ import IntervalArithmetic: unsafe_interval @test isatomic(interval(1)) @test isatomic(interval(2.3, 2.3)) @test isatomic(emptyinterval()) - @test isatomic(interval(Inf)) # interval(floatmax(), Inf) + @test isnai(interval(Inf)) @test !isatomic(interval(1, 2)) @test !isatomic(interval(1, nextfloat(1.0, 2))) @@ -324,16 +322,6 @@ import IntervalArithmetic: unsafe_interval @test !isthinzero(interval(0.0, nextfloat(0.0))) end - @testset "Difference between checked and unchecked Intervals" begin - @test isequal_interval(unsafe_interval(Float64, 1, 2), interval(Float64, 1, 2)) - - @test inf(unsafe_interval(Float64, 3, 2)) == 3 - @test_logs (:warn,) @test isempty_interval(interval(3, 2)) - - @test sup(unsafe_interval(Float64, Inf, Inf)) == Inf - @test_logs (:warn,) @test isempty_interval(interval(Inf, Inf)) - end - @testset "Type stability" begin for T in (Float32, Float64, BigFloat) @@ -363,7 +351,7 @@ import IntervalArithmetic: unsafe_interval @test_throws ArgumentError isdisjoint(x, y) @test_throws ArgumentError issubset(x, y) @test_throws ArgumentError issetequal(x, y) - @test_throws ArgumentError x in y + @test_throws ArgumentError x ∈ y @test_throws ArgumentError isempty(x) @test_throws ArgumentError isfinite(x) @test_throws ArgumentError isnan(x) @@ -371,3 +359,39 @@ import IntervalArithmetic: unsafe_interval end end + +@testset "Zero interval" begin + @test isequal_interval(zero(Interval{Float64}), interval(0)) + @test isequal_interval(zero(interval(0, 1)), interval(0)) +end + +@testset "Decorations" begin + a = interval(1, 2) + b = interval(3, 4) + + @test dist(a, b) == 2.0 + + @test isnai(interval(3, 1)) + @test isnai(interval(Inf, Inf)) + @test isnai(interval(-Inf, -Inf)) + @test isnai(interval(NaN, NaN)) + @test isnai(interval(NaN, 3)) + @test isnai(interval(3, NaN)) +end + +@testset "Hashing of Intervals" begin + x = interval(Float64, 1, 2) + y = interval(BigFloat, 1, 2) + @test isequal_interval(x, y) + @test hash(x) == hash(y) + + x = I"0.1" + y = interval(BigFloat, x) + @test isequal_interval(x, y) + @test hash(x) == hash(y) + + x = interval(1, 2) + y = interval(1, 3) + @test !isequal_interval(x, y) + @test hash(x) != hash(y) +end diff --git a/test/interval_tests/construction.jl b/test/interval_tests/construction.jl index 024a9bab6..983ded562 100644 --- a/test/interval_tests/construction.jl +++ b/test/interval_tests/construction.jl @@ -1,281 +1,155 @@ -using Test -using IntervalArithmetic -import IntervalArithmetic: unsafe_interval +@testset "Difference between checked and unchecked Intervals" begin + @test isequal_interval(IntervalArithmetic._unsafe_bareinterval(Float64, 1, 2), bareinterval(1, 2)) -@testset "Constructing intervals" begin - # Naive constructors, with no conversion involved - @test isequal_interval(interval(Float64, 1.0, 1.0), interval(1)) - @test isequal_interval(interval(1), interval(interval(1.0))) - @test isequal_interval(interval(interval(1.0)), interval(Float64, interval(1.0))) - @test size(interval(1)) == () # Match the `size` behaviour of `Number` - @test isequal_interval(interval(big(1)), interval(Float64, 1.0, 1.0)) - @test isequal_interval(interval(Rational{Int}, 1//10), interval(Rational{Int}, 1//10, 1//10)) - @test isequal_interval(interval(Rational{BigInt}, BigInt(1)//10), interval(Rational{BigInt}, 1//10, 1//10)) - @test isequal_interval(interval( (1.0, 2.0) ), interval(Float64, 1.0, 2.0)) - @test isequal_interval(interval(BigFloat, 1), interval(BigFloat, big(1.0), big(1.0))) + @test inf(IntervalArithmetic._unsafe_bareinterval(Float64, 3, 2)) == 3 + @test isnai(interval(3, 2)) - # constructing interval with `Interval` fails - @test_throws MethodError Interval(1, 2) - @test_throws MethodError Interval{Float64}(1.0, 2.0) - - # Irrational - for irr in (π, ℯ) - @test isequal_interval(interval(0, irr), hull(interval(0), interval(irr))) - @test isequal_interval(interval(irr), interval(irr, irr)) - @test isequal_interval(interval(irr, irr), interval(Float64, irr)) - @test isequal_interval(interval(Float32, irr, irr), interval(Float32, irr)) - end - - @test isequal_interval(interval(ℯ, big(4)), hull(interval(BigFloat, ℯ), interval(4))) - @test isequal_interval(interval(π, big(4)), hull(interval(BigFloat, π), interval(4))) - - @test isequal_interval(interval(ℯ, π), hull(interval(ℯ), interval(Float64, π))) - @test in_interval(big(ℯ), interval(ℯ, π)) - @test in_interval(big(π), interval(ℯ, π)) - @test in_interval(big(ℯ), interval(0, ℯ)) - @test in_interval(big(π), interval(π, 4)) - - @test in_interval(big(ℯ), interval(Float32, ℯ, π)) - @test in_interval(big(π), interval(Float32, ℯ, π)) - @test in_interval(big(ℯ), interval(Float32, 0, ℯ)) - @test in_interval(big(π), interval(Float32, π, 4)) - - @test isequal_interval(interval(interval(π)), interval(π)) - @test isequal_interval(interval(unsafe_interval(Float64, NaN, -Inf)), emptyinterval()) - - # with rational - @test isequal_interval(interval(1//2), I"0.5") - @test isequal_interval(I"0.5", interval(0.5)) - @test isequal_interval(parse(Interval{Rational{Int64}}, "0.1"), interval(Rational{Int64}, 1//10, 1//10)) - @test isequal_interval(parse(Interval{Rational{Int64}}, "[0.1, 0.3]"), interval(Rational{Int64}, 1//10, 3//10)) - - # a < Inf and b > -Inf - @test isequal_interval(I"1e300", unsafe_interval(Float64, 9.999999999999999e299, 1.0e300)) - @test isequal_interval(I"-1e307", unsafe_interval(Float64, -1.0000000000000001e307, -1.0e307)) - - # Disallowed construction with a > b - @test_logs (:warn,) @test isempty_interval(interval(2, 1)) - @test_logs (:warn,) @test isempty_interval(interval(big(2), big(1))) - @test_logs (:warn,) @test isempty_interval(interval(big(1), 1//10)) - @test_logs (:warn,) @test isempty_interval(interval(1, 0.1)) - @test_logs (:warn,) @test isempty_interval(interval(big(1), big(0.1))) - @test_logs (:warn,) @test isempty_interval(interval(Inf)) - @test_logs (:warn,) @test isempty_interval(interval(-Inf, -Inf)) - @test_logs (:warn,) @test isempty_interval(interval(Inf, Inf)) - - # Conversion to Interval without type - @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 isequal_interval(convert(Interval, interval(Float64, 0.1, 0.2)), interval(Float64, 0.1, 0.2)) - - a = I"0.1" - b = interval(π) - - @test typeof(a) == Interval{Float64} - @test nextfloat(a.lo) == a.hi - @test isequal_interval(b, interval(π)) - @test nextfloat(b.lo) == b.hi - x = typemax(Int64) - @test !isthin(interval(x)) - - a = I"[0.1, 0.2]" - b = interval(0.1, 0.2) - - @test issubset_interval(b, a) - - # TODO Actually use the rounding mode here - for rounding in (:wide, :narrow) - a = interval(0.1, 0.2) - @test issubset_interval(a, interval(0.09999999999999999, 0.20000000000000004)) - - b = interval(0.1) - @test issubset_interval(b, interval(0.09999999999999999, 0.10000000000000002)) - @test issubset_interval(b, interval(0.09999999999999999, 0.20000000000000004)) - @test issubset_interval(float(b), a) - - c = I"[0.1, 0.2]" - @test issubset_interval(a, c) # a is narrower than c - @test isequal_interval(interval(1//2), interval(0.5)) - @test interval(1//10).lo == rationalize(0.1) - end - - @test string(emptyinterval()) == "∅" -end - -# Issue 502 -@testset "Corner case for enclosure" begin - # 0.100000000000000006 Round down to 0.1 for Float64 - @test in_interval(BigFloat("0.100000000000000006"), I"0.100000000000000006") -end - -@testset "Big intervals" begin - a = interval(3) - @test typeof(a)== Interval{Float64} - @test typeof(big(a)) == Interval{BigFloat} - - @test isequal_interval(I"123412341234123412341241234", interval(1.234123412341234e26, 1.2341234123412342e26)) - @test isequal_interval(interval(big"3"), interval(3)) - - @test isequal_interval(interval(Float64, big"1e10000"), interval(prevfloat(Inf), Inf)) - - a = big(10)^10000 - @test isequal_interval(interval(Float64, a), interval(prevfloat(Inf), Inf)) -end - -#= -@testset "Complex intervals" begin - a = @floatinterval(3 + 4im) - @test typeof(a) == Complex{Interval{Float64}} - @test a, Interval(3) + im*Interval(4) - - # b = exp(a) - # @test real(b) == Interval(-13.12878308146216, -13.128783081462153) - # @test imag(b) == Interval(-15.200784463067956, -15.20078446306795) -end -=# - -@testset ".. tests" begin - a = IntervalArithmetic.Symbols.:(..)(big(0.1), 2) - @test typeof(a) == Interval{BigFloat} - - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(2, 1)) - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(π, 1)) - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(π, ℯ)) - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(4, π)) - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(NaN, 3)) - @test_logs (:warn, ) @test isempty_interval(IntervalArithmetic.Symbols.:(..)(3, NaN)) - @test isequal_interval(IntervalArithmetic.Symbols.:(..)(1, π), interval(Float64, 1, π)) -end - -@testset "± tests" begin - @test isequal_interval(3 ± 1, interval(Float64, 2.0, 4.0)) - @test isequal_interval(3 ± 0.5, interval(2.5, 3.5)) - @test isequal_interval(3 ± 0.1, interval(2.9, 3.1)) - @test isequal_interval(0.5 ± 1, interval(-0.5, 1.5)) - - # issue 172: - @test isequal_interval(interval(1, 1) ± 1, interval(0, 2)) -end - -@testset "Conversion to interval of same type" begin - x = interval(3, 4) - @test isequal_interval(convert(Interval{Float64}, x), x) - - x = interval(big(3), big(4)) - @test isequal_interval(convert(Interval{BigFloat}, x), x) + @test sup(IntervalArithmetic._unsafe_bareinterval(Float64, Inf, Inf)) == Inf + @test isnai(interval(Inf, Inf)) end -@testset "Promotion between intervals" begin - x = interval(Float64, π) - y = interval(BigFloat, π) - x_, y_ = promote(x, y) - - @test promote_type(typeof(x), typeof(y)) == Interval{BigFloat} - @test bounds(x_) == (BigFloat(inf(x), RoundDown), BigFloat(sup(x), RoundUp)) - @test isequal_interval(y_, y) -end - -@testset "Typed intervals" begin +@testset "Basics" begin @test typeof(interval(1, 2)) == Interval{Float64} - @test typeof(interval(Float64, 1, 2)) == Interval{Float64} - @test typeof(interval(Float32, 1, 2)) == Interval{Float32} - @test typeof(interval(Float16, 1, 2)) == Interval{Float16} - - # PR 496 + @test typeof(big(interval(1, 2))) == Interval{BigFloat} + for T ∈ (Float16, Float32, Float64, BigFloat) + @test typeof(interval(T, 1, 2)) == Interval{T} + end + for T ∈ [InteractiveUtils.subtypes(Signed) ; InteractiveUtils.subtypes(Unsigned)] + @test typeof(interval(Rational{T}, 1, 2)) == Interval{Rational{T}} + end @test eltype(interval(1, 2)) == Interval{Float64} @test IntervalArithmetic.numtype(interval(1, 2)) == Float64 - @test all(isequal_interval.([1 2; 3 4] * interval(-1, 1), [interval(-1, 1) interval(-2, 2) ; interval(-3, 3) interval(-4, 4)])) -end - -@testset "Conversions between different types of interval" begin - a = convert(Interval{BigFloat}, interval(3, 4)) - @test typeof(a) == Interval{BigFloat} - - a = convert(Interval{Float64}, interval(BigFloat, 3, 4)) - @test typeof(a) == Interval{Float64} - - pi64, pi32 = interval(Float64, pi), interval(Float32, pi) - x, y = promote(pi64, pi32) - @test isequal_interval(x, pi64) - @test isequal_interval(y, Interval{Float64}(pi32)) -end + @test typeof(interval(BigInt(1), 11//10)) == Interval{Rational{BigInt}} -@testset "Interval{T} constructor" begin - @test isequal_interval(interval(Float64, 1, 1), interval(1)) - # no rounding - @test bounds(interval(Float64, 1.1, 1.1)) == (1.1, 1.1) + @test inf(interval(1, 2)) == 1 && sup(interval(1, 2)) == 2 - @test bounds(interval(BigFloat, big"1.1", big"1.1")) == (big"1.1", big"1.1") -end + @test isequal_interval( + interval(Float64, 1, 1), interval(Float64, 1), interval(1), + interval(Float64, interval(1)), interval(interval(1)), + interval(BigFloat, 1, 1), interval(BigFloat, 1), interval(big(1)), + interval( (Float64, 1, 1) ), interval( (1, 1) ), interval( (Float64, 1) ), interval( (1,) )) -# issue 206: -@testset "Interval strings" begin - a = I"[2/3, 1.1]" - b = interval(0.6666666666666666, 1.1) - @test isequal_interval(a, b) + @test isequal_interval( + interval(Rational{Int}, 1//10, 1//10), interval(1//10, 1//10), interval(Rational{Int}, 1//10), interval(1//10), + interval(Rational{Int}, interval(1//10)), interval(interval(1//10)), + interval(Rational{BigInt}, 1//10, 1//10), interval(Rational{BigInt}, 1//10), interval(big(1//10)), + interval( (Rational{Int}, 1//10, 1//10) ), interval( (1//10, 1//10) ), interval( (Rational{Int}, 1//10) ), interval( (1//10,) )) - a = I"[1]" - b = interval(1.0, 1.0) - @test isequal_interval(a, b) + @test_throws MethodError BareInterval(1) + @test_throws MethodError BareInterval{Float64}(1) + @test_throws MethodError BareInterval(1, 2) + @test_throws MethodError BareInterval{Float64}(1, 2) - a = I"[-0x1.3p-1, 2/3]" - b = interval(-0.59375, 0.6666666666666667) - @test isequal_interval(a, b) + @test_throws MethodError Interval(1) + @test_throws MethodError Interval{Float64}(1) + @test_throws MethodError Interval(1, 2) + @test_throws MethodError Interval{Float64}(1, 2) + + @test isequal_interval( + BareInterval{Float64}(bareinterval(3, 4)), BareInterval{BigFloat}(bareinterval(3, 4)), + BareInterval{Rational{Int}}(bareinterval(3, 4)), BareInterval{Rational{BigInt}}(bareinterval(3, 4)), + bareinterval(3, 4)) + + @test isequal_interval( + Interval{Float64}(interval(3, 4)), Interval{BigFloat}(interval(3, 4)), + Interval{Rational{Int}}(interval(3, 4)), Interval{Rational{BigInt}}(interval(3, 4)), + interval(3, 4)) + + @test isempty_interval(bareinterval(2, 1)) + @test isempty_interval(bareinterval(Inf)) + @test isempty_interval(bareinterval(-Inf)) + @test isempty_interval(bareinterval(1, NaN)) + @test isempty_interval(bareinterval(NaN)) + + @test isnai(interval(2, 1)) + @test isnai(interval(Inf)) + @test isnai(interval(-Inf)) + @test isnai(interval(1, NaN)) + @test isnai(interval(NaN)) + + # 1//10 < 0.1, 2//10 < 0.2 + @test !in_interval(1//10, interval(0.1, 0.2)) && in_interval(2//10, interval(0.1, 0.2)) + + @test isequal_interval(interval(1//2), interval(0.5)) + @test inf(interval(1//10)) == 1//10 && sup(interval(1//10)) == 1//10 + + x = interval(1 + 2im) + @test typeof(x) == Complex{Interval{Float64}} + @test isequal_interval(x, complex(interval(1), interval(2))) + + @test IntervalArithmetic.Symbols.:(..) === interval +end + +@testset "Irrationals" begin + for irr ∈ (MathConstants.:e, MathConstants.:γ, MathConstants.:π, MathConstants.:φ, MathConstants.:ℯ) + for T ∈ (Float16, Float32, Float64, BigFloat) + @test in_interval(irr, interval(T, irr)) + if T !== BigFloat + @test nextfloat(inf(interval(T, irr))) == sup(interval(T, irr)) + end + end + for T ∈ [InteractiveUtils.subtypes(Signed) ; InteractiveUtils.subtypes(Unsigned)] + @test in_interval(irr, interval(Rational{T}, irr)) + end + end end -@testset "setdiff_interval tests" begin - x = interval(1, 3) - y = interval(2, 4) - @test all(isequal_interval.(setdiff_interval(x, y), [interval(1, 2)])) - @test all(isequal_interval.(setdiff_interval(y, x), [interval(3, 4)])) +@testset "Midpoint" begin + @test isequal_interval(IntervalArithmetic.Symbols.:±(0.5, 1), + interval(0.5, 1; format = :midpoint), + interval(0.5, 1+0im; format = :midpoint), + interval(0.5, interval(1+0im); format = :midpoint), + interval(-0.5, 1.5)) - @test setdiff_interval(x, x) == Interval{Float64}[] - @test setdiff_interval(x, x) == Interval{Float64}[] + @test isequal_interval(IntervalArithmetic.Symbols.:±(interval(0.5, 1), interval(1, 2)), + interval(interval(0.5, 1), interval(1, 2); format = :midpoint), + interval(-1.5, 3)) - @test all(isequal_interval.(setdiff_interval(x, emptyinterval(x)), [x])) + @test isequal_interval(IntervalArithmetic.Symbols.:±(0.5+im, 1), + interval(0.5+im, 1; format = :midpoint), + interval(0.5+im, 1+0im; format = :midpoint), + interval(interval(0.5+im), interval(1+0im); format = :midpoint), + complex(interval(-0.5, 1.5), interval(0, 2))) - z = interval(0, 5) - @test setdiff_interval(x, z) == Interval{Float64}[] - @test all(isequal_interval.(setdiff_interval(z, x), [interval(0, 1), interval(3, 5)])) + @test_throws DomainError interval(0.5+im, 1+im; format = :midpoint) end -@testset "Interval{T}(x::Interval)" begin - @test isequal_interval(Interval{Float64}(interval(3, 4)), interval(Float64, 3.0, 4.0)) - @test isequal_interval(Interval{BigFloat}(interval(3, 4)), interval(BigFloat, 3, 4)) -end - -# issue 192: -@testset "Disallow NaN in an interval" begin - @test_logs (:warn, ) @test isempty_interval(interval(NaN, 2)) - @test_logs (:warn, ) @test isempty_interval(interval(Inf, NaN)) - @test_logs (:warn, ) @test isempty_interval(interval(NaN, NaN)) -end - -@testset "Hashing of Intervals" begin - x = interval(Float64, 1, 2) - y = interval(BigFloat, 1, 2) - @test isequal_interval(x, y) - @test hash(x) == hash(y) +@testset "Decorations" begin + a = interval(1, 2) + b = interval(1, 2, IntervalArithmetic.com) + c = interval(1, 2, IntervalArithmetic.dac) + d = interval(a, IntervalArithmetic.dac) - x = I"0.1" - y = IntervalArithmetic.bigequiv(x) - @test isequal_interval(x, y) - @test hash(x) == hash(y) + @test decoration(a) == IntervalArithmetic.com + @test decoration(b) == IntervalArithmetic.com + @test decoration(c) == IntervalArithmetic.dac + @test decoration(d) == IntervalArithmetic.dac - x = interval(1, 2) - y = interval(1, 3) - @test !isequal_interval(x, y) - @test hash(x) != hash(y) + @test decoration(interval(2, 0.1)) == decoration(interval(2, 0.1, IntervalArithmetic.com)) == IntervalArithmetic.ill end -@testset "a..b with a > b" begin - @test_logs (:warn,) @test isempty_interval(interval(3, 2)) -end +@testset "Conversions and promotions" begin + bx = bareinterval(Float64, π) + by = bareinterval(BigFloat, π) + big_bx, big_by = promote(bx, by) + @test promote_type(typeof(bx), typeof(by)) == typeof(big_bx) == BareInterval{BigFloat} + @test isequal_interval(big_bx, BareInterval{BigFloat}(bx)) + @test isequal_interval(big_by, by) + # cannot convert a `Real` to a `BareInterval` + @test_throws MethodError convert(BareInterval, 1) + @test_throws MethodError convert(BareInterval{Float64}, 1) -@testset "Zero interval" begin - @test isequal_interval(zero(Interval{Float64}), interval(Float64, 0, 0)) - @test isequal_interval(zero(interval(0, 1)), interval(Float64, 0, 0)) + x = interval(Float64, π) + y = interval(BigFloat, π) + big_x, big_y = promote(x, y) + @test promote_type(typeof(x), typeof(y)) == typeof(big_x) == Interval{BigFloat} + @test isequal_interval(big_x, Interval{BigFloat}(x)) + @test isequal_interval(big_y, y) + # can convert a `Real` to an `Interval` + @test isequal_interval(convert(Interval{Float64}, 1), interval(1)) & (isguaranteed(convert(Interval{Float64}, 1)) == !isguaranteed(interval(1))) + @test isequal_interval(convert(Complex{Interval{Float64}}, 1), interval(1+0im)) & (isguaranteed(convert(Complex{Interval{Float64}}, 1)) == !isguaranteed(interval(1+0im))) + @test isequal_interval(convert(Complex{Interval{Float64}}, im), interval(im)) & (isguaranteed(convert(Complex{Interval{Float64}}, im)) == !isguaranteed(interval(im))) + @test isequal_interval(convert(Interval{Float64}, 1+0im), convert(Interval{Float64}, interval(1+0im)), interval(1)) + @test_throws DomainError convert(Interval{Float64}, 1+im) + @test_throws DomainError convert(Interval{Float64}, interval(1+im)) end diff --git a/test/interval_tests/display.jl b/test/interval_tests/display.jl new file mode 100644 index 000000000..40be6f4cf --- /dev/null +++ b/test/interval_tests/display.jl @@ -0,0 +1,228 @@ +setprecision(BigFloat, 256) do + @testset "BareInterval" begin + a = bareinterval(-floatmin(Float64), 1.3) + # large_expo = IntervalArithmetic.atomic(BigFloat, -Inf) + large_expo = bareinterval(0, big"1e123456789") # use smaller exponent, cf. JuliaLang/julia#48678 + + @testset "Standard format" begin + setdisplay(:standard) + + @testset "6 significant digits" begin + # `decorations` keyword has no impact for `BareInterval` + setdisplay(; sigdigits = 6, decorations = true) + + @test sprint(show, MIME("text/plain"), emptyinterval(BareInterval{Float64})) == "∅" + + @test sprint(show, MIME("text/plain"), a) == "[-2.22508e-308, 1.30001]" + @test sprint(show, MIME("text/plain"), large_expo) == + "[0.0, 1.00001e+123456789]₂₅₆" + end + + @testset "20 significant digits" begin + # `decorations` keyword has no impact for `BareInterval` + setdisplay(; sigdigits = 20, decorations = true) + + @test sprint(show, MIME("text/plain"), a) == "[-2.2250738585072014e-308, 1.3000000000000000445]" + @test sprint(show, MIME("text/plain"), large_expo) == + "[0.0, 1.0000000000000000001e+123456789]₂₅₆" + end + end + + @testset "Full format" begin + # `decorations` keyword has no impact for `BareInterval` + # `sigdigits` is not taken into account for format `:full` + setdisplay(:full; sigdigits = 100, decorations = true) + + @test sprint(show, MIME("text/plain"), emptyinterval(BareInterval{Float64})) == "BareInterval{Float64}(∅)" + + @test sprint(show, MIME("text/plain"), a) == "BareInterval{Float64}(-2.2250738585072014e-308, 1.3)" + @test sprint(show, MIME("text/plain"), large_expo) == + "BareInterval{BigFloat}(0.0, 1.000000000000000000000000000000000000000000000000000000000000000000000000000004e+123456789)" + end + + @testset "Midpoint format" begin + # `decorations` keyword has no impact for `BareInterval` + setdisplay(:midpoint; sigdigits = 6, decorations = true) + + @test sprint(show, MIME("text/plain"), emptyinterval(BareInterval{Float64})) == "∅" + + @test sprint(show, MIME("text/plain"), a) == "0.65 ± 0.650001" + @test sprint(show, MIME("text/plain"), large_expo) == + "(5.0e+123456788 ± 5.00001e+123456788)₂₅₆" + end + end + + @testset "Interval" begin + a = interval(1, 2) + a_NG = a/1 + b = interval(-floatmin(Float64), 1.3) + b32 = interval(-floatmin(Float32), parse(Float32, "1.3")) + b16 = interval(-floatmin(Float16), parse(Float16, "1.3")) + br = interval(Rational{Int64}, -11//10, 13//10) + c = interval(-1, Inf) + # large_expo = IntervalArithmetic.atomic(BigFloat, -Inf) + large_expo = interval(0, big"1e123456789") # use smaller exponent, cf. JuliaLang/julia#48678 + + @testset "Standard format" begin + setdisplay(:standard) + + @testset "6 significant digits" begin + setdisplay(; sigdigits = 6) + + @testset "Decorations" begin + setdisplay(; decorations = true) + + @test sprint(show, MIME("text/plain"), emptyinterval()) == "∅_trv" + @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "∅_trv_NG" + + @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]_com" + @test sprint(show, MIME("text/plain"), a_NG) == "[1.0, 2.0]_com_NG" + @test sprint(show, MIME("text/plain"), b) == "[-2.22508e-308, 1.30001]_com" + @test sprint(show, MIME("text/plain"), b32) == "[-1.1755f-38, 1.30001f0]_com" + @test sprint(show, MIME("text/plain"), b16) == "[Float16(-6.104e-5), Float16(1.29981)]_com" + @test sprint(show, MIME("text/plain"), br) == "[-11//10, 13//10]_com" + @test sprint(show, MIME("text/plain"), c) == "[-1.0, ∞)_dac" + @test sprint(show, MIME("text/plain"), large_expo) == + "[0.0, 1.00001e+123456789]₂₅₆_com" + end + + @testset "No decorations" begin + setdisplay(; decorations = false) + + @test sprint(show, MIME("text/plain"), emptyinterval()) == "∅" + @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "∅_NG" + + @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]" + @test sprint(show, MIME("text/plain"), a_NG) == "[1.0, 2.0]_NG" + @test sprint(show, MIME("text/plain"), b) == "[-2.22508e-308, 1.30001]" + @test sprint(show, MIME("text/plain"), b32) == "[-1.1755f-38, 1.30001f0]" + @test sprint(show, MIME("text/plain"), b16) == "[Float16(-6.104e-5), Float16(1.29981)]" + @test sprint(show, MIME("text/plain"), br) == "[-11//10, 13//10]" + @test sprint(show, MIME("text/plain"), c) == "[-1.0, ∞)" + @test sprint(show, MIME("text/plain"), large_expo) == + "[0.0, 1.00001e+123456789]₂₅₆" + end + end + + @testset "20 significant digits" begin + setdisplay(; sigdigits = 20, decorations = true) + + @test sprint(show, MIME("text/plain"), a) == "[1.0, 2.0]_com" + @test sprint(show, MIME("text/plain"), a_NG) == "[1.0, 2.0]_com_NG" + @test sprint(show, MIME("text/plain"), b) == "[-2.2250738585072014e-308, 1.3000000000000000445]_com" + @test sprint(show, MIME("text/plain"), b32) == "[-1.1754944f-38, 1.2999999523162841797f0]_com" + @test sprint(show, MIME("text/plain"), b16) == "[Float16(-6.104e-5), Float16(1.2998046875000000001)]_com" + @test sprint(show, MIME("text/plain"), br) == "[-11//10, 13//10]_com" + @test sprint(show, MIME("text/plain"), c) == "[-1.0, ∞)_dac" + @test sprint(show, MIME("text/plain"), large_expo) == + "[0.0, 1.0000000000000000001e+123456789]₂₅₆_com" + end + end + + @testset "Full format" begin + # `sigdigits` and `decorations` keywords are not taken into account for format `:full` + setdisplay(:full; sigdigits = 100, decorations = false) + + @test sprint(show, MIME("text/plain"), emptyinterval()) == "Interval{Float64}(∅, trv)" + @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "Interval{Float64}(∅, trv, 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"), large_expo) == + "Interval{BigFloat}(0.0, 1.000000000000000000000000000000000000000000000000000000000000000000000000000004e+123456789, com)" + end + + @testset "Midpoint format" begin + setdisplay(:midpoint; sigdigits = 6) + + @testset "Decorations" begin + setdisplay(; decorations = true) + + @test sprint(show, MIME("text/plain"), emptyinterval()) == "∅_trv" + @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "∅_trv_NG" + + @test sprint(show, MIME("text/plain"), a) == "(1.5 ± 0.5)_com" + @test sprint(show, MIME("text/plain"), a_NG) == "(1.5 ± 0.5)_com_NG" + @test sprint(show, MIME("text/plain"), b) == "(0.65 ± 0.650001)_com" + @test sprint(show, MIME("text/plain"), b32) == "(0.65f0 ± 0.650001f0)_com" + @test sprint(show, MIME("text/plain"), b16) == "(Float16(0.649902) ± Float16(0.649903))_com" + @test sprint(show, MIME("text/plain"), br) == "(1//10 ± 6//5)_com" + @test sprint(show, MIME("text/plain"), c) == "(1.79769e+308 ± ∞)_dac" + @test sprint(show, MIME("text/plain"), large_expo) == + "(5.0e+123456788 ± 5.00001e+123456788)₂₅₆_com" + end + + @testset "No decorations" begin + setdisplay(; decorations = false) + + @test sprint(show, MIME("text/plain"), emptyinterval()) == "∅" + @test sprint(show, MIME("text/plain"), emptyinterval()/1) == "∅_NG" + + @test sprint(show, MIME("text/plain"), a) == "1.5 ± 0.5" + @test sprint(show, MIME("text/plain"), a_NG) == "(1.5 ± 0.5)_NG" + @test sprint(show, MIME("text/plain"), b) == "0.65 ± 0.650001" + @test sprint(show, MIME("text/plain"), b32) == "0.65f0 ± 0.650001f0" + @test sprint(show, MIME("text/plain"), b16) == "Float16(0.649902) ± Float16(0.649903)" + @test sprint(show, MIME("text/plain"), br) == "1//10 ± 6//5" + @test sprint(show, MIME("text/plain"), c) == "1.79769e+308 ± ∞" + @test sprint(show, MIME("text/plain"), large_expo) == + "(5.0e+123456788 ± 5.00001e+123456788)₂₅₆" + end + end + end + + @testset "Complex{<:Interval}" begin + a = complex(interval(0, 2), interval(1)) + + + @testset "Standard format" begin + setdisplay(:standard) + + @testset "6 significant digits" begin + setdisplay(; sigdigits = 6) + + @testset "Decorations" begin + setdisplay(; decorations = true) + + @test sprint(show, MIME("text/plain"), a) == "[0.0, 2.0]_com + ([1.0, 1.0]_com)im" + end + + @testset "No decorations" begin + setdisplay(; decorations = false) + + @test sprint(show, MIME("text/plain"), a) == "[0.0, 2.0] + [1.0, 1.0]im" + end + end + end + + @testset "Full format" begin + # `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) + Interval{Float64}(1.0, 1.0, com)im" + end + + @testset "Midpoint format" begin + setdisplay(:midpoint; sigdigits = 6) + + @testset "Decorations" begin + setdisplay(; decorations = true) + + @test sprint(show, MIME("text/plain"), a) == "(1.0 ± 1.0)_com + ((1.0 ± 0.0)_com)im" + end + + @testset "No decorations" begin + setdisplay(; decorations = false) + + @test sprint(show, MIME("text/plain"), a) == "(1.0 ± 1.0) + (1.0 ± 0.0)im" + end + end + end + + setdisplay(:standard; sigdigits = 6, decorations = true) # reset to default display options +end diff --git a/test/interval_tests/hyperbolic.jl b/test/interval_tests/hyperbolic.jl index 3bad1acb5..935473809 100644 --- a/test/interval_tests/hyperbolic.jl +++ b/test/interval_tests/hyperbolic.jl @@ -1,6 +1,3 @@ -using IntervalArithmetic -using Test - @testset "sinh" begin @test isequal_interval(sinh(emptyinterval()), emptyinterval()) @test isequal_interval(sinh(interval(0.5)), interval(0.5210953054937473, 0.5210953054937474)) diff --git a/test/interval_tests/linear_algebra.jl b/test/interval_tests/linear_algebra.jl deleted file mode 100644 index 41b30fc57..000000000 --- a/test/interval_tests/linear_algebra.jl +++ /dev/null @@ -1,17 +0,0 @@ -using Test -using IntervalArithmetic - -A = [ interval(2, 4) interval(-2, 1) - interval(-1, 2) interval(2, 4)] - -b = [interval(-2, 2) - interval(-2, 2)] - -@testset "Linear algebra with intervals tests" begin - @test all(isequal_interval.(A * b, [interval(-12, 12), interval(-12, 12)])) - - # Example from Moore et al., Introduction to Interval Analysis (2009), pg. 88: - # TODO This is using the wrong \. I think the correct one is defined - # elsewhere, maybe IntervalRootFinding.jl. - @test_skip all(isequal_interval.(A \ b, [interval(-5, 5), interval(-4, 4)])) -end diff --git a/test/interval_tests/loops.jl b/test/interval_tests/loops.jl index 73864e629..210720ba4 100644 --- a/test/interval_tests/loops.jl +++ b/test/interval_tests/loops.jl @@ -1,17 +1,13 @@ -using Test -using IntervalArithmetic - - @testset "Interval loop tests" begin i = 1 - @test interval(i, i).lo == 1 - @test interval(i).lo == 1 + @test inf(interval(i, i)) == 1 + @test inf(interval(i)) == 1 for i in 1:10 a = interval(i) - @test a.lo == i + @test inf(a) == i end end @@ -22,33 +18,33 @@ function calc_pi1(N) S1 = interval(0) for i in 1:N - S1 += 1/interval(i)^2 + S1 += inv(interval(i)^2) end - S1 += interval(1/interval(N+1), 1/interval(N)) + S1 += interval(inv(interval(N+1)), inv(interval(N))) - sqrt(6*S1) + return sqrt(interval(6)*S1) end function calc_pi2(N) S2 = interval(0) for i in 1:N - S2 += 1 / i^2 + S2 += interval(1 / i^2) end - S2 += interval(1/interval(N+1), 1/interval(N)) + S2 += interval(inv(interval(N+1)), inv(interval(N))) - sqrt(6*S2) + return sqrt(interval(6)*S2) end function calc_pi3(N) S3 = interval(0) for i in 1:N - S3 += 1 / i^2 + S3 += interval(1 / i^2) end S3 += parse(Interval{Float64}, "[1/$(N+1), 1/$N]") - sqrt(6*S3) + return sqrt(interval(6)*S3) end function calc_pi4(N) @@ -56,27 +52,27 @@ function calc_pi4(N) II = interval(1) for i in N:-1:1 - S4 += II / i^2 + S4 += II / interval(i^2) end S4 += II / interval(N, N+1) - sqrt(6*S4) + return sqrt(interval(6)*S4) end function calc_pi5(N) S5 = interval(0) for i in N:-1:1 - S5 += 1 // i^2 + S5 += interval(1 // i^2) end - S5 += 1 / interval(N, N+1) + S5 += inv(interval(N, N+1)) - sqrt(6*S5) + return sqrt(interval(6)*S5) end @testset "Pi tests" begin big_pi = setprecision(256) do - big(pi) + big(π) end N = 10000 diff --git a/test/multidim_tests/multidim.jl b/test/interval_tests/multidim.jl similarity index 66% rename from test/multidim_tests/multidim.jl rename to test/interval_tests/multidim.jl index 7f43f6688..657408ec6 100644 --- a/test/multidim_tests/multidim.jl +++ b/test/interval_tests/multidim.jl @@ -1,5 +1,19 @@ using IntervalArithmetic.Symbols +@testset "Linear algebra" begin + A = [interval(2, 4) interval(-2, 1) + interval(-1, 2) interval(2, 4)] + + b = [interval(-2, 2) + interval(-2, 2)] + + @test all(isequal_interval.(A * b, [interval(-12, 12), interval(-12, 12)])) + @test_throws ArgumentError A \ b + + @test all(isequal_interval.(interval.([1 2; 3 4]) * interval(-1, 1), [interval(-1, 1) interval(-2, 2) ; interval(-3, 3) interval(-4, 4)])) +end + + @testset "setdiff_interval" begin function sameset(A, B) length(A) != length(B) && return false @@ -110,3 +124,30 @@ end @test mapreduce((x, y) -> all(isequal_interval.(x, y)), &, mince(ib4, (4,4,4,4)), vb4) @test mapreduce((x, y) -> all(isequal_interval.(x, y)), &, mince(ib4, (1,1,1,1)), (ib4,)) end + +@testset "Bisect" begin + v = [interval(0, 1), interval(0, 2)] + w = bisect(v, 1, 0.5) + @test all(isequal_interval.( w[1], [interval(0, 0.5), interval(0, 2)] )) & + all(isequal_interval.( w[2], [interval(0.5, 1), interval(0, 2)] )) + w = bisect(v, 2, 0.5) + @test all(isequal_interval.( w[1], [interval(0, 1), interval(0, 1)] )) & + all(isequal_interval.( w[2], [interval(0, 1), interval(1, 2)] )) + w = bisect(v, 1, 0.25) + @test all(isequal_interval.( w[1], [interval(0, 0.25), interval(0, 2)] )) & + all(isequal_interval.( w[2], [interval(0.25, 1), interval(0, 2)] )) + w = bisect(v, 2, 0.25) + @test all(isequal_interval.( w[1], [interval(0, 1), interval(0, 0.5)] )) & + all(isequal_interval.( w[2], [interval(0, 1), interval(0.5, 2)] )) + w = bisect(v, 1) + @test all(isequal_interval.( w[1], [interval(0, 0.49609375), interval(0, 2)] )) & + all(isequal_interval.( w[2], [interval(0.49609375, 1), interval(0, 2)] )) + w = bisect(v, 2) + @test all(isequal_interval.( w[1], [interval(0, 1), interval(0.0, 0.9921875)] )) & + all(isequal_interval.( w[2], [interval(0, 1), interval(0.9921875, 2.0)] )) + + v = [interval(-Inf, Inf), interval(-Inf, Inf)] + w = bisect(v, 1, 0.5) + @test all(isequal_interval.( w[1], [interval(-Inf, 0), interval(-Inf, Inf)] )) & + all(isequal_interval.( w[2], [interval(0, Inf), interval(-Inf, Inf)] )) +end diff --git a/test/interval_tests/non_BigFloat.jl b/test/interval_tests/non_BigFloat.jl deleted file mode 100644 index 701da656d..000000000 --- a/test/interval_tests/non_BigFloat.jl +++ /dev/null @@ -1,37 +0,0 @@ -using Test -using IntervalArithmetic -import IntervalArithmetic: unsafe_interval - -@testset "Tests with rational intervals" begin - a = interval(Rational{Int}, 1//2, 3//4) - b = interval(Rational{Int}, 3//7, 9//12) - - @test isequal_interval(a + b, interval(Rational{Int}, 13//14, 3//2)) # exact - - @test isequal_interval(sqrt(a + b), unsafe_interval(Rational{Int64}, 137482504//142672337, 46099201//37639840)) - - X = interval(1//3) - @test isequal_interval(sqrt(X), unsafe_interval(Rational{Int64}, 29354524//50843527, 50843527//88063572)) -end - -@testset "Rounding rational intervals" begin - X = interval(big(1)//3) - Y = interval(big"5.77350269189625764452e-01", big"5.77350269189625764561e-01") - @test_broken isequal_interval(sqrt(X), Y) -end - -@testset "Tests with float intervals" begin - c = I"[0.1, 0.2]" - - @test isa(I"0.1", Interval) - @test issubset_interval(c, interval(prevfloat(0.1), nextfloat(0.2))) - - @test isequal_interval(interval(Float64, pi), interval(3.141592653589793, 3.1415926535897936)) -end - -@testset "Testing functions of intervals" begin - f(x) = x + 0.1 - - c = I"[0.1, 0.2]" - @test isequal_interval(f(c), interval(0.19999999999999998, 0.30000000000000004)) -end diff --git a/test/interval_tests/numeric.jl b/test/interval_tests/numeric.jl index 83f768b65..d0d2b0c3b 100644 --- a/test/interval_tests/numeric.jl +++ b/test/interval_tests/numeric.jl @@ -1,29 +1,8 @@ -using Test -using IntervalArithmetic - -@testset "brodcasting tests" begin - a = 3 - b = 12 - x = interval(a, b) - - for i in 1:20 - @test isequal_interval(x.-i, interval(a-i, b-i)) - end - - - for i in 1:20 - @test isequal_interval(x.*i, interval(a*i, b*i)) - end - - a = 4 - b = 5 - y = interval(a, b) - for i in 1:20 - @test isequal_interval(y.+i, interval(a+i, b+i)) - end +@testset "Brodcasting" begin + x = interval(1, 2) - for i in 1:20 - @test isequal_interval(y./i, interval(/(a, i, RoundDown), /(b, i, RoundUp))) + for f ∈ (+, -, *, /) + @test isequal_interval(f.(x, x), f(x, x)) end end @@ -35,9 +14,9 @@ end ## Basic arithmetic @test isequal_interval(+a, a) - @test isequal_interval(a + b, interval(+(a.lo, b.lo, RoundDown), +(a.hi, b.hi, RoundUp))) - @test isequal_interval(-a, interval(-a.hi, -a.lo)) - @test isequal_interval(a - b, interval(-(a.lo, b.hi, RoundDown), -(a.hi, b.lo, RoundUp))) + @test isequal_interval(a + b, interval(+(inf(a), inf(b), RoundDown), +(sup(a), sup(b), RoundUp))) + @test isequal_interval(-a, interval(-sup(a), -inf(a))) + @test isequal_interval(a - b, interval(-(inf(a), sup(b), RoundDown), -(sup(a), inf(b), RoundUp))) for f in (:+, :-, :*, :/) @eval begin @test isequal_interval($f(interval(Float64, pi), interval(Float32, pi)), @@ -49,9 +28,9 @@ end @test isequal_interval(interval(-30.0,-15.0) / interval(-5.0,-3.0), interval(3.0, 10.0)) @test isequal_interval(interval(-30,-15) / interval(-5,-3), interval(3.0, 10.0)) - @test isequal_interval(b/a, interval(/(b.lo, a.hi, RoundDown), /(b.hi, a.lo, RoundUp))) + @test isequal_interval(b/a, interval(/(inf(b), sup(a), RoundDown), /(sup(b), inf(a), RoundUp))) @test isequal_interval(a/c, interval(0.025, 4.4)) - @test isequal_interval(c/4.0, interval(6.25e-02, 1e+00)) + @test isequal_interval(c/interval(4.0), interval(6.25e-02, 1e+00)) @test isequal_interval(c/zero(c), emptyinterval(c)) @test isequal_interval(interval(0.0, 1.0)/interval(0.0,1.0), interval(0.0, Inf)) @test isequal_interval(interval(-1.0, 1.0)/interval(0.0,1.0), entireinterval(c)) @@ -75,86 +54,80 @@ end result = interval(1.1) * interval(2) + interval(3) @test isequal_interval(muladd(interval(1.1), interval(2), interval(3)), result) @test isequal_interval(muladd(interval(1.1), interval(Float32, 2), interval(3)), result) - @test isequal_interval(muladd(interval(1.1), interval(2), 3), result) - @test isequal_interval(muladd(interval(1.1), 2, interval(3)), result) - @test isequal_interval(muladd(1.1, interval(2), interval(3)), result) - @test isequal_interval(muladd(interval(1.1), 2, 3), result) - @test isequal_interval(muladd(1.1, interval(2), 3), result) - @test isequal_interval(muladd(1.1, 2, interval(3)), result) end @testset "Arithmetic with constants" begin x = interval(1, 2) - @test isequal_interval(0.1 + x, interval(1.0999999999999999, 2.1)) - @test isequal_interval(3.0 - x, x) - @test isequal_interval(3.1 - x, interval(1.1, 2.1)) - @test isequal_interval(0.1 * interval(1), interval(0.1, 0.1)) - @test isequal_interval(0.0 * interval(1), interval(0.0, 0.0)) - @test isequal_interval(interval(1) / 10.0, interval(0.09999999999999999, 0.1)) + @test isequal_interval(interval(0.1) + x, interval(1.0999999999999999, 2.1)) + @test isequal_interval(interval(3.0) - x, x) + @test isequal_interval(interval(3.1) - x, interval(1.1, 2.1)) + @test isequal_interval(interval(0.1) * interval(1), interval(0.1, 0.1)) + @test isequal_interval(interval(0.0) * interval(1), interval(0.0, 0.0)) + @test isequal_interval(interval(1) / interval(10.0), interval(0.09999999999999999, 0.1)) end @testset "Arithmetic with irrational" begin - @test isequal_interval(interval(1) * π, interval(π)) - @test isequal_interval(π * interval(1), interval(π)) - @test isequal_interval(π + interval(0), interval(π)) - @test isequal_interval(interval(0) + π, interval(π)) - @test isequal_interval(π - interval(0), interval(π)) - @test isequal_interval(interval(0) - π, -interval(π)) + @test isequal_interval(interval(1) * interval(π), interval(π)) + @test isequal_interval(interval(π) * interval(1), interval(π)) + @test isequal_interval(interval(π) + interval(0), interval(π)) + @test isequal_interval(interval(0) + interval(π), interval(π)) + @test isequal_interval(interval(π) - interval(0), interval(π)) + @test isequal_interval(interval(0) - interval(π), -interval(π)) end @testset "Power tests" begin - @test isequal_interval(interval(2,3) ^ 2, interval(4, 9)) - @test isequal_interval(interval(0,3) ^ 2, interval(0, 9)) - @test isequal_interval(interval(-3,0) ^ 2, interval(0, 9)) - @test isequal_interval(interval(-3,-2) ^ 2, interval(4, 9)) - @test isequal_interval(interval(-3,2) ^ 2, interval(0, 9)) - @test isequal_interval(interval(0,3) ^ 3, interval(0, 27)) - @test isequal_interval(interval(2,3) ^ 3, interval(8, 27)) - @test isequal_interval(interval(-3,0) ^ 3, interval(-27., 0.)) - @test isequal_interval(interval(-3,-2) ^ 3, interval(-27, -8)) - @test isequal_interval(interval(-3,2) ^ 3, interval(-27., 8.)) - @test isequal_interval(interval(0,3) ^ -2, interval(1/9, Inf)) - @test isequal_interval(interval(-3,0) ^ -2, interval(1/9, Inf)) - @test isequal_interval(interval(-3,2) ^ -2, interval(1/9, Inf)) - @test isequal_interval(interval(2,3) ^ -2, interval(1/9, 1/4)) - @test isequal_interval(interval(1,2) ^ -3, interval(1/8, 1.0)) - @test isequal_interval(interval(0,3) ^ -3, interval(1/27, Inf)) - @test isequal_interval(interval(-1,2) ^ -3, entireinterval()) - @test isequal_interval(interval(-3,2) ^ (3//1), interval(-27, 8)) - @test isequal_interval(interval(0.0) ^ 1.1, interval(0, 0)) - @test isequal_interval(interval(0.0) ^ 0.0, emptyinterval()) - @test isequal_interval(interval(0.0) ^ (1//10), interval(0, 0)) - @test isequal_interval(interval(0.0) ^ (-1//10), emptyinterval()) - @test isequal_interval(emptyinterval() ^ 0, emptyinterval()) - @test isequal_interval(interval(2.5)^3, interval(15.625, 15.625)) - @test isequal_interval(interval(5//2)^3.0, interval(125//8)) + @test isequal_interval(nthpow(interval(2,3) , 2), interval(4, 9)) + @test isequal_interval(nthpow(interval(0,3) , 2), interval(0, 9)) + @test isequal_interval(nthpow(interval(-3,0) , 2), interval(0, 9)) + @test isequal_interval(nthpow(interval(-3,-2), 2), interval(4, 9)) + @test isequal_interval(nthpow(interval(-3,2) , 2), interval(0, 9)) + @test isequal_interval(nthpow(interval(0,3) , 3), interval(0, 27)) + @test isequal_interval(nthpow(interval(2,3) , 3), interval(8, 27)) + @test isequal_interval(nthpow(interval(-3,0) , 3), interval(-27., 0.)) + @test isequal_interval(nthpow(interval(-3,-2), 3), interval(-27, -8)) + @test isequal_interval(nthpow(interval(-3,2) , 3), interval(-27., 8.)) + @test isequal_interval(nthpow(interval(0,3) , -2), interval(1/9, Inf)) + @test isequal_interval(nthpow(interval(-3,0) , -2), interval(1/9, Inf)) + @test isequal_interval(nthpow(interval(-3,2) , -2), interval(1/9, Inf)) + @test isequal_interval(nthpow(interval(2,3) , -2), interval(1/9, 1/4)) + @test isequal_interval(nthpow(interval(1,2) , -3), interval(1/8, 1.0)) + @test isequal_interval(nthpow(interval(0,3) , -3), interval(1/27, Inf)) + @test isequal_interval(nthpow(interval(-1,2) , -3), entireinterval()) + @test isequal_interval(nthpow(interval(-3,2) , 3), interval(-27, 8)) + @test isequal_interval(interval(0.0) ^ interval(1.1), interval(0)) + @test isequal_interval(nthpow(interval(0.0) , 0), interval(1)) + @test isequal_interval(interval(0.0) ^ interval(1//10), interval(0)) + @test isequal_interval(interval(0.0) ^ interval(-1//10), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(), 0), emptyinterval()) + @test isequal_interval(nthpow(interval(2.5) , 3), interval(15.625, 15.625)) + @test isequal_interval(nthpow(interval(5//2), 3), interval(125//8)) x = interval(-3, 2) - @test isequal_interval(x^3, interval(-27, 8)) + @test isequal_interval(nthpow(x, 3), interval(-27, 8)) - @test isequal_interval(interval(-3, 4) ^ 0.5, interval(0, 2)) - @test isequal_interval(interval(-3, 4) ^ 0.5, interval(-3, 4)^(1//2)) - @test isequal_interval(interval(-3, 2) ^ interval(2), interval(0.0, 4.0)) @test isequal_interval(interval(-3, 4) ^ interval(0.5), interval(0, 2)) - @test isequal_interval(interval(BigFloat, -3, 4) ^ 0.5, interval(BigFloat, 0, 2)) + @test isequal_interval(interval(-3, 4) ^ interval(0.5), interval(-3, 4)^(1//2)) + @test isequal_interval(nthpow(interval(-3, 2), 2), interval(0.0, 9.0)) + @test isequal_interval(interval(-3, 4) ^ interval(0.5), interval(0, 2)) + @test isequal_interval(interval(BigFloat, -3, 4) ^ interval(0.5), interval(BigFloat, 0, 2)) - @test dist(interval(1,27)^interval(1/3), interval(1., 3.)) < 2*eps(interval(1,3)).lo - @test dist(interval(1,27)^(1/3), interval(1., 3.)) < 2*eps(interval(1,3)).lo - @test issubset_interval(interval(1., 3.), interval(1,27)^(1//3)) - @test isequal_interval(interval(0.1,0.7)^(1//3), interval(0.46415888336127786, 0.8879040017426008)) - @test dist(interval(0.1,0.7)^(1/3), - interval(0.46415888336127786, 0.8879040017426008)) < 2*eps(interval(0.1,0.7)^(1/3)).lo + @test dist(interval(1, 27)^interval(1/3), interval(1, 3)) < 2*inf(eps(interval(1, 3))) + @test dist(interval(1, 27)^interval(1/3), interval(1, 3)) < 2*inf(eps(interval(1, 3))) + @test issubset_interval(interval(1, 3), interval(1, 27)^interval(1//3)) + @test isequal_interval(interval(0.1, 0.7)^interval(1//3), interval(0.4641588833612778, 0.8879040017426008)) # interval(0.46415888336127786, 0.8879040017426008) + @test dist(interval(0.1, 0.7)^interval(1/3), + interval(0.46415888336127786, 0.8879040017426008)) < 2*inf(eps(interval(0.1, 0.7)^interval(1/3))) x = interval(BigFloat, 27) - y = x^(1//3) + y = x^interval(1//3) @test diam(y) == 0 x = interval(BigFloat, 9.595703125) - y = x^(1//3) + y = x^interval(1//3) @test diam(y) == 0 x = interval(BigFloat, 0.1) - y = x^(1//3) + y = x^interval(1//3) @test (0 <= diam(y) < 1e-76) end @@ -205,112 +178,75 @@ end g = 1 // 3 @test isequal_interval(interval(f*g), interval(1//9)) @test isequal_interval(interval(1//9), interval(1//9, 1//9)) - @test isequal_interval(interval(f, g) - 1, interval(-2 // 3, -2 // 3)) - @test issubset_interval(interval(f*g), interval(1)/9) + @test isequal_interval(interval(f, g) - interval(1//1), interval(-2 // 3, -2 // 3)) + @test issubset_interval(interval(f*g), interval(1)/interval(9)) end @testset "Floor etc. tests" begin a = interval(0.1) b = interval(0.1, 0.1) - @test dist(a, b) <= eps(a).lo + @test dist(a, b) <= inf(eps(a)) @test isequal_interval(floor(interval(0.1, 1.1)), interval(0, 1)) @test isequal_interval(round(interval(0.1, 1.1), RoundDown), interval(0, 1)) @test isequal_interval(ceil(interval(0.1, 1.1)), interval(1, 2)) @test isequal_interval(round(interval(0.1, 1.1), RoundUp), interval(1, 2)) @test isequal_interval(sign(interval(0.1, 1.1)), interval(1.0)) - @test isequal_interval(signbit(interval(-4)), interval(1,1)) - @test isequal_interval(signbit(interval(5)), interval(0,0)) - @test isequal_interval(signbit(interval(-4,5)), interval(0,1)) - @test isequal_interval(copysign(interval(1,2), interval(-1,1)), interval(-2,2)) - @test isequal_interval(copysign(3, interval(-1,1)), interval(-3,3)) - @test isequal_interval(copysign(3.0, interval(-1,1)), interval(-3,3)) - @test isequal_interval(copysign(3f0, interval(-1,1)), interval(-3,3)) - @test isequal_interval(copysign(3, interval(0,1)), interval(3)) - @test isequal_interval(interval(3), interval(copysign(3,0),copysign(3,1))) - @test isequal_interval(copysign(3, interval(-1,0)), interval(-3,3)) - @test isequal_interval(interval(-3,3), interval(copysign(3,-1),copysign(3,0))) - @test isequal_interval(copysign(UInt64(3), interval(-1,1)), interval(-3,3)) - @test isequal_interval(copysign(BigFloat(3), interval(-1,1)), interval(-3,3)) - @test isequal_interval(copysign(interval(0,1), -1), interval(-1,0)) - @test isequal_interval(copysign(interval(0,1), -1.0), interval(-1,0)) - @test isequal_interval(copysign(interval(0,1), -1f0), interval(-1,0)) - @test isequal_interval(copysign(interval(0,1), -BigFloat(1)), interval(-1,0)) - @test isequal_interval(copysign(interval(0,1), UInt64(1)), interval(0,1)) - @test isequal_interval(copysign(interval(-1),interval(-1)), interval(-1)) - @test isequal_interval(copysign(interval(-2,2), 2), interval(0,2)) - @test isequal_interval(flipsign(interval(1,2), interval(-1,1)), interval(-2,2)) - @test isequal_interval(flipsign(interval(1,2), interval(1,2)), interval(1,2)) - @test isequal_interval(flipsign(3, interval(-1,1)), interval(-3,3)) - @test isequal_interval(flipsign(3.0, interval(-1,1)), interval(-3,3)) - @test isequal_interval(flipsign(3f0, interval(-1,1)), interval(-3,3)) - @test isequal_interval(flipsign(3, interval(0,1)), interval(3,3)) - @test isequal_interval(interval(3,3), interval(flipsign(3,0),flipsign(3,1))) - @test isequal_interval(flipsign(3, interval(-1,0)), interval(-3,3)) - @test isequal_interval(interval(-3,3), interval(flipsign(3,-1),flipsign(3,0))) - @test isequal_interval(flipsign(UInt64(3), interval(-1,1)), interval(-3,3)) - @test isequal_interval(flipsign(BigFloat(3), interval(-1,1)), interval(-3,3)) - @test isequal_interval(flipsign(interval(0,1), -1), interval(-1,0)) - @test isequal_interval(flipsign(interval(0,1), -1.0), interval(-1,0)) - @test isequal_interval(flipsign(interval(0,1), -1f0), interval(-1,0)) - @test isequal_interval(flipsign(interval(0,1), -BigFloat(1)), interval(-1,0)) - @test isequal_interval(flipsign(interval(0,1), UInt64(1)), interval(0,1)) - @test isequal_interval(flipsign(interval(-1),interval(-1)), interval(1)) @test isequal_interval(trunc(interval(0.1, 1.1)), interval(0.0, 1.0)) @test isequal_interval(round(interval(0.1, 1.1), RoundToZero), interval(0.0, 1.0)) @test isequal_interval(round(interval(0.1, 1.1)), interval(0.0, 1.0)) @test isequal_interval(round(interval(0.1, 1.5)), interval(0.0, 2.0)) @test isequal_interval(round(interval(-1.5, 0.1)), interval(-2.0, 0.0)) @test isequal_interval(round(interval(-2.5, 0.1)), interval(-2.0, 0.0)) - @test isequal_interval(round(interval(0.1, 1.1), RoundTiesToEven), interval(0.0, 1.0)) - @test isequal_interval(round(interval(0.1, 1.5), RoundTiesToEven), interval(0.0, 2.0)) - @test isequal_interval(round(interval(-1.5, 0.1), RoundTiesToEven), interval(-2.0, 0.0)) - @test isequal_interval(round(interval(-2.5, 0.1), RoundTiesToEven), interval(-2.0, 0.0)) - @test isequal_interval(round(interval(0.1, 1.1), RoundTiesToAway), interval(0.0, 1.0)) - @test isequal_interval(round(interval(0.1, 1.5), RoundTiesToAway), interval(0.0, 2.0)) - @test isequal_interval(round(interval(-1.5, 0.1), RoundTiesToAway), interval(-2.0, 0.0)) - @test isequal_interval(round(interval(-2.5, 0.1), RoundTiesToAway), interval(-3.0, 0.0)) + @test isequal_interval(round(interval(0.1, 1.1), RoundNearest), interval(0.0, 1.0)) + @test isequal_interval(round(interval(0.1, 1.5), RoundNearest), interval(0.0, 2.0)) + @test isequal_interval(round(interval(-1.5, 0.1), RoundNearest), interval(-2.0, 0.0)) + @test isequal_interval(round(interval(-2.5, 0.1), RoundNearest), interval(-2.0, 0.0)) + @test isequal_interval(round(interval(0.1, 1.1), RoundNearestTiesAway), interval(0.0, 1.0)) + @test isequal_interval(round(interval(0.1, 1.5), RoundNearestTiesAway), interval(0.0, 2.0)) + @test isequal_interval(round(interval(-1.5, 0.1), RoundNearestTiesAway), interval(-2.0, 0.0)) + @test isequal_interval(round(interval(-2.5, 0.1), RoundNearestTiesAway), interval(-3.0, 0.0)) end @testset "Fast power" begin @testset "Fast integer powers" begin x = interval(1, 2) - @test isequal_interval(pow(x, 2), pow(-x, 2)) - @test isequal_interval(pow(-x, 2), interval(1, 4)) - @test isequal_interval(pow(-x, 3), interval(-8.0, -1.0)) + @test isequal_interval(fastpow(x, 2), fastpow(-x, 2)) + @test isequal_interval(fastpow(-x, 2), interval(1, 4)) + @test isequal_interval(fastpow(-x, 3), interval(-8.0, -1.0)) - @test isequal_interval(pow(interval(-1, 2), 2), interval(0, 4)) - @test isequal_interval(pow(interval(-1, 2), 3), interval(-1, 8)) - @test isequal_interval(pow(interval(-1, 2), 4), interval(0, 16)) + @test isequal_interval(fastpow(interval(-1, 2), 2), interval(0, 4)) + @test isequal_interval(fastpow(interval(-1, 2), 3), interval(-1, 8)) + @test isequal_interval(fastpow(interval(-1, 2), 4), interval(0, 16)) - @test isequal_interval(pow(interval(-2, -1), interval(4)), interval(1, 16)) - @test isequal_interval(pow(interval(-2, -1), interval(-1, -1)), interval(-1, -0.5)) + @test isequal_interval(fastpow(interval(-2, -1), interval(4)), interval(1, 16)) + @test isequal_interval(fastpow(interval(-2, -1), interval(-1, -1)), interval(-1, -0.5)) - @test isequal_interval(pow(interval(BigFloat, -1, 2), 2), interval(0, 4)) - @test isequal_interval(pow(interval(BigFloat, -1, 2), 3), interval(-1, 8)) - @test isequal_interval(pow(interval(BigFloat, 1, 2), 2), interval(1, 4)) + @test isequal_interval(fastpow(interval(BigFloat, -1, 2), 2), interval(0, 4)) + @test isequal_interval(fastpow(interval(BigFloat, -1, 2), 3), interval(-1, 8)) + @test isequal_interval(fastpow(interval(BigFloat, 1, 2), 2), interval(1, 4)) x = interval(pi) - @test issubset_interval(x^100, pow(x, 100)) - @test issubset_interval(x^50, pow(x, 50)) - @test isstrictsubset_interval(x^50, pow(x, 50)) + @test issubset_interval(x^100, fastpow(x, 100)) + @test issubset_interval(x^50, fastpow(x, 50)) + @test isstrictsubset_interval(x^50, fastpow(x, 50)) x = interval(2) - @test isequal_interval(pow(x, 2000), interval(floatmax(), Inf)) + @test isequal_interval(fastpow(x, 2000), interval(floatmax(), Inf)) end @testset "Fast real powers" begin x = interval(1, 2) - @test isequal_interval(pow(x, 0.5), interval(1.0, 1.4142135623730951)) - @test isequal_interval(pow(x, 0.5), x^0.5) + @test isequal_interval(fastpow(x, 0.5), interval(1.0, 1.4142135623730951)) + @test isequal_interval(fastpow(x, 0.5), x^interval(0.5)) y = interval(2, 3) - @test isequal_interval(pow(y, -0.5), interval(0.5773502691896257, 0.7071067811865476)) + @test isequal_interval(fastpow(y, -0.5), interval(0.5773502691896257, 0.7071067811865476)) y = interval(-2, 3) - @test isequal_interval(pow(y, 2.1), interval(0.0, 10.045108566305146)) - @test issubset_interval(y^2.1, pow(y, 2.1)) + @test isequal_interval(fastpow(y, 2.1), interval(0.0, 10.045108566305146)) + @test issubset_interval(y^interval(2.1), fastpow(y, 2.1)) end @testset "Fast interval powers" begin @@ -318,10 +254,10 @@ end @test isequal_interval(x^interval(-1.5, 2.5), interval(0.35355339059327373, 5.656854249492381)) y = interval(-2, 3) - @test isequal_interval(pow(y, 2.1), interval(0.0, 10.045108566305146)) - @test isequal_interval(pow(y, interval(-2, 3)), interval(0, Inf)) + @test isequal_interval(fastpow(y, 2.1), interval(0.0, 10.045108566305146)) + @test isequal_interval(fastpow(y, interval(-2, 3)), interval(0, Inf)) - @test isequal_interval(pow(y, interval(2.1)), interval(0.0, 10.045108566305146)) + @test isequal_interval(fastpow(y, interval(2.1)), interval(0.0, 10.045108566305146)) end @testset "sqrt" begin diff --git a/test/interval_tests/parsing.jl b/test/interval_tests/parsing.jl index fd83e24b6..2dd09d60e 100644 --- a/test/interval_tests/parsing.jl +++ b/test/interval_tests/parsing.jl @@ -1,25 +1,59 @@ -@testset "parse to Interval{Float32}" begin - I32 = Interval{Float32} - DI32 = DecoratedInterval{Float32} - @test isequal_interval(parse(I32, "[1, 2]"), interval(1f0, 2f0)) - @test isequal_interval(parse(I32, "[1e-324, 1e400]"), interval(0f0, Float32(Inf))) - @test isequal_interval(parse(I32, "[2,infinity]"), interval(2f0, Float32(Inf))) - @test isequal_interval(parse(I32, "[foobar]"), emptyinterval(Float32)) - - @test isequal_interval(parse(DI32, "[1, 2]_com"), DecoratedInterval(interval(1f0, 2f0), com)) - @test isnai(parse(DI32, "[foobar]")) +@testset "BareInterval" begin + for T ∈ (Float16, Float32, Float64, BigFloat) + @test isequal_interval(parse(BareInterval{T}, "[1, 2]"), bareinterval(T, 1, 2)) + if T !== BigFloat + @test isequal_interval(parse(BareInterval{T}, "[1e-324, 1e400]"), bareinterval(T, 0, Inf)) + else + @test isequal_interval(parse(BareInterval{BigFloat}, "[1e-324, 1e400]"), bareinterval(big"1e-324", big"1e400")) + end + @test isequal_interval(parse(BareInterval{T}, "[2,infinity]"), bareinterval(T, 2, Inf)) + @test isempty_interval(parse(BareInterval{T}, "[foobar]")) + end + + @test isequal_interval(parse(BareInterval{Rational{Int64}}, "0.1"), bareinterval(Rational{Int64}, 1//10)) + @test isequal_interval(parse(BareInterval{Rational{Int64}}, "[0.1, 0.3]"), bareinterval(Rational{Int64}, 1//10, 3//10)) +end + +@testset "Interval" begin + for T ∈ (Float16, Float32, Float64, BigFloat) + @test isequal_interval(parse(Interval{T}, "[1, 2]"), interval(T, 1, 2)) + if T !== BigFloat + @test isequal_interval(parse(Interval{T}, "[1e-324, 1e400]"), interval(T, 0, Inf)) + else + @test isequal_interval(parse(Interval{BigFloat}, "[1e-324, 1e400]"), interval(big"1e-324", big"1e400")) + end + @test isequal_interval(parse(Interval{T}, "[2,infinity]"), interval(T, 2, Inf)) + @test isnai(parse(Interval{T}, "[foobar]")) + + x = parse(Interval{T}, "[1, 2]_com") + y = parse(Interval{T}, "[1, 2]") + z = interval(T, 1, 2) + @test isequal_interval(x, y, z) & (decoration(x) == decoration(y) == decoration(z)) + end + + @test isequal_interval(parse(Interval{Rational{Int64}}, "0.1"), interval(Rational{Int64}, 1//10)) + @test isequal_interval(parse(Interval{Rational{Int64}}, "[0.1, 0.3]"), interval(Rational{Int64}, 1//10, 3//10)) end +@testset "String macro" begin + @test typeof(I"0.1") == Interval{Float64} + + @test isequal_interval(I"[2/3, 1.1]", interval(0.6666666666666666, 1.1)) + @test isequal_interval(I"[1]", interval(1)) + @test isequal_interval(I"[-0x1.3p-1, 2/3]", interval(-0.59375, 0.6666666666666667)) + @test isequal_interval(I"123412341234123412341241234", interval(1.234123412341234e26, 1.2341234123412342e26)) + @test isequal_interval(interval(big"3"), interval(3)) + @test isequal_interval(interval(Float64, big"1e10000"), interval(Float64, big(10)^10000), interval(prevfloat(Inf), Inf)) -@testset "parse to Interval{BigFloat}" begin - BI = Interval{BigFloat} - DBI = DecoratedInterval{BigFloat} + @test in_interval(1//10, I"[0.1, 0.2]") && in_interval(2//10, I"[0.1, 0.2]") + @test issubset_interval(I"[0.1, 0.2]", interval(prevfloat(0.1), nextfloat(0.2))) - @test isequal_interval(parse(BI, "[1, 2]"), interval(big(1), big(2))) - @test isequal_interval(parse(BI, "[1e-400, 2e400]"), interval(big"1e-400", big"2e400")) + @test nextfloat(inf(I"0.1")) == sup(I"0.1") - x = parse(DBI, "[1e-400, 1e400]") - _x = DecoratedInterval(big"1e-400", big"1e400", com) - @test isequal_interval(x, _x) && decoration(x) == decoration(_x) && x isa DecoratedInterval{BigFloat} + @test isequal_interval(interval(0.5), interval(1//2), I"0.5") + @test inf(I"1e300") == 9.999999999999999e299 && sup(I"1e300") == 1.0e300 + @test inf(I"-1e307") == -1.0000000000000001e307 && sup(I"-1e307") == -1.0e307 + # corner case for enclosure, `0.100000000000000006` rounds down to `0.1` for `Float64` + @test in_interval(big"0.100000000000000006", I"0.100000000000000006") end diff --git a/test/interval_tests/power.jl b/test/interval_tests/power.jl index 49c354cc9..89c5fcec1 100644 --- a/test/interval_tests/power.jl +++ b/test/interval_tests/power.jl @@ -1,6 +1,3 @@ -using Test -using IntervalArithmetic - @testset "rational_power_test" begin @test isequal_interval(^(emptyinterval(), 1//3), emptyinterval()) @test isequal_interval(^(interval(1, 8), 1//3), interval(1, 2)) @@ -50,3 +47,46 @@ using IntervalArithmetic @test isequal_interval(^(interval(-8, -2), -3//2), emptyinterval()) @test isequal_interval(^(interval(-1, 1), 1000000000000000000000000000000000000000//1), interval(0, 1)) end + +@testset "Interval{<:Rational}" begin + a = interval(Rational{Int64}, 1//2, 3//4) + b = interval(Rational{Int64}, 3//7, 9//12) + + @test isequal_interval(sqrt(a + b), interval(Int64(137482504)//142672337, Int64(46099201)//37639840)) + + @test isequal_interval(sqrt(interval(1//3)), interval(Int64(29354524)//50843527, Int64(50843527)//88063572)) +end + +@testset "Decorations" begin + a = interval(1, 2, IntervalArithmetic.com) + b = sqrt(a) + @test isequal_interval(interval(b), sqrt(interval(1, 2))) + @test decoration(b) == IntervalArithmetic.com + + a = interval(-1, 1, IntervalArithmetic.com) + b = sqrt(a) + @test isequal_interval(interval(b), sqrt(interval(0, 1))) + @test decoration(b) == IntervalArithmetic.trv + + @test isequal_interval(nthpow(interval(2, 3) , 2), interval(4, 9)) + @test isequal_interval(nthpow(interval(2, 3) , -2), interval(1/9, 1/4)) + @test isequal_interval(nthpow(interval(-3, 2) , 3), interval(-27, 8)) + @test isequal_interval(nthpow(interval(-3, -2), -3), interval(-1/8, -1/27)) + @test isequal_interval(nthpow(interval(0, 3) , 2), interval(0, 9)) + @test isequal_interval(nthpow(interval(0, 3) , -2), interval(1/9, Inf, IntervalArithmetic.trv)) + @test isequal_interval(interval(2, 3) ^ interval(0, 1), interval(1, 3)) + @test isequal_interval(interval(2, 3) ^ interval(0, 1), interval(1, 3)) + @test isequal_interval(interval(0, 2) ^ interval(0, 1), interval(0, 2, IntervalArithmetic.trv)) + @test isequal_interval(interval(0, 2) ^ interval(0, 1), interval(0, 2, IntervalArithmetic.trv)) + @test isequal_interval(interval(-3, 2) ^ interval(0, 1), interval(0, 2, IntervalArithmetic.trv)) + @test isequal_interval(interval(-3, 2) ^ interval(0, 1), interval(0, 2, IntervalArithmetic.trv)) + @test isequal_interval(interval(-3, 2) ^ interval(-1, 1), interval(0, Inf, IntervalArithmetic.trv)) + @test isequal_interval(interval(-3, 2) ^ interval(-1, 1), interval(0, Inf, IntervalArithmetic.trv)) +end + +# @testset "Complex{<:Interval}" begin +# a = interval(3 + 4im) +# b = exp(a) +# @test real(b) == interval(-13.12878308146216, -13.128783081462153) +# @test imag(b) == interval(-15.200784463067956, -15.20078446306795) +# end diff --git a/test/rand.jl b/test/interval_tests/rand.jl similarity index 93% rename from test/rand.jl rename to test/interval_tests/rand.jl index 08e58228b..fd470ee08 100644 --- a/test/rand.jl +++ b/test/interval_tests/rand.jl @@ -1,5 +1,3 @@ -using Test -using IntervalArithmetic using Random @testset "rand tests" begin diff --git a/test/interval_tests/rounding.jl b/test/interval_tests/rounding.jl index a195ff645..98402f3d1 100644 --- a/test/interval_tests/rounding.jl +++ b/test/interval_tests/rounding.jl @@ -1,6 +1,3 @@ -using Test -using IntervalArithmetic - x = interval(0.5) @testset "IntervalRounding{:slow}" begin @@ -36,5 +33,4 @@ end @test isequal_interval(tiny / huge, interval(0, nextfloat(0.0))) end -setformat(:standard) IntervalArithmetic.interval_rounding() = IntervalRounding{:tight}() diff --git a/test/interval_tests/intervals.jl b/test/interval_tests/run_intervals.jl similarity index 63% rename from test/interval_tests/intervals.jl rename to test/interval_tests/run_intervals.jl index ef35fc74b..9026321b0 100644 --- a/test/interval_tests/intervals.jl +++ b/test/interval_tests/run_intervals.jl @@ -1,13 +1,14 @@ include_test("construction.jl") +include_test("parsing.jl") +include_test("rounding.jl") include_test("consistency.jl") include_test("numeric.jl") +include_test("power.jl") include_test("trig.jl") include_test("hyperbolic.jl") -include_test("non_BigFloat.jl") -include_test("linear_algebra.jl") include_test("loops.jl") -include_test("parsing.jl") -include_test("power.jl") -include_test("rounding.jl") include_test("bisect.jl") -# include_test("complex.jl") # TODO uncomment when Complex support is restored +include_test("rand.jl") +include_test("display.jl") +include_test("multidim.jl") +# include_test("complex.jl") # TODO uncomment when `Complex` support is restored diff --git a/test/interval_tests/set_operations.jl b/test/interval_tests/set_operations.jl index c28761bf6..5a4b8bc15 100644 --- a/test/interval_tests/set_operations.jl +++ b/test/interval_tests/set_operations.jl @@ -1,6 +1,3 @@ -using Test -using IntervalArithmetic - @testset "removed interval" begin @test_throws ArgumentError intersect(interval(1)) @test_throws ArgumentError intersect(interval(1), 2, [1], 4., 5) @@ -36,3 +33,19 @@ end y = interval(3, 4) @test setdiff_interval(x, y) == [interval(2, 3), interval(4, 5)] end + +@testset "setdiff_interval tests" begin + x = interval(1, 3) + y = interval(2, 4) + @test all(isequal_interval.(setdiff_interval(x, y), [interval(1, 2)])) + @test all(isequal_interval.(setdiff_interval(y, x), [interval(3, 4)])) + + @test setdiff_interval(x, x) == Interval{Float64}[] + @test setdiff_interval(x, x) == Interval{Float64}[] + + @test all(isequal_interval.(setdiff_interval(x, emptyinterval(x)), [x])) + + z = interval(0, 5) + @test setdiff_interval(x, z) == Interval{Float64}[] + @test all(isequal_interval.(setdiff_interval(z, x), [interval(0, 1), interval(3, 5)])) +end diff --git a/test/interval_tests/trig.jl b/test/interval_tests/trig.jl index 57516dd32..2f7e11a13 100644 --- a/test/interval_tests/trig.jl +++ b/test/interval_tests/trig.jl @@ -1,9 +1,6 @@ -using Test -using IntervalArithmetic - @testset "rad2deg/deg2rad" begin @test issubset_interval(interval(180, 360), rad2deg(interval(π, 2π))) - @test issubset_interval(interval(π, 2interval(π)), deg2rad(interval(180, 360))) + @test issubset_interval(interval(π, interval(2)*interval(π)), deg2rad(interval(180, 360))) end @testset "sin" begin @@ -41,7 +38,7 @@ end end @testset "sinpi" begin - @test isequal_interval(sinpi(emptyinterval()), emptyinterval()) + @test isempty_interval(sinpi(emptyinterval())) @test issubset_interval(interval(-1 , 0), sinpi(interval(1, 2))) @test isequal_interval(sinpi(interval(0.5, 1.5)), interval(-1 , 1)) @test issubset_interval(interval(1/sqrt(2) , 1), sinpi(interval(0.25, 0.75))) @@ -49,7 +46,7 @@ end end @testset "cospi" begin - @test isequal_interval(cospi(emptyinterval()), emptyinterval()) + @test isempty_interval(cospi(emptyinterval())) @test isequal_interval(cospi(interval(1, 2)), interval(-1 , 1)) @test issubset_interval(interval(-1 , 0), cospi(interval(0.5, 1.5))) @test issubset_interval(interval(-1/sqrt(2) , 1/sqrt(2)), cospi(interval(0.25, 0.75))) @@ -58,7 +55,7 @@ end @testset "sincospi" begin x = sincospi(emptyinterval()) - @test isequal_interval(x[1], emptyinterval()) & isequal_interval(x[2], emptyinterval()) + @test isempty_interval(x[1]) & isempty_interval(x[2]) x = sincospi(interval(1, 2)) @test issubset_interval(interval(-1, 0), x[1]) & isequal_interval(x[2], interval(-1, 1)) x = sincospi(interval(0.5, 1.5)) @@ -87,7 +84,7 @@ end end @testset "Inverse trig" begin - @test isequal_interval(asin(interval(1)), interval(pi)/2) + @test isequal_interval(asin(interval(1)), interval(π)/interval(2)) @test isequal_interval(asin(interval(0.9, 2)), asin(interval(0.9, 1))) @test isequal_interval(asin(interval(3, 4)), emptyinterval()) @@ -104,7 +101,7 @@ end @test issubset_interval(acos(interval(BigFloat, 3, 4)), acos(interval(3, 4))) @test isequal_interval(atan(interval(-1,1)), - interval(-interval(Float64, π).hi/4, interval(Float64, π).hi/4)) + interval(-interval(sup(interval(Float64, π)))/interval(4), interval(sup(interval(Float64, π)))/interval(4))) @test isequal_interval(atan(interval(0)), interval(0.0, 0.0)) @test issubset_interval(atan(interval(BigFloat, -1, 1)), atan(interval(-1, 1))) end @@ -112,9 +109,9 @@ end @testset "atan" begin @test isequal_interval(atan(emptyinterval(), entireinterval()), emptyinterval()) @test isequal_interval(atan(entireinterval(), emptyinterval()), emptyinterval()) - @test isequal_interval(atan(interval(0.0, 1.0), interval(BigFloat, 0.0, 0.0)), interval(BigFloat, π)/2) - @test isequal_interval(atan(interval(0.0, 1.0), interval(0.0)), interval(π)/2) - @test isequal_interval(atan(interval(-1.0, -0.1), interval(0.0)), -interval(π)/2) + @test isequal_interval(atan(interval(0.0, 1.0), interval(BigFloat, 0.0, 0.0)), interval(BigFloat, π)/interval(2)) + @test isequal_interval(atan(interval(0.0, 1.0), interval(0.0)), interval(π)/interval(2)) + @test isequal_interval(atan(interval(-1.0, -0.1), interval(0.0)), -interval(π)/interval(2)) @test isequal_interval(atan(interval(-1.0, 1.0), interval(0.0)), interval(-0.5, 0.5) * interval(π)) @test isequal_interval(atan(interval(0.0), interval(0.1, 1.0)), interval(0.0)) @test issubset_interval(atan(interval(BigFloat, 0.0, 0.1), interval(BigFloat, 0.1, 1.0)), @@ -227,7 +224,7 @@ end end @testset "Trig with large arguments" begin - x = interval(2.)^1000 # this is a thin interval + x = nthpow(interval(2.), 1000) @test diam(x) == 0.0 @test isequal_interval(sin(x), interval(-0.15920170308624246, -0.15920170308624243)) diff --git a/test/runtests.jl b/test/runtests.jl index eb312a2d8..34126a985 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,8 +1,6 @@ using Test using IntervalArithmetic -using LinearAlgebra - -# IntervalArithmetic.:(isequal_interval)(a::Tuple, b::Tuple) = all(a .isequal_interval b) +using InteractiveUtils function include_test(filename) @testset "$filename" begin @@ -10,17 +8,8 @@ function include_test(filename) end end -# Interval tests: -include_test("interval_tests/intervals.jl") -include_test("decoration_tests/decoration_tests.jl") - -include_test("rand.jl") - -# Display tests: -include_test("display_tests/display.jl") - -# Multidim tests -include_test("multidim_tests/multidim.jl") +# interval tests +include_test("interval_tests/run_intervals.jl") # ITF1788 tests -include_test("test_ITF1788/run_ITF1788.jl") # TODO fix these tests +include_test("test_ITF1788/run_ITF1788.jl") # TODO fix these tests diff --git a/test/test_ITF1788/abs_rev.jl b/test/test_ITF1788/abs_rev.jl index cb0b44f87..ff5f869da 100644 --- a/test/test_ITF1788/abs_rev.jl +++ b/test/test_ITF1788/abs_rev.jl @@ -1,51 +1,51 @@ @testset "minimal.absRevBin_test" begin - @test isequal_interval(abs_rev(emptyinterval(), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(0.0, 1.0), emptyinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(0.0, 1.0), emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(0.0, 1.0), interval(7.0, 9.0))[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(0.0, 1.0), bareinterval(7.0, 9.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(emptyinterval(), interval(0.0, 1.0))[2], emptyinterval()) + @test isequal_interval(abs_rev(emptyinterval(BareInterval{Float64}), bareinterval(0.0, 1.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-2.0, -1.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-2.0, -1.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(1.0, 1.0), entireinterval())[2], interval(-1.0, 1.0)) + @test isequal_interval(abs_rev(bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64}))[2], bareinterval(-1.0, 1.0)) - @test isequal_interval(abs_rev(interval(0.0, 0.0), entireinterval())[2], interval(0.0, 0.0)) + @test isequal_interval(abs_rev(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64}))[2], bareinterval(0.0, 0.0)) - @test isequal_interval(abs_rev(interval(-1.0, -1.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-1.0, -1.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), entireinterval())[2], interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(abs_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), entireinterval(BareInterval{Float64}))[2], bareinterval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(abs_rev(interval(0x1p-1022, 0x1p-1022), entireinterval())[2], interval(-0x1p-1022, 0x1p-1022)) + @test isequal_interval(abs_rev(bareinterval(0x1p-1022, 0x1p-1022), entireinterval(BareInterval{Float64}))[2], bareinterval(-0x1p-1022, 0x1p-1022)) - @test isequal_interval(abs_rev(interval(-0x1p-1022, -0x1p-1022), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-0x1p-1022, -0x1p-1022), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-0x1.FFFFFFFFFFFFFp1023, -0x1.FFFFFFFFFFFFFp1023), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-0x1.FFFFFFFFFFFFFp1023, -0x1.FFFFFFFFFFFFFp1023), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(1.0, 2.0), entireinterval())[2], interval(-2.0, 2.0)) + @test isequal_interval(abs_rev(bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64}))[2], bareinterval(-2.0, 2.0)) - @test isequal_interval(abs_rev(interval(1.0, 2.0), interval(0.0, 2.0))[2], interval(1.0, 2.0)) + @test isequal_interval(abs_rev(bareinterval(1.0, 2.0), bareinterval(0.0, 2.0))[2], bareinterval(1.0, 2.0)) - @test isequal_interval(abs_rev(interval(0.0, 1.0), interval(-0.5, 2.0))[2], interval(-0.5, 1.0)) + @test isequal_interval(abs_rev(bareinterval(0.0, 1.0), bareinterval(-0.5, 2.0))[2], bareinterval(-0.5, 1.0)) - @test isequal_interval(abs_rev(interval(-1.0, 1.0), entireinterval())[2], interval(-1.0, 1.0)) + @test isequal_interval(abs_rev(bareinterval(-1.0, 1.0), entireinterval(BareInterval{Float64}))[2], bareinterval(-1.0, 1.0)) - @test isequal_interval(abs_rev(interval(-1.0, 0.0), entireinterval())[2], interval(0.0, 0.0)) + @test isequal_interval(abs_rev(bareinterval(-1.0, 0.0), entireinterval(BareInterval{Float64}))[2], bareinterval(0.0, 0.0)) - @test isequal_interval(abs_rev(interval(0.0, Inf), entireinterval())[2], entireinterval()) + @test isequal_interval(abs_rev(bareinterval(0.0, Inf), entireinterval(BareInterval{Float64}))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(entireinterval(), entireinterval())[2], entireinterval()) + @test isequal_interval(abs_rev(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-Inf, 0.0), entireinterval())[2], interval(0.0, 0.0)) + @test isequal_interval(abs_rev(bareinterval(-Inf, 0.0), entireinterval(BareInterval{Float64}))[2], bareinterval(0.0, 0.0)) - @test isequal_interval(abs_rev(interval(1.0, Inf), interval(-Inf, 0.0))[2], interval(-Inf, -1.0)) + @test isequal_interval(abs_rev(bareinterval(1.0, Inf), bareinterval(-Inf, 0.0))[2], bareinterval(-Inf, -1.0)) - @test isequal_interval(abs_rev(interval(-1.0, Inf), entireinterval())[2], entireinterval()) + @test isequal_interval(abs_rev(bareinterval(-1.0, Inf), entireinterval(BareInterval{Float64}))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-Inf, -1.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-Inf, 1.0), entireinterval())[2], interval(-1.0, 1.0)) + @test isequal_interval(abs_rev(bareinterval(-Inf, 1.0), entireinterval(BareInterval{Float64}))[2], bareinterval(-1.0, 1.0)) end diff --git a/test/test_ITF1788/atan2.jl b/test/test_ITF1788/atan2.jl index cdd55aadb..2f76a0a09 100644 --- a/test/test_ITF1788/atan2.jl +++ b/test/test_ITF1788/atan2.jl @@ -1,79 +1,79 @@ @testset "minimal.atan2_test" begin - @test isequal_interval(atan(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(entireinterval(), entireinterval()), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-Inf, 0.0)), interval(0x1.921FB54442D18p1, 0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)), bareinterval(0x1.921FB54442D18p1, 0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, Inf)), interval(0.0, 0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, Inf)), bareinterval(0.0, 0.0)) - @test isequal_interval(atan(interval(0.0, Inf), interval(0.0, 0.0)), interval(0x1.921FB54442D18p0, 0x1.921FB54442D19p0)) + @test isequal_interval(atan(bareinterval(0.0, Inf), bareinterval(0.0, 0.0)), bareinterval(0x1.921FB54442D18p0, 0x1.921FB54442D19p0)) - @test isequal_interval(atan(interval(-Inf, 0.0), interval(0.0, 0.0)), interval(-0x1.921FB54442D19p0, -0x1.921FB54442D18p0)) + @test isequal_interval(atan(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19p0, -0x1.921FB54442D18p0)) - @test isequal_interval(atan(interval(-0x1p-1022, 0.0), interval(-0x1p-1022, -0x1p-1022)), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(-0x1p-1022, 0.0), bareinterval(-0x1p-1022, -0x1p-1022)), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(1.0, 1.0), interval(-1.0, -1.0)), interval(0x1.2D97C7F3321D2p1, 0x1.2D97C7F3321D3p1)) + @test isequal_interval(atan(bareinterval(1.0, 1.0), bareinterval(-1.0, -1.0)), bareinterval(0x1.2D97C7F3321D2p1, 0x1.2D97C7F3321D3p1)) - @test isequal_interval(atan(interval(1.0, 1.0), interval(1.0, 1.0)), interval(0x1.921FB54442D18p-1, 0x1.921FB54442D19p-1)) + @test isequal_interval(atan(bareinterval(1.0, 1.0), bareinterval(1.0, 1.0)), bareinterval(0x1.921FB54442D18p-1, 0x1.921FB54442D19p-1)) - @test isequal_interval(atan(interval(-1.0, -1.0), interval(1.0, 1.0)), interval(-0x1.921FB54442D19p-1, -0x1.921FB54442D18p-1)) + @test isequal_interval(atan(bareinterval(-1.0, -1.0), bareinterval(1.0, 1.0)), bareinterval(-0x1.921FB54442D19p-1, -0x1.921FB54442D18p-1)) - @test isequal_interval(atan(interval(-1.0, -1.0), interval(-1.0, -1.0)), interval(-0x1.2D97C7F3321D3p1, -0x1.2D97C7F3321D2p1)) + @test isequal_interval(atan(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)), bareinterval(-0x1.2D97C7F3321D3p1, -0x1.2D97C7F3321D2p1)) - @test isequal_interval(atan(interval(-0x1p-1022, 0x1p-1022), interval(-0x1p-1022, -0x1p-1022)), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(-0x1p-1022, 0x1p-1022), bareinterval(-0x1p-1022, -0x1p-1022)), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(-0x1p-1022, 0x1p-1022), interval(0x1p-1022, 0x1p-1022)), interval(-0x1.921FB54442D19p-1, +0x1.921FB54442D19p-1)) + @test isequal_interval(atan(bareinterval(-0x1p-1022, 0x1p-1022), bareinterval(0x1p-1022, 0x1p-1022)), bareinterval(-0x1.921FB54442D19p-1, +0x1.921FB54442D19p-1)) - @test isequal_interval(atan(interval(-0x1p-1022, -0x1p-1022), interval(-0x1p-1022, 0x1p-1022)), interval(-0x1.2D97C7F3321D3p1, -0x1.921FB54442D18p-1)) + @test isequal_interval(atan(bareinterval(-0x1p-1022, -0x1p-1022), bareinterval(-0x1p-1022, 0x1p-1022)), bareinterval(-0x1.2D97C7F3321D3p1, -0x1.921FB54442D18p-1)) - @test isequal_interval(atan(interval(0x1p-1022, 0x1p-1022), interval(-0x1p-1022, 0x1p-1022)), interval(0x1.921FB54442D18p-1, 0x1.2D97C7F3321D3p1)) + @test isequal_interval(atan(bareinterval(0x1p-1022, 0x1p-1022), bareinterval(-0x1p-1022, 0x1p-1022)), bareinterval(0x1.921FB54442D18p-1, 0x1.2D97C7F3321D3p1)) - @test isequal_interval(atan(interval(-2.0, 2.0), interval(-3.0, -1.0)), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(-2.0, 2.0), bareinterval(-3.0, -1.0)), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(0.0, 2.0), interval(-3.0, -1.0)), interval(0x1.0468A8ACE4DF6p1, 0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(0.0, 2.0), bareinterval(-3.0, -1.0)), bareinterval(0x1.0468A8ACE4DF6p1, 0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(1.0, 3.0), interval(-3.0, -1.0)), interval(0x1.E47DF3D0DD4Dp0, 0x1.68F095FDF593Dp1)) + @test isequal_interval(atan(bareinterval(1.0, 3.0), bareinterval(-3.0, -1.0)), bareinterval(0x1.E47DF3D0DD4Dp0, 0x1.68F095FDF593Dp1)) - @test isequal_interval(atan(interval(1.0, 3.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18p0, 0x1.56C6E7397F5AFp1)) + @test isequal_interval(atan(bareinterval(1.0, 3.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18p0, 0x1.56C6E7397F5AFp1)) - @test isequal_interval(atan(interval(1.0, 3.0), interval(-2.0, 2.0)), interval(0x1.DAC670561BB4Fp-2, 0x1.56C6E7397F5AFp1)) + @test isequal_interval(atan(bareinterval(1.0, 3.0), bareinterval(-2.0, 2.0)), bareinterval(0x1.DAC670561BB4Fp-2, 0x1.56C6E7397F5AFp1)) - @test isequal_interval(atan(interval(1.0, 3.0), interval(0.0, 2.0)), interval(0x1.DAC670561BB4Fp-2, 0x1.921FB54442D19p0)) + @test isequal_interval(atan(bareinterval(1.0, 3.0), bareinterval(0.0, 2.0)), bareinterval(0x1.DAC670561BB4Fp-2, 0x1.921FB54442D19p0)) - @test isequal_interval(atan(interval(1.0, 3.0), interval(1.0, 3.0)), interval(0x1.4978FA3269EE1p-2, 0x1.3FC176B7A856p0)) + @test isequal_interval(atan(bareinterval(1.0, 3.0), bareinterval(1.0, 3.0)), bareinterval(0x1.4978FA3269EE1p-2, 0x1.3FC176B7A856p0)) - @test isequal_interval(atan(interval(0.0, 2.0), interval(1.0, 3.0)), interval(0x0p0, 0x1.1B6E192EBBE45p0)) + @test isequal_interval(atan(bareinterval(0.0, 2.0), bareinterval(1.0, 3.0)), bareinterval(0x0p0, 0x1.1B6E192EBBE45p0)) - @test isequal_interval(atan(interval(-2.0, 2.0), interval(1.0, 3.0)), interval(-0x1.1B6E192EBBE45p0, +0x1.1B6E192EBBE45p0)) + @test isequal_interval(atan(bareinterval(-2.0, 2.0), bareinterval(1.0, 3.0)), bareinterval(-0x1.1B6E192EBBE45p0, +0x1.1B6E192EBBE45p0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(1.0, 3.0)), interval(-0x1.1B6E192EBBE45p0, 0x0p0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(1.0, 3.0)), bareinterval(-0x1.1B6E192EBBE45p0, 0x0p0)) - @test isequal_interval(atan(interval(-3.0, -1.0), interval(1.0, 3.0)), interval(-0x1.3FC176B7A856p0, -0x1.4978FA3269EE1p-2)) + @test isequal_interval(atan(bareinterval(-3.0, -1.0), bareinterval(1.0, 3.0)), bareinterval(-0x1.3FC176B7A856p0, -0x1.4978FA3269EE1p-2)) - @test isequal_interval(atan(interval(-3.0, -1.0), interval(0.0, 2.0)), interval(-0x1.921FB54442D19p0, -0x1.DAC670561BB4Fp-2)) + @test isequal_interval(atan(bareinterval(-3.0, -1.0), bareinterval(0.0, 2.0)), bareinterval(-0x1.921FB54442D19p0, -0x1.DAC670561BB4Fp-2)) - @test isequal_interval(atan(interval(-3.0, -1.0), interval(-2.0, 2.0)), interval(-0x1.56C6E7397F5AFp1, -0x1.DAC670561BB4Fp-2)) + @test isequal_interval(atan(bareinterval(-3.0, -1.0), bareinterval(-2.0, 2.0)), bareinterval(-0x1.56C6E7397F5AFp1, -0x1.DAC670561BB4Fp-2)) - @test isequal_interval(atan(interval(-3.0, -1.0), interval(-2.0, 0.0)), interval(-0x1.56C6E7397F5AFp1, -0x1.921FB54442D18p0)) + @test isequal_interval(atan(bareinterval(-3.0, -1.0), bareinterval(-2.0, 0.0)), bareinterval(-0x1.56C6E7397F5AFp1, -0x1.921FB54442D18p0)) - @test isequal_interval(atan(interval(-3.0, -1.0), interval(-3.0, -1.0)), interval(-0x1.68F095FDF593Dp1, -0x1.E47DF3D0DD4Dp0)) + @test isequal_interval(atan(bareinterval(-3.0, -1.0), bareinterval(-3.0, -1.0)), bareinterval(-0x1.68F095FDF593Dp1, -0x1.E47DF3D0DD4Dp0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-3.0, -1.0)), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-3.0, -1.0)), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(-5.0, 0.0), interval(-5.0, 0.0)), interval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(-5.0, 0.0), bareinterval(-5.0, 0.0)), bareinterval(-0x1.921FB54442D19p1, +0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(0.0, 5.0), interval(-5.0, 0.0)), interval(0x1.921FB54442D18p0, 0x1.921FB54442D19p1)) + @test isequal_interval(atan(bareinterval(0.0, 5.0), bareinterval(-5.0, 0.0)), bareinterval(0x1.921FB54442D18p0, 0x1.921FB54442D19p1)) - @test isequal_interval(atan(interval(0.0, 5.0), interval(0.0, 5.0)), interval(0x0p0, 0x1.921FB54442D19p0)) + @test isequal_interval(atan(bareinterval(0.0, 5.0), bareinterval(0.0, 5.0)), bareinterval(0x0p0, 0x1.921FB54442D19p0)) - @test isequal_interval(atan(interval(-5.0, 0.0), interval(0.0, 5.0)), interval(-0x1.921FB54442D19p0, 0x0p0)) + @test isequal_interval(atan(bareinterval(-5.0, 0.0), bareinterval(0.0, 5.0)), bareinterval(-0x1.921FB54442D19p0, 0x0p0)) end diff --git a/test/test_ITF1788/c-xsc.jl b/test/test_ITF1788/c-xsc.jl index 94a72015b..538967281 100644 --- a/test/test_ITF1788/c-xsc.jl +++ b/test/test_ITF1788/c-xsc.jl @@ -1,351 +1,351 @@ @testset "cxsc.intervaladdsub" begin - @test isequal_interval(+(interval(10.0, 20.0), interval(13.0, 17.0)), interval(23.0, 37.0)) + @test isequal_interval(+(bareinterval(10.0, 20.0), bareinterval(13.0, 17.0)), bareinterval(23.0, 37.0)) - @test isequal_interval(+(interval(13.0, 17.0), interval(10.0, 20.0)), interval(23.0, 37.0)) + @test isequal_interval(+(bareinterval(13.0, 17.0), bareinterval(10.0, 20.0)), bareinterval(23.0, 37.0)) - @test isequal_interval(-(interval(10.0, 20.0), interval(13.0, 16.0)), interval(-6.0, 7.0)) + @test isequal_interval(-(bareinterval(10.0, 20.0), bareinterval(13.0, 16.0)), bareinterval(-6.0, 7.0)) - @test isequal_interval(-(interval(13.0, 16.0), interval(10.0, 20.0)), interval(-7.0, 6.0)) + @test isequal_interval(-(bareinterval(13.0, 16.0), bareinterval(10.0, 20.0)), bareinterval(-7.0, 6.0)) - @test isequal_interval(-(interval(10.0, 20.0)), interval(-20.0, -10.0)) + @test isequal_interval(-(bareinterval(10.0, 20.0)), bareinterval(-20.0, -10.0)) - @test isequal_interval(+(interval(10.0, 20.0)), interval(10.0, 20.0)) + @test isequal_interval(+(bareinterval(10.0, 20.0)), bareinterval(10.0, 20.0)) end @testset "cxsc.intervalmuldiv" begin - @test isequal_interval(*(interval(1.0, 2.0), interval(3.0, 4.0)), interval(3.0, 8.0)) + @test isequal_interval(*(bareinterval(1.0, 2.0), bareinterval(3.0, 4.0)), bareinterval(3.0, 8.0)) - @test isequal_interval(*(interval(-1.0, 2.0), interval(3.0, 4.0)), interval(-4.0, 8.0)) + @test isequal_interval(*(bareinterval(-1.0, 2.0), bareinterval(3.0, 4.0)), bareinterval(-4.0, 8.0)) - @test isequal_interval(*(interval(-2.0, 1.0), interval(3.0, 4.0)), interval(-8.0, 4.0)) + @test isequal_interval(*(bareinterval(-2.0, 1.0), bareinterval(3.0, 4.0)), bareinterval(-8.0, 4.0)) - @test isequal_interval(*(interval(-2.0, -1.0), interval(3.0, 4.0)), interval(-8.0, -3.0)) + @test isequal_interval(*(bareinterval(-2.0, -1.0), bareinterval(3.0, 4.0)), bareinterval(-8.0, -3.0)) - @test isequal_interval(*(interval(1.0, 2.0), interval(-3.0, 4.0)), interval(-6.0, 8.0)) + @test isequal_interval(*(bareinterval(1.0, 2.0), bareinterval(-3.0, 4.0)), bareinterval(-6.0, 8.0)) - @test isequal_interval(*(interval(-1.0, 2.0), interval(-3.0, 4.0)), interval(-6.0, 8.0)) + @test isequal_interval(*(bareinterval(-1.0, 2.0), bareinterval(-3.0, 4.0)), bareinterval(-6.0, 8.0)) - @test isequal_interval(*(interval(-2.0, 1.0), interval(-3.0, 4.0)), interval(-8.0, 6.0)) + @test isequal_interval(*(bareinterval(-2.0, 1.0), bareinterval(-3.0, 4.0)), bareinterval(-8.0, 6.0)) - @test isequal_interval(*(interval(-2.0, -1.0), interval(-3.0, 4.0)), interval(-8.0, 6.0)) + @test isequal_interval(*(bareinterval(-2.0, -1.0), bareinterval(-3.0, 4.0)), bareinterval(-8.0, 6.0)) - @test isequal_interval(*(interval(1.0, 2.0), interval(-4.0, 3.0)), interval(-8.0, 6.0)) + @test isequal_interval(*(bareinterval(1.0, 2.0), bareinterval(-4.0, 3.0)), bareinterval(-8.0, 6.0)) - @test isequal_interval(*(interval(-1.0, 2.0), interval(-4.0, 3.0)), interval(-8.0, 6.0)) + @test isequal_interval(*(bareinterval(-1.0, 2.0), bareinterval(-4.0, 3.0)), bareinterval(-8.0, 6.0)) - @test isequal_interval(*(interval(-2.0, 1.0), interval(-4.0, 3.0)), interval(-6.0, 8.0)) + @test isequal_interval(*(bareinterval(-2.0, 1.0), bareinterval(-4.0, 3.0)), bareinterval(-6.0, 8.0)) - @test isequal_interval(*(interval(-2.0, -1.0), interval(-4.0, 3.0)), interval(-6.0, 8.0)) + @test isequal_interval(*(bareinterval(-2.0, -1.0), bareinterval(-4.0, 3.0)), bareinterval(-6.0, 8.0)) - @test isequal_interval(*(interval(1.0, 2.0), interval(-4.0, -3.0)), interval(-8.0, -3.0)) + @test isequal_interval(*(bareinterval(1.0, 2.0), bareinterval(-4.0, -3.0)), bareinterval(-8.0, -3.0)) - @test isequal_interval(*(interval(-1.0, 2.0), interval(-4.0, -3.0)), interval(-8.0, 4.0)) + @test isequal_interval(*(bareinterval(-1.0, 2.0), bareinterval(-4.0, -3.0)), bareinterval(-8.0, 4.0)) - @test isequal_interval(*(interval(-2.0, -1.0), interval(-4.0, -3.0)), interval(3.0, 8.0)) + @test isequal_interval(*(bareinterval(-2.0, -1.0), bareinterval(-4.0, -3.0)), bareinterval(3.0, 8.0)) - @test isequal_interval(/(interval(1.0, 2.0), interval(4.0, 8.0)), interval(0.125, 0.5)) + @test isequal_interval(/(bareinterval(1.0, 2.0), bareinterval(4.0, 8.0)), bareinterval(0.125, 0.5)) - @test isequal_interval(/(interval(-1.0, 2.0), interval(4.0, 8.0)), interval(-0.25, 0.5)) + @test isequal_interval(/(bareinterval(-1.0, 2.0), bareinterval(4.0, 8.0)), bareinterval(-0.25, 0.5)) - @test isequal_interval(/(interval(-2.0, 1.0), interval(4.0, 8.0)), interval(-0.5, 0.25)) + @test isequal_interval(/(bareinterval(-2.0, 1.0), bareinterval(4.0, 8.0)), bareinterval(-0.5, 0.25)) - @test isequal_interval(/(interval(-2.0, -1.0), interval(4.0, 8.0)), interval(-0.5, -0.125)) + @test isequal_interval(/(bareinterval(-2.0, -1.0), bareinterval(4.0, 8.0)), bareinterval(-0.5, -0.125)) - @test isequal_interval(/(interval(1.0, 2.0), interval(-4.0, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(1.0, 2.0), bareinterval(-4.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-1.0, 2.0), interval(-4.0, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-1.0, 2.0), bareinterval(-4.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.0, 1.0), interval(-4.0, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-2.0, 1.0), bareinterval(-4.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.0, -1.0), interval(-4.0, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-2.0, -1.0), bareinterval(-4.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(1.0, 2.0), interval(-8.0, 4.0)), entireinterval()) + @test isequal_interval(/(bareinterval(1.0, 2.0), bareinterval(-8.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-1.0, 2.0), interval(-8.0, 4.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-1.0, 2.0), bareinterval(-8.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.0, 1.0), interval(-8.0, 4.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-2.0, 1.0), bareinterval(-8.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.0, -1.0), interval(-8.0, 4.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-2.0, -1.0), bareinterval(-8.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(1.0, 2.0), interval(-8.0, -4.0)), interval(-0.5, -0.125)) + @test isequal_interval(/(bareinterval(1.0, 2.0), bareinterval(-8.0, -4.0)), bareinterval(-0.5, -0.125)) - @test isequal_interval(/(interval(-1.0, 2.0), interval(-8.0, -4.0)), interval(-0.5, 0.25)) + @test isequal_interval(/(bareinterval(-1.0, 2.0), bareinterval(-8.0, -4.0)), bareinterval(-0.5, 0.25)) - @test isequal_interval(/(interval(-2.0, 1.0), interval(-8.0, -4.0)), interval(-0.25, 0.5)) + @test isequal_interval(/(bareinterval(-2.0, 1.0), bareinterval(-8.0, -4.0)), bareinterval(-0.25, 0.5)) - @test isequal_interval(/(interval(-2.0, -1.0), interval(-8.0, -4.0)), interval(0.125, 0.5)) + @test isequal_interval(/(bareinterval(-2.0, -1.0), bareinterval(-8.0, -4.0)), bareinterval(0.125, 0.5)) end @testset "cxsc.intervalsetops" begin - @test isequal_interval(hull(interval(-2.0, 2.0), interval(-4.0, -3.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(-4.0, -3.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(-4.0, -1.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(-4.0, -1.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(-4.0, 4.0)), interval(-4.0, 4.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(-4.0, 4.0)), bareinterval(-4.0, 4.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(-1.0, 1.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(-1.0, 1.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(1.0, 4.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(1.0, 4.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(3.0, 4.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(3.0, 4.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(hull(interval(-4.0, -3.0), interval(-2.0, 2.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-4.0, -3.0), bareinterval(-2.0, 2.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(-4.0, -1.0), interval(-2.0, 2.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-4.0, -1.0), bareinterval(-2.0, 2.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(-4.0, 4.0), interval(-2.0, 2.0)), interval(-4.0, 4.0)) + @test isequal_interval(hull(bareinterval(-4.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(-4.0, 4.0)) - @test isequal_interval(hull(interval(-1.0, 1.0), interval(-2.0, 2.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(-1.0, 1.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(hull(interval(1.0, 4.0), interval(-2.0, 2.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(1.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(hull(interval(3.0, 4.0), interval(-2.0, 2.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(3.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(-4.0, -3.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(-4.0, -3.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(-4.0, -1.0)), interval(-2.0, -1.0)) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(-4.0, -1.0)), bareinterval(-2.0, -1.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(-4.0, 4.0)), interval(-2.0, 2.0)) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(-4.0, 4.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(-1.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(1.0, 4.0)), interval(1.0, 2.0)) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(1.0, 4.0)), bareinterval(1.0, 2.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(3.0, 4.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(3.0, 4.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-4.0, -3.0), interval(-2.0, 2.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-4.0, -3.0), bareinterval(-2.0, 2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-4.0, -1.0), interval(-2.0, 2.0)), interval(-2.0, -1.0)) + @test isequal_interval(intersect_interval(bareinterval(-4.0, -1.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, -1.0)) - @test isequal_interval(intersect_interval(interval(-4.0, 4.0), interval(-2.0, 2.0)), interval(-2.0, 2.0)) + @test isequal_interval(intersect_interval(bareinterval(-4.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(intersect_interval(interval(-1.0, 1.0), interval(-2.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(intersect_interval(bareinterval(-1.0, 1.0), bareinterval(-2.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(intersect_interval(interval(1.0, 4.0), interval(-2.0, 2.0)), interval(1.0, 2.0)) + @test isequal_interval(intersect_interval(bareinterval(1.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(1.0, 2.0)) - @test isequal_interval(intersect_interval(interval(3.0, 4.0), interval(-2.0, 2.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(3.0, 4.0), bareinterval(-2.0, 2.0)), emptyinterval(BareInterval{Float64})) end @testset "cxsc.intervalmixsetops" begin - @test isequal_interval(hull(interval(-2.0, 2.0), interval(-4.0, -4.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(-4.0, -4.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(1.0, 1.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(1.0, 1.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(hull(interval(-2.0, 2.0), interval(4.0, 4.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(-2.0, 2.0), bareinterval(4.0, 4.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(hull(interval(-4.0, -4.0), interval(-2.0, 2.0)), interval(-4.0, 2.0)) + @test isequal_interval(hull(bareinterval(-4.0, -4.0), bareinterval(-2.0, 2.0)), bareinterval(-4.0, 2.0)) - @test isequal_interval(hull(interval(1.0, 1.0), interval(-2.0, 2.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(1.0, 1.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(hull(interval(4.0, 4.0), interval(-2.0, 2.0)), interval(-2.0, 4.0)) + @test isequal_interval(hull(bareinterval(4.0, 4.0), bareinterval(-2.0, 2.0)), bareinterval(-2.0, 4.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(-4.0, -4.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(-4.0, -4.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(1.0, 1.0)), interval(1.0, 1.0)) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(1.0, 1.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(intersect_interval(interval(-2.0, 2.0), interval(4.0, 4.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-2.0, 2.0), bareinterval(4.0, 4.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-4.0, -4.0), interval(-2.0, 2.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-4.0, -4.0), bareinterval(-2.0, 2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(1.0, 1.0), interval(-2.0, 2.0)), interval(1.0, 1.0)) + @test isequal_interval(intersect_interval(bareinterval(1.0, 1.0), bareinterval(-2.0, 2.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(intersect_interval(interval(4.0, 4.0), interval(-2.0, 2.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(4.0, 4.0), bareinterval(-2.0, 2.0)), emptyinterval(BareInterval{Float64})) end @testset "cxsc.scalarmixsetops" begin - @test isequal_interval(hull(interval(-2.0, -2.0), interval(-4.0, -4.0)), interval(-4.0, -2.0)) + @test isequal_interval(hull(bareinterval(-2.0, -2.0), bareinterval(-4.0, -4.0)), bareinterval(-4.0, -2.0)) - @test isequal_interval(hull(interval(-2.0, -2.0), interval(-2.0, -2.0)), interval(-2.0, -2.0)) + @test isequal_interval(hull(bareinterval(-2.0, -2.0), bareinterval(-2.0, -2.0)), bareinterval(-2.0, -2.0)) - @test isequal_interval(hull(interval(-2.0, -2.0), interval(2.0, 2.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(-2.0, -2.0), bareinterval(2.0, 2.0)), bareinterval(-2.0, 2.0)) - @test isequal_interval(hull(interval(-4.0, -4.0), interval(-2.0, -2.0)), interval(-4.0, -2.0)) + @test isequal_interval(hull(bareinterval(-4.0, -4.0), bareinterval(-2.0, -2.0)), bareinterval(-4.0, -2.0)) - @test isequal_interval(hull(interval(-2.0, -2.0), interval(-2.0, -2.0)), interval(-2.0, -2.0)) + @test isequal_interval(hull(bareinterval(-2.0, -2.0), bareinterval(-2.0, -2.0)), bareinterval(-2.0, -2.0)) - @test isequal_interval(hull(interval(2.0, 2.0), interval(-2.0, -2.0)), interval(-2.0, 2.0)) + @test isequal_interval(hull(bareinterval(2.0, 2.0), bareinterval(-2.0, -2.0)), bareinterval(-2.0, 2.0)) end @testset "cxsc.intervalsetcompops" begin - @test isstrictsubset_interval(interval(-1.0, 2.0), interval(-1.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, 2.0), bareinterval(-1.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 1.0), interval(-3.0, 2.0)) == true + @test isstrictsubset_interval(bareinterval(-2.0, 1.0), bareinterval(-3.0, 2.0)) == true - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-1.0, 1.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 1.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-1.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-2.0, 1.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 1.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-2.0, 3.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 3.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-3.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-3.0, 2.0)) == false - @test isstrictsubset_interval(interval(-1.0, 2.0), interval(-1.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, 2.0), bareinterval(-1.0, 2.0)) == false - @test isstrictsubset_interval(interval(-3.0, 2.0), interval(-2.0, 1.0)) == false + @test isstrictsubset_interval(bareinterval(-3.0, 2.0), bareinterval(-2.0, 1.0)) == false - @test isstrictsubset_interval(interval(-1.0, 1.0), interval(-2.0, 2.0)) == true + @test isstrictsubset_interval(bareinterval(-1.0, 1.0), bareinterval(-2.0, 2.0)) == true - @test isstrictsubset_interval(interval(-1.0, 2.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, 2.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 1.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 1.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 3.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 3.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(-3.0, 2.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-3.0, 2.0), bareinterval(-2.0, 2.0)) == false - @test issubset_interval(interval(-1.0, 2.0), interval(-1.0, 2.0)) == true + @test issubset_interval(bareinterval(-1.0, 2.0), bareinterval(-1.0, 2.0)) == true - @test issubset_interval(interval(-2.0, 1.0), interval(-3.0, 2.0)) == true + @test issubset_interval(bareinterval(-2.0, 1.0), bareinterval(-3.0, 2.0)) == true - @test issubset_interval(interval(-2.0, 2.0), interval(-1.0, 1.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 1.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(-1.0, 2.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 2.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(-2.0, 1.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 1.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(-2.0, 3.0)) == true + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 3.0)) == true - @test issubset_interval(interval(-2.0, 2.0), interval(-3.0, 2.0)) == true + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-3.0, 2.0)) == true - @test issubset_interval(interval(-3.0, 2.0), interval(-2.0, 1.0)) == false + @test issubset_interval(bareinterval(-3.0, 2.0), bareinterval(-2.0, 1.0)) == false - @test issubset_interval(interval(-1.0, 1.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(-1.0, 1.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(-1.0, 2.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(-1.0, 2.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(-2.0, 1.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(-2.0, 1.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(-2.0, 3.0), interval(-2.0, 2.0)) == false + @test issubset_interval(bareinterval(-2.0, 3.0), bareinterval(-2.0, 2.0)) == false - @test issubset_interval(interval(-3.0, 2.0), interval(-2.0, 2.0)) == false + @test issubset_interval(bareinterval(-3.0, 2.0), bareinterval(-2.0, 2.0)) == false - @test isequal_interval(interval(-1.0, 2.0), interval(-1.0, 2.0)) == true + @test isequal_interval(bareinterval(-1.0, 2.0), bareinterval(-1.0, 2.0)) == true - @test isequal_interval(interval(-2.0, 1.0), interval(-3.0, 2.0)) == false + @test isequal_interval(bareinterval(-2.0, 1.0), bareinterval(-3.0, 2.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-1.0, 1.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 1.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-1.0, 2.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-1.0, 2.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-2.0, 1.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 1.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-2.0, 3.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, 3.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-3.0, 2.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-3.0, 2.0)) == false end @testset "cxsc.intervalscalarsetcompops" begin - @test isstrictsubset_interval(interval(-1.0, 2.0), interval(-2.0, -2.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(-2.0, -2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(0.0, 0.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(0.0, 0.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(2.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, 2.0), interval(3.0, 3.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, 2.0), bareinterval(3.0, 3.0)) == false - @test isstrictsubset_interval(interval(-1.0, -1.0), interval(1.0, 1.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, -1.0), bareinterval(1.0, 1.0)) == false - @test isstrictsubset_interval(interval(-1.0, -1.0), interval(-1.0, -1.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)) == false - @test isstrictsubset_interval(interval(-2.0, -2.0), interval(-1.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, -2.0), bareinterval(-1.0, 2.0)) == false - @test isstrictsubset_interval(interval(-2.0, -2.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0, -2.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(0.0, 0.0), interval(-2.0, 2.0)) == true + @test isstrictsubset_interval(bareinterval(0.0, 0.0), bareinterval(-2.0, 2.0)) == true - @test isstrictsubset_interval(interval(2.0, 2.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(2.0, 2.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(3.0, 3.0), interval(-2.0, 2.0)) == false + @test isstrictsubset_interval(bareinterval(3.0, 3.0), bareinterval(-2.0, 2.0)) == false - @test isstrictsubset_interval(interval(1.0, 1.0), interval(-1.0, -1.0)) == false + @test isstrictsubset_interval(bareinterval(1.0, 1.0), bareinterval(-1.0, -1.0)) == false - @test isstrictsubset_interval(interval(-1.0, -1.0), interval(-1.0, -1.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)) == false - @test issubset_interval(interval(-1.0, 2.0), interval(-2.0, -2.0)) == false + @test issubset_interval(bareinterval(-1.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(-2.0, -2.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(0.0, 0.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(0.0, 0.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(2.0, 2.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(2.0, 2.0)) == false - @test issubset_interval(interval(-2.0, 2.0), interval(3.0, 3.0)) == false + @test issubset_interval(bareinterval(-2.0, 2.0), bareinterval(3.0, 3.0)) == false - @test issubset_interval(interval(-1.0, -1.0), interval(1.0, 1.0)) == false + @test issubset_interval(bareinterval(-1.0, -1.0), bareinterval(1.0, 1.0)) == false - @test issubset_interval(interval(-1.0, -1.0), interval(-1.0, -1.0)) == true + @test issubset_interval(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)) == true - @test issubset_interval(interval(-2.0, -2.0), interval(-1.0, 2.0)) == false + @test issubset_interval(bareinterval(-2.0, -2.0), bareinterval(-1.0, 2.0)) == false - @test issubset_interval(interval(-2.0, -2.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(-2.0, -2.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(0.0, 0.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(0.0, 0.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(2.0, 2.0), interval(-2.0, 2.0)) == true + @test issubset_interval(bareinterval(2.0, 2.0), bareinterval(-2.0, 2.0)) == true - @test issubset_interval(interval(3.0, 3.0), interval(-2.0, 2.0)) == false + @test issubset_interval(bareinterval(3.0, 3.0), bareinterval(-2.0, 2.0)) == false - @test issubset_interval(interval(1.0, 1.0), interval(-1.0, -1.0)) == false + @test issubset_interval(bareinterval(1.0, 1.0), bareinterval(-1.0, -1.0)) == false - @test issubset_interval(interval(-1.0, -1.0), interval(-1.0, -1.0)) == true + @test issubset_interval(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)) == true - @test isequal_interval(interval(-1.0, 2.0), interval(-2.0, -2.0)) == false + @test isequal_interval(bareinterval(-1.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(-2.0, -2.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(-2.0, -2.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(0.0, 0.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(0.0, 0.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(2.0, 2.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(2.0, 2.0)) == false - @test isequal_interval(interval(-2.0, 2.0), interval(3.0, 3.0)) == false + @test isequal_interval(bareinterval(-2.0, 2.0), bareinterval(3.0, 3.0)) == false - @test isequal_interval(interval(-1.0, -1.0), interval(1.0, 1.0)) == false + @test isequal_interval(bareinterval(-1.0, -1.0), bareinterval(1.0, 1.0)) == false - @test isequal_interval(interval(-1.0, -1.0), interval(-1.0, -1.0)) == true + @test isequal_interval(bareinterval(-1.0, -1.0), bareinterval(-1.0, -1.0)) == true end @testset "cxsc.intervalstdfunc" begin - @test isequal_interval(interval(11.0, 11.0)^2, interval(121.0, 121.0)) + @test isequal_interval(nthpow(bareinterval(11.0, 11.0), 2), bareinterval(121.0, 121.0)) - @test isequal_interval(interval(0.0, 0.0)^2, interval(0.0, 0.0)) + @test isequal_interval(nthpow(bareinterval(0.0, 0.0), 2), bareinterval(0.0, 0.0)) - @test isequal_interval(interval(-9.0, -9.0)^2, interval(81.0, 81.0)) + @test isequal_interval(nthpow(bareinterval(-9.0, -9.0), 2), bareinterval(81.0, 81.0)) - @test isequal_interval(sqrt(interval(121.0, 121.0)), interval(11.0, 11.0)) + @test isequal_interval(sqrt(bareinterval(121.0, 121.0)), bareinterval(11.0, 11.0)) - @test isequal_interval(sqrt(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(sqrt(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(sqrt(interval(81.0, 81.0)), interval(9.0, 9.0)) + @test isequal_interval(sqrt(bareinterval(81.0, 81.0)), bareinterval(9.0, 9.0)) - @test isequal_interval(nthroot(interval(27.0, 27.0), 3), interval(3.0, 3.0)) + @test isequal_interval(nthroot(bareinterval(27.0, 27.0), 3), bareinterval(3.0, 3.0)) - @test isequal_interval(nthroot(interval(0.0, 0.0), 4), interval(0.0, 0.0)) + @test isequal_interval(nthroot(bareinterval(0.0, 0.0), 4), bareinterval(0.0, 0.0)) - @test isequal_interval(nthroot(interval(1024.0, 1024.0), 10), interval(2.0, 2.0)) + @test isequal_interval(nthroot(bareinterval(1024.0, 1024.0), 10), bareinterval(2.0, 2.0)) - @test isequal_interval(^(interval(2.0, 2.0), interval(2.0, 2.0)), interval(4.0, 4.0)) + @test isequal_interval(^(bareinterval(2.0, 2.0), bareinterval(2.0, 2.0)), bareinterval(4.0, 4.0)) - @test isequal_interval(^(interval(4.0, 4.0), interval(5.0, 5.0)), interval(1024.0, 1024.0)) + @test isequal_interval(^(bareinterval(4.0, 4.0), bareinterval(5.0, 5.0)), bareinterval(1024.0, 1024.0)) - @test isequal_interval(^(interval(2.0, 2.0), interval(3.0, 3.0)), interval(8.0, 8.0)) + @test isequal_interval(^(bareinterval(2.0, 2.0), bareinterval(3.0, 3.0)), bareinterval(8.0, 8.0)) end diff --git a/test/test_ITF1788/fi_lib.jl b/test/test_ITF1788/fi_lib.jl index 936229c4a..cf3ee05e7 100644 --- a/test/test_ITF1788/fi_lib.jl +++ b/test/test_ITF1788/fi_lib.jl @@ -1,1745 +1,1745 @@ @testset "FI_LIB.addii" begin - @test isequal_interval(+(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(+(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x3.0000000000000P+0, 0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x3.0000000000000P+0, 0x3.0000000000000P+0)) - @test isequal_interval(+(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x3.0000000000000P+0, -0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, -0x3.0000000000000P+0)) - @test isequal_interval(+(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(+(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(+(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), interval(0x3.F400000000000P-1064, 0x3.F400000000000P-1064)) + @test isequal_interval(+(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), bareinterval(0x3.F400000000000P-1064, 0x3.F400000000000P-1064)) - @test isequal_interval(+(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(+(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(+(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), interval(-0x3.F400000000000P-1064, -0x3.F400000000000P-1064)) + @test isequal_interval(+(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), bareinterval(-0x3.F400000000000P-1064, -0x3.F400000000000P-1064)) - @test isequal_interval(+(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(+(interval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0xF.FFFFFFFFFFFF0P+1020, 0xF.FFFFFFFFFFFF8P+1020)) + @test isequal_interval(+(bareinterval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0xF.FFFFFFFFFFFF0P+1020, 0xF.FFFFFFFFFFFF8P+1020)) - @test isequal_interval(+(interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF0P+1020)) + @test isequal_interval(+(bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF0P+1020)) - @test isequal_interval(+(interval(0x0.0000000000000P+0, 0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) - @test isequal_interval(+(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) - @test isequal_interval(+(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0), interval(0x3.0000000000000P+0, 0x4.0000000000000P+0)), interval(0x4.0000000000000P+0, 0x6.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0), bareinterval(0x3.0000000000000P+0, 0x4.0000000000000P+0)), bareinterval(0x4.0000000000000P+0, 0x6.0000000000000P+0)) - @test isequal_interval(+(interval(0x3.0000000000000P+0, 0x4.0000000000000P+0), interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x4.0000000000000P+0, 0x6.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x3.0000000000000P+0, 0x4.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x4.0000000000000P+0, 0x6.0000000000000P+0)) - @test isequal_interval(+(interval(-0x1.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x4.0000000000000P+0, -0x3.0000000000000P+0)), interval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x1.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x4.0000000000000P+0, -0x3.0000000000000P+0)), bareinterval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)) - @test isequal_interval(+(interval(-0x4.0000000000000P+0, -0x3.0000000000000P+0), interval(-0x1.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x4.0000000000000P+0, -0x3.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)) - @test isequal_interval(+(interval(-0x5.0000000000000P+0, -0x4.0000000000000P+0), interval(0x4.0000000000000P+0, 0x5.0000000000000P+0)), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) + @test isequal_interval(+(bareinterval(-0x5.0000000000000P+0, -0x4.0000000000000P+0), bareinterval(0x4.0000000000000P+0, 0x5.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) - @test isequal_interval(+(interval(0x4.0000000000000P+0, 0x5.0000000000000P+0), interval(-0x5.0000000000000P+0, -0x4.0000000000000P+0)), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) + @test isequal_interval(+(bareinterval(0x4.0000000000000P+0, 0x5.0000000000000P+0), bareinterval(-0x5.0000000000000P+0, -0x4.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) end @testset "FI_LIB.subii" begin - @test isequal_interval(-(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(-(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x2.0000000000000P+0, 0x2.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x2.0000000000000P+0, 0x2.0000000000000P+0)) - @test isequal_interval(-(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x2.0000000000000P+0, -0x2.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0xF.FFFFFFFFFFFF8P-4)) + @test isequal_interval(-(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0xF.FFFFFFFFFFFF8P-4)) - @test isequal_interval(-(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(-(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) - @test isequal_interval(-(interval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0xF.FFFFFFFFFFFF0P+1020, 0xF.FFFFFFFFFFFF8P+1020)) + @test isequal_interval(-(bareinterval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0xF.FFFFFFFFFFFF0P+1020, 0xF.FFFFFFFFFFFF8P+1020)) - @test isequal_interval(-(interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF0P+1020)) + @test isequal_interval(-(bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF0P+1020)) - @test isequal_interval(-(interval(0x0.0000000000000P+0, 0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(-0x2.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(-0x2.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x2.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x2.0000000000000P+0)) - @test isequal_interval(-(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0), interval(0x3.0000000000000P+0, 0x4.0000000000000P+0)), interval(-0x3.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0), bareinterval(0x3.0000000000000P+0, 0x4.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(-(interval(0x3.0000000000000P+0, 0x4.0000000000000P+0), interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x3.0000000000000P+0, 0x4.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x3.0000000000000P+0)) - @test isequal_interval(-(interval(-0x1.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x4.0000000000000P+0, -0x3.0000000000000P+0)), interval(0x2.0000000000000P+0, 0x4.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x1.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x4.0000000000000P+0, -0x3.0000000000000P+0)), bareinterval(0x2.0000000000000P+0, 0x4.0000000000000P+0)) - @test isequal_interval(-(interval(-0x4.0000000000000P+0, -0x3.0000000000000P+0), interval(-0x1.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x4.0000000000000P+0, -0x2.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x4.0000000000000P+0, -0x3.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x4.0000000000000P+0, -0x2.0000000000000P+0)) - @test isequal_interval(-(interval(-0x5.0000000000000P+0, -0x4.0000000000000P+0), interval(0x4.0000000000000P+0, 0x5.0000000000000P+0)), interval(-0xA.0000000000000P+0, -0x8.0000000000000P+0)) + @test isequal_interval(-(bareinterval(-0x5.0000000000000P+0, -0x4.0000000000000P+0), bareinterval(0x4.0000000000000P+0, 0x5.0000000000000P+0)), bareinterval(-0xA.0000000000000P+0, -0x8.0000000000000P+0)) - @test isequal_interval(-(interval(0x4.0000000000000P+0, 0x5.0000000000000P+0), interval(-0x5.0000000000000P+0, -0x4.0000000000000P+0)), interval(0x8.0000000000000P+0, 0xA.0000000000000P+0)) + @test isequal_interval(-(bareinterval(0x4.0000000000000P+0, 0x5.0000000000000P+0), bareinterval(-0x5.0000000000000P+0, -0x4.0000000000000P+0)), bareinterval(0x8.0000000000000P+0, 0xA.0000000000000P+0)) end @testset "FI_LIB.mulii" begin - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(*(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(*(interval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), interval(0x8.0000000000000P-4, 0x8.0000000000000P-4)), interval(0x7.FFFFFFFFFFFFCP+1020, 0x7.FFFFFFFFFFFFCP+1020)) + @test isequal_interval(*(bareinterval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x8.0000000000000P-4, 0x8.0000000000000P-4)), bareinterval(0x7.FFFFFFFFFFFFCP+1020, 0x7.FFFFFFFFFFFFCP+1020)) - @test isequal_interval(*(interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), interval(0x8.0000000000000P-4, 0x8.0000000000000P-4)), interval(-0x7.FFFFFFFFFFFFCP+1020, -0x7.FFFFFFFFFFFFCP+1020)) + @test isequal_interval(*(bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x8.0000000000000P-4, 0x8.0000000000000P-4)), bareinterval(-0x7.FFFFFFFFFFFFCP+1020, -0x7.FFFFFFFFFFFFCP+1020)) - @test isequal_interval(*(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(*(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(*(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) + @test isequal_interval(*(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) - @test isequal_interval(*(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) + @test isequal_interval(*(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(0x4.0000000000000P+0, 0x9.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(0x4.0000000000000P+0, 0x9.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x9.0000000000000P+0, -0x4.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, -0x4.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x9.0000000000000P+0, -0x4.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, -0x4.0000000000000P+0)) - @test isequal_interval(*(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(0x4.0000000000000P+0, 0x9.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(0x4.0000000000000P+0, 0x9.0000000000000P+0)) - @test isequal_interval(*(interval(-0x5.0000000000000P+0, +0x2.0000000000000P+0), interval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), interval(-0xF.0000000000000P+0, +0x1.4000000000000P+4)) + @test isequal_interval(*(bareinterval(-0x5.0000000000000P+0, +0x2.0000000000000P+0), bareinterval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), bareinterval(-0xF.0000000000000P+0, +0x1.4000000000000P+4)) - @test isequal_interval(*(interval(-0x5.0000000000000P+0, +0x2.0000000000000P+0), interval(-0x3.0000000000000P+0, +0x8.0000000000000P+0)), interval(-0x2.8000000000000P+4, +0x1.0000000000000P+4)) + @test isequal_interval(*(bareinterval(-0x5.0000000000000P+0, +0x2.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, +0x8.0000000000000P+0)), bareinterval(-0x2.8000000000000P+4, +0x1.0000000000000P+4)) - @test isequal_interval(*(interval(-0x2.0000000000000P+0, +0x5.0000000000000P+0), interval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), interval(-0x1.4000000000000P+4, +0xF.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x2.0000000000000P+0, +0x5.0000000000000P+0), bareinterval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), bareinterval(-0x1.4000000000000P+4, +0xF.0000000000000P+0)) - @test isequal_interval(*(interval(-0x4.0000000000000P+0, +0x5.0000000000000P+0), interval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), interval(-0x1.4000000000000P+4, +0x1.0000000000000P+4)) + @test isequal_interval(*(bareinterval(-0x4.0000000000000P+0, +0x5.0000000000000P+0), bareinterval(-0x4.0000000000000P+0, +0x3.0000000000000P+0)), bareinterval(-0x1.4000000000000P+4, +0x1.0000000000000P+4)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) - @test isequal_interval(*(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(0x0.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(0x0.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), interval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)), bareinterval(-0x3.0000000000000P+0, +0x3.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x3.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x9.0000000000000P+0)) - @test isequal_interval(*(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x9.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x0.0000000000000P+0, 0x2.0000000000000P+0), interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), interval(-0x6.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x0.0000000000000P+0, 0x2.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(-0x6.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(*(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(*(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) + @test isequal_interval(*(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) - @test isequal_interval(*(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) + @test isequal_interval(*(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) - @test isequal_interval(*(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), interval(-0x4.0000000000000P-1076, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), bareinterval(-0x4.0000000000000P-1076, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(*(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(*(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) end @testset "FI_LIB.divii" begin - @test isequal_interval(/(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(/(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(/(interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(/(bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(/(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(/(interval(0x0.0000000000000P+0, 0x0.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(/(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)) - @test isequal_interval(/(interval(0x1.0000000000000P+0, 0x1.0000000000000P+0), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(/(interval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), interval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x7.FFFFFFFFFFFFCP+1020, 0x7.FFFFFFFFFFFFCP+1020)) + @test isequal_interval(/(bareinterval(0xF.FFFFFFFFFFFF8P+1020, 0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x7.FFFFFFFFFFFFCP+1020, 0x7.FFFFFFFFFFFFCP+1020)) - @test isequal_interval(/(interval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), interval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), interval(-0x7.FFFFFFFFFFFFCP+1020, -0x7.FFFFFFFFFFFFCP+1020)) + @test isequal_interval(/(bareinterval(-0xF.FFFFFFFFFFFF8P+1020, -0xF.FFFFFFFFFFFF8P+1020), bareinterval(0x2.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(-0x7.FFFFFFFFFFFFCP+1020, -0x7.FFFFFFFFFFFFCP+1020)) - @test isequal_interval(/(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(/(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) + @test isequal_interval(/(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(0x1.0000000000000P+0, 0x1.0000000000000P+0)), bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064)) - @test isequal_interval(/(interval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), interval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), interval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) + @test isequal_interval(/(bareinterval(0x1.FA00000000000P-1064, 0x1.FA00000000000P-1064), bareinterval(-0x1.0000000000000P+0, -0x1.0000000000000P+0)), bareinterval(-0x1.FA00000000000P-1064, -0x1.FA00000000000P-1064)) - @test isequal_interval(/(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(0xA.AAAAAAAAAAAA8P-4, 0x1.8000000000000P+0)) + @test isequal_interval(/(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(0xA.AAAAAAAAAAAA8P-4, 0x1.8000000000000P+0)) - @test isequal_interval(/(interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x1.8000000000000P+0, -0xA.AAAAAAAAAAAA8P-4)) + @test isequal_interval(/(bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x1.8000000000000P+0, -0xA.AAAAAAAAAAAA8P-4)) - @test isequal_interval(/(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x8.0000000000000P-4, +0x8.0000000000000P-4)) + @test isequal_interval(/(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x8.0000000000000P-4, +0x8.0000000000000P-4)) - @test isequal_interval(/(interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x8.0000000000000P-4, +0x8.0000000000000P-4)) + @test isequal_interval(/(bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x8.0000000000000P-4, +0x8.0000000000000P-4)) - @test isequal_interval(/(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x1.8000000000000P+0, -0xA.AAAAAAAAAAAA8P-4)) + @test isequal_interval(/(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x1.8000000000000P+0, -0xA.AAAAAAAAAAAA8P-4)) - @test isequal_interval(/(interval(0x2.0000000000000P+0, 0x3.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(0xA.AAAAAAAAAAAA8P-4, 0x1.8000000000000P+0)) + @test isequal_interval(/(bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(0xA.AAAAAAAAAAAA8P-4, 0x1.8000000000000P+0)) - @test isequal_interval(/(interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x1.8000000000000P+0)) + @test isequal_interval(/(bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x1.8000000000000P+0)) - @test isequal_interval(/(interval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(-0x1.8000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(/(bareinterval(-0x3.0000000000000P+0, 0x0.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(-0x1.8000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(/(interval(0x0.0000000000000P+0, 0x3.0000000000000P+0), interval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), interval(-0x1.8000000000000P+0, 0x0.0000000000000P+0)) + @test isequal_interval(/(bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(-0x3.0000000000000P+0, -0x2.0000000000000P+0)), bareinterval(-0x1.8000000000000P+0, 0x0.0000000000000P+0)) - @test isequal_interval(/(interval(0x0.0000000000000P+0, 0x3.0000000000000P+0), interval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), interval(0x0.0000000000000P+0, 0x1.8000000000000P+0)) + @test isequal_interval(/(bareinterval(0x0.0000000000000P+0, 0x3.0000000000000P+0), bareinterval(0x2.0000000000000P+0, 0x3.0000000000000P+0)), bareinterval(0x0.0000000000000P+0, 0x1.8000000000000P+0)) end @testset "FI_LIB.unary_functions" begin - @test isequal_interval(exp(interval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), interval(0x0.0000000000000P+0, 0x2.BA43457B11D98P-4)) + @test isequal_interval(exp(bareinterval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), bareinterval(0x0.0000000000000P+0, 0x2.BA43457B11D98P-4)) - @test isequal_interval(exp(interval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), interval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFA38P-4)) + @test isequal_interval(exp(bareinterval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), bareinterval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFA38P-4)) - @test isequal_interval(exp(interval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), interval(0x0.0000000000000P+0, 0x1.5D7A2F6655DFCP-848)) + @test isequal_interval(exp(bareinterval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), bareinterval(0x0.0000000000000P+0, 0x1.5D7A2F6655DFCP-848)) - @test isequal_interval(exp(interval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), interval(0x9.34C0766401B20P-472, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), bareinterval(0x9.34C0766401B20P-472, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x2.B7E151628AED2P+0, 0x7.63992E35376B8P+0)) + @test isequal_interval(exp(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x2.B7E151628AED2P+0, 0x7.63992E35376B8P+0)) - @test isequal_interval(exp(interval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), interval(0x5.E2D58D8B3BCDCP-4, 0x7.63992E35376B8P+0)) + @test isequal_interval(exp(bareinterval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), bareinterval(0x5.E2D58D8B3BCDCP-4, 0x7.63992E35376B8P+0)) - @test isequal_interval(exp(interval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), interval(0x1.B993FE00D5376P-8, 0xC.BED8666758578P-8)) + @test isequal_interval(exp(bareinterval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), bareinterval(0x1.B993FE00D5376P-8, 0xC.BED8666758578P-8)) - @test isequal_interval(exp(interval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), interval(0x2.2A555477F0396P-4, 0x1.D27660B11A9F0P+0)) + @test isequal_interval(exp(bareinterval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), bareinterval(0x2.2A555477F0396P-4, 0x1.D27660B11A9F0P+0)) - @test isequal_interval(exp(interval(0x4.0000000000000P-1076, 0x4.4444400000000P-1056)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(exp(bareinterval(0x4.0000000000000P-1076, 0x4.4444400000000P-1056)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(exp(interval(0x4.4440000000000P-1064, 0x1.0000000000000P+0)), interval(0x1.0000000000000P+0, 0x2.B7E151628AED4P+0)) + @test isequal_interval(exp(bareinterval(0x4.4440000000000P-1064, 0x1.0000000000000P+0)), bareinterval(0x1.0000000000000P+0, 0x2.B7E151628AED4P+0)) - @test isequal_interval(exp(interval(-0x4.4444000000000P-1060, +0x4.4444000000000P-1060)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) + @test isequal_interval(exp(bareinterval(-0x4.4444000000000P-1060, +0x4.4444000000000P-1060)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) - @test isequal_interval(exp(interval(-0x4.4400000000000P-1068, +0x1.FFF0000000000P+0)), interval(0xF.FFFFFFFFFFFF8P-4, 0x7.6322F8540CFB4P+0)) + @test isequal_interval(exp(bareinterval(-0x4.4400000000000P-1068, +0x1.FFF0000000000P+0)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x7.6322F8540CFB4P+0)) - @test isequal_interval(exp(interval(-0x1.FFFF000000000P+0, -0x8.8888880000000P-1052)), interval(0x2.2A577ECE59DC6P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp(bareinterval(-0x1.FFFF000000000P+0, -0x8.8888880000000P-1052)), bareinterval(0x2.2A577ECE59DC6P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp(interval(-0x1.FFFFFFF000000P+0, +0x8.CD11555400000P-1044)), interval(0x2.2A55549A958EAP-4, 0x1.0000000000001P+0)) + @test isequal_interval(exp(bareinterval(-0x1.FFFFFFF000000P+0, +0x8.CD11555400000P-1044)), bareinterval(0x2.2A55549A958EAP-4, 0x1.0000000000001P+0)) - @test isequal_interval(exp2(interval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), interval(0x0.0000000000000P+0, 0x4.B1AC6F8470484P-4)) + @test isequal_interval(exp2(bareinterval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), bareinterval(0x0.0000000000000P+0, 0x4.B1AC6F8470484P-4)) - @test isequal_interval(exp2(interval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), interval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFC00P-4)) + @test isequal_interval(exp2(bareinterval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), bareinterval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFC00P-4)) - @test isequal_interval(exp2(interval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), interval(0x0.0000000000000P+0, 0x1.6FB78C613E5ECP-588)) + @test isequal_interval(exp2(bareinterval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), bareinterval(0x0.0000000000000P+0, 0x1.6FB78C613E5ECP-588)) - @test isequal_interval(exp2(interval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), interval(0x8.4EB038B9B8508P-328, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), bareinterval(0x8.4EB038B9B8508P-328, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp2(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x2.0000000000000P+0, 0x4.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x2.0000000000000P+0, 0x4.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), interval(0x8.0000000000000P-4, 0x4.0000000000000P+0)) + @test isequal_interval(exp2(bareinterval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), bareinterval(0x8.0000000000000P-4, 0x4.0000000000000P+0)) - @test isequal_interval(exp2(interval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), interval(0x8.0000000000000P-8, 0x2.0000000000000P-4)) + @test isequal_interval(exp2(bareinterval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), bareinterval(0x8.0000000000000P-8, 0x2.0000000000000P-4)) - @test isequal_interval(exp2(interval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), interval(0x4.0000000000000P-4, 0x1.8406003B2AE5DP+0)) + @test isequal_interval(exp2(bareinterval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), bareinterval(0x4.0000000000000P-4, 0x1.8406003B2AE5DP+0)) - @test isequal_interval(exp2(interval(0x4.4400000000000P-1068, 0x4.48CD100000000P-1052)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(exp2(bareinterval(0x4.4400000000000P-1068, 0x4.48CD100000000P-1052)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(exp2(interval(-0x4.8D15088880000P-1040, +0x4.8D11554000000P-1048)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) + @test isequal_interval(exp2(bareinterval(-0x4.8D15088880000P-1040, +0x4.8D11554000000P-1048)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) - @test isequal_interval(exp2(interval(0xD.0888D11000000P-1044, 0x1.000003443AAAAP+0)), interval(0x1.0000000000000P+0, 0x2.0000048742860P+0)) + @test isequal_interval(exp2(bareinterval(0xD.0888D11000000P-1044, 0x1.000003443AAAAP+0)), bareinterval(0x1.0000000000000P+0, 0x2.0000048742860P+0)) - @test isequal_interval(exp2(interval(-0xD.15550CC880000P-1040, +0x4.8D150CC000000P-1048)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) + @test isequal_interval(exp2(bareinterval(-0xD.15550CC880000P-1040, +0x4.8D150CC000000P-1048)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000001P+0)) - @test isequal_interval(exp2(interval(-0x4.8D159E0000000P-1048, +0x1.FFFFFF0999999P+0)), interval(0xF.FFFFFFFFFFFF8P-4, 0x3.FFFFFD54D58B0P+0)) + @test isequal_interval(exp2(bareinterval(-0x4.8D159E0000000P-1048, +0x1.FFFFFF0999999P+0)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x3.FFFFFD54D58B0P+0)) - @test isequal_interval(exp2(interval(-0x1.FFFFFFFFFFFFFP+0, +0x1.14C8911540000P-1040)), interval(0x4.0000000000000P-4, 0x1.0000000000001P+0)) + @test isequal_interval(exp2(bareinterval(-0x1.FFFFFFFFFFFFFP+0, +0x1.14C8911540000P-1040)), bareinterval(0x4.0000000000000P-4, 0x1.0000000000001P+0)) - @test isequal_interval(exp10(interval(-0x2.8457BC029986EP+112, -0x1.7A77BFCCF5A9EP-232)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x2.8457BC029986EP+112, -0x1.7A77BFCCF5A9EP-232)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x6.05C0BB1BCB730P-220, -0x3.C5EC30FBB68C8P-508)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x6.05C0BB1BCB730P-220, -0x3.C5EC30FBB68C8P-508)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x2.9B09919BF9D9EP+272, -0xE.20FF41BD18058P-204)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x2.9B09919BF9D9EP+272, -0xE.20FF41BD18058P-204)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.1503444763FC5P-416, -0x2.075DF98B2478CP-456)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.1503444763FC5P-416, -0x2.075DF98B2478CP-456)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x4.ECBC855871080P+332, -0x1.3A01905E36F84P+0)), interval(0x0.0000000000000P+0, 0xF.317F8555628F0P-8)) + @test isequal_interval(exp10(bareinterval(-0x4.ECBC855871080P+332, -0x1.3A01905E36F84P+0)), bareinterval(0x0.0000000000000P+0, 0xF.317F8555628F0P-8)) - @test isequal_interval(exp10(interval(-0x7.32EDAB7F60A50P+236, -0x2.404E44C49C644P-440)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x7.32EDAB7F60A50P+236, -0x2.404E44C49C644P-440)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x6.5263CF84EF388P+172, -0x1.63A15E999EB64P-344)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x6.5263CF84EF388P+172, -0x1.63A15E999EB64P-344)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.4171976A1CA54P-288, -0x6.941F470A70074P-756)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.4171976A1CA54P-288, -0x6.941F470A70074P-756)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x4.69BB1D34B9570P-76, -0x7.78A1F475A306CP-564)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x4.69BB1D34B9570P-76, -0x7.78A1F475A306CP-564)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x2.E046DB554037CP+256, -0x2.6ABC15579B2B2P-48)), interval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFA70P-4)) + @test isequal_interval(exp10(bareinterval(-0x2.E046DB554037CP+256, -0x2.6ABC15579B2B2P-48)), bareinterval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFA70P-4)) - @test isequal_interval(exp10(interval(-0xE.33C49CF5B8790P+652, -0x8.297A99ED9ED08P+8)), interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(exp10(bareinterval(-0xE.33C49CF5B8790P+652, -0x8.297A99ED9ED08P+8)), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(exp10(interval(-0x1.7AAA15EBBD3F2P+8, -0x6.3E590E626451CP-172)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.7AAA15EBBD3F2P+8, -0x6.3E590E626451CP-172)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x2.8F9204BC4041EP+988, -0x6.ACFA418D8F92CP-544)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x2.8F9204BC4041EP+988, -0x6.ACFA418D8F92CP-544)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x2.B00450A48D586P-148, -0x2.BB570B356C6CAP-440)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x2.B00450A48D586P-148, -0x2.BB570B356C6CAP-440)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.9E7DDBBE00F75P+352, -0xC.41329461A0C30P-512)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.9E7DDBBE00F75P+352, -0xC.41329461A0C30P-512)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.5BD629B25AA23P-236, -0x7.DEA605DEC97CCP-316)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.5BD629B25AA23P-236, -0x7.DEA605DEC97CCP-316)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x3.AE1DC13A652CAP+168, -0x6.65D7E0A247778P-56)), interval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFFF8P-4)) + @test isequal_interval(exp10(bareinterval(-0x3.AE1DC13A652CAP+168, -0x6.65D7E0A247778P-56)), bareinterval(0x0.0000000000000P+0, 0xF.FFFFFFFFFFFF8P-4)) - @test isequal_interval(exp10(interval(-0xA.27B4555158148P-68, -0x5.2B55801231EC8P-344)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0xA.27B4555158148P-68, -0x5.2B55801231EC8P-344)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.D68A6BA7E617FP+12, -0x6.36B661DCE2688P-236)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.D68A6BA7E617FP+12, -0x6.36B661DCE2688P-236)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.98EF0C6A8BD66P+132, -0x1.EB0E1AB78F314P-480)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.98EF0C6A8BD66P+132, -0x1.EB0E1AB78F314P-480)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x1.C08152CC09416P+220, -0x7.4CF193131FA64P-192)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x1.C08152CC09416P+220, -0x7.4CF193131FA64P-192)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x6.F70E0DA4D2BA0P-140, -0x1.7036C237D5B00P-672)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x6.F70E0DA4D2BA0P-140, -0x1.7036C237D5B00P-672)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0xF.CC937FA330E40P+648, -0x3.A0EE84451C92CP-324)), interval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0xF.CC937FA330E40P+648, -0x3.A0EE84451C92CP-324)), bareinterval(0x0.0000000000000P+0, 0x1.0000000000000P+0)) - @test isequal_interval(exp10(interval(-0x5.F775993940188P-120, -0x1.8BCA641025A83P-124)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(exp10(bareinterval(-0x5.F775993940188P-120, -0x1.8BCA641025A83P-124)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(log(interval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), interval(-0xB.47B530A1054D8P+4, +0x4.227AD8183FB70P+4)) + @test isequal_interval(log(bareinterval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), bareinterval(-0xB.47B530A1054D8P+4, +0x4.227AD8183FB70P+4)) - @test isequal_interval(log(interval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), interval(-0x1.64CBA844FC0EAP+8, -0x9.968AD8B569FE0P+4)) + @test isequal_interval(log(bareinterval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), bareinterval(-0x1.64CBA844FC0EAP+8, -0x9.968AD8B569FE0P+4)) - @test isequal_interval(log(interval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), interval(-0xA.426B5145A44A0P+4, +0xA.40B346F454218P+4)) + @test isequal_interval(log(bareinterval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), bareinterval(-0xA.426B5145A44A0P+4, +0xA.40B346F454218P+4)) - @test isequal_interval(log(interval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), interval(-0x1.52D81024E4C23P+8, -0x1.3813C01ACD25CP+8)) + @test isequal_interval(log(bareinterval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), bareinterval(-0x1.52D81024E4C23P+8, -0x1.3813C01ACD25CP+8)) - @test isequal_interval(log(interval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), interval(0x8.80F0717A1DC40P+4, 0x9.D6130F01F8B78P+4)) + @test isequal_interval(log(bareinterval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), bareinterval(0x8.80F0717A1DC40P+4, 0x9.D6130F01F8B78P+4)) - @test isequal_interval(log(interval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), interval(-0x1.C9B8D4127E3DAP+4, +0xC.091AAD1207058P+4)) + @test isequal_interval(log(bareinterval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), bareinterval(-0x1.C9B8D4127E3DAP+4, +0xC.091AAD1207058P+4)) - @test isequal_interval(log(interval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), interval(-0x1.49B9D16B7E46AP+8, +0x8.A1137BDE55CF8P+4)) + @test isequal_interval(log(bareinterval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), bareinterval(-0x1.49B9D16B7E46AP+8, +0x8.A1137BDE55CF8P+4)) - @test isequal_interval(log(interval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), interval(-0x1.028323B4D95B4P+8, +0x6.21D80D9193AB8P+4)) + @test isequal_interval(log(bareinterval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), bareinterval(-0x1.028323B4D95B4P+8, +0x6.21D80D9193AB8P+4)) - @test isequal_interval(log(interval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), interval(-0x2.142D983D15A28P+8, -0xE.2C8FA3F896A50P+4)) + @test isequal_interval(log(bareinterval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), bareinterval(-0x2.142D983D15A28P+8, -0xE.2C8FA3F896A50P+4)) - @test isequal_interval(log(interval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), interval(-0x1.907255D3994FEP+8, -0x5.A87FCF5FBD800P+4)) + @test isequal_interval(log(bareinterval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), bareinterval(-0x1.907255D3994FEP+8, -0x5.A87FCF5FBD800P+4)) - @test isequal_interval(log(interval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), interval(0x5.15D8B410E0A5CP+4, 0xC.0A13DC536CD58P+4)) + @test isequal_interval(log(bareinterval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), bareinterval(0x5.15D8B410E0A5CP+4, 0xC.0A13DC536CD58P+4)) - @test isequal_interval(log(interval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), interval(-0x4.425A8474E3980P+4, +0x8.DFF506FE0D9F8P+4)) + @test isequal_interval(log(bareinterval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), bareinterval(-0x4.425A8474E3980P+4, +0x8.DFF506FE0D9F8P+4)) - @test isequal_interval(log(interval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), interval(0x4.54169A4297548P+0, 0x1.9D179EA5204D0P+8)) + @test isequal_interval(log(bareinterval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), bareinterval(0x4.54169A4297548P+0, 0x1.9D179EA5204D0P+8)) - @test isequal_interval(log(interval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), interval(0xE.CD14BEBE2CD68P+0, 0x1.B46DC0D02B874P+8)) + @test isequal_interval(log(bareinterval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), bareinterval(0xE.CD14BEBE2CD68P+0, 0x1.B46DC0D02B874P+8)) - @test isequal_interval(log(interval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), interval(-0x7.9346BAB839B58P+4, -0xE.E33F2C933B990P+0)) + @test isequal_interval(log(bareinterval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), bareinterval(-0x7.9346BAB839B58P+4, -0xE.E33F2C933B990P+0)) - @test isequal_interval(log(interval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), interval(-0x1.83044F26AAA2BP+8, +0x2.805CE2DC91036P+8)) + @test isequal_interval(log(bareinterval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), bareinterval(-0x1.83044F26AAA2BP+8, +0x2.805CE2DC91036P+8)) - @test isequal_interval(log(interval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), interval(-0x1.4359ECD75CB6CP+8, -0x6.E715E1BA0E35CP+4)) + @test isequal_interval(log(bareinterval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), bareinterval(-0x1.4359ECD75CB6CP+8, -0x6.E715E1BA0E35CP+4)) - @test isequal_interval(log(interval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), interval(-0x1.6F438EE9F6020P+8, +0xE.1A4A3523F2658P+4)) + @test isequal_interval(log(bareinterval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), bareinterval(-0x1.6F438EE9F6020P+8, +0xE.1A4A3523F2658P+4)) - @test isequal_interval(log(interval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), interval(0x6.564D09AD1D214P+4, 0x8.914A9531FD118P+4)) + @test isequal_interval(log(bareinterval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), bareinterval(0x6.564D09AD1D214P+4, 0x8.914A9531FD118P+4)) - @test isequal_interval(log(interval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), interval(-0xE.1D2336A5BE1A8P+4, -0xA.649D44362A2F0P+4)) + @test isequal_interval(log(bareinterval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), bareinterval(-0xE.1D2336A5BE1A8P+4, -0xA.649D44362A2F0P+4)) - @test isequal_interval(log(interval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), interval(0xF.BD7308ED73FF0P+4, 0x1.6DF4DA39DC5DDP+8)) + @test isequal_interval(log(bareinterval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), bareinterval(0xF.BD7308ED73FF0P+4, 0x1.6DF4DA39DC5DDP+8)) - @test isequal_interval(log(interval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), interval(-0x4.8FBAEF1169C24P+4, +0x5.F718BBF0CE2F8P+4)) + @test isequal_interval(log(bareinterval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), bareinterval(-0x4.8FBAEF1169C24P+4, +0x5.F718BBF0CE2F8P+4)) - @test isequal_interval(log(interval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), interval(-0xF.4CD3094A3B4B8P+4, -0x3.439BFD719BAE8P+4)) + @test isequal_interval(log(bareinterval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), bareinterval(-0xF.4CD3094A3B4B8P+4, -0x3.439BFD719BAE8P+4)) - @test isequal_interval(log(interval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), interval(-0xA.CDC41AEE74318P+4, -0x1.681AFF89E9C89P+4)) + @test isequal_interval(log(bareinterval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), bareinterval(-0xA.CDC41AEE74318P+4, -0x1.681AFF89E9C89P+4)) - @test isequal_interval(log(interval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), interval(-0x1.5ADD53379EF4DP+8, +0x3.36D2B121508A8P+4)) + @test isequal_interval(log(bareinterval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), bareinterval(-0x1.5ADD53379EF4DP+8, +0x3.36D2B121508A8P+4)) - @test isequal_interval(log(interval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), interval(-0x9.341D196AD2D58P+4, +0x8.5ADC069F618A8P+4)) + @test isequal_interval(log(bareinterval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), bareinterval(-0x9.341D196AD2D58P+4, +0x8.5ADC069F618A8P+4)) - @test isequal_interval(log(interval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), interval(-0x1.DC410CBC8E1C8P+8, -0x6.4027B79D2EAA8P+4)) + @test isequal_interval(log(bareinterval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), bareinterval(-0x1.DC410CBC8E1C8P+8, -0x6.4027B79D2EAA8P+4)) - @test isequal_interval(log(interval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), interval(0x8.6243148F46208P+4, 0xB.519B6E544F898P+4)) + @test isequal_interval(log(bareinterval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), bareinterval(0x8.6243148F46208P+4, 0xB.519B6E544F898P+4)) - @test isequal_interval(log(interval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), interval(-0xE.9F20674285418P+4, +0x1.990C99B6124FEP+8)) + @test isequal_interval(log(bareinterval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), bareinterval(-0xE.9F20674285418P+4, +0x1.990C99B6124FEP+8)) - @test isequal_interval(log(interval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), interval(-0x7.A02728D7D3790P+4, -0x6.70DBA893A16E0P+4)) + @test isequal_interval(log(bareinterval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), bareinterval(-0x7.A02728D7D3790P+4, -0x6.70DBA893A16E0P+4)) - @test isequal_interval(log2(interval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), interval(-0x1.04614E93EA794P+8, +0x5.F7104B04804E4P+4)) + @test isequal_interval(log2(bareinterval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), bareinterval(-0x1.04614E93EA794P+8, +0x5.F7104B04804E4P+4)) - @test isequal_interval(log2(interval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), interval(-0x2.02BF4547CF74AP+8, -0xD.D527F669B7AA0P+4)) + @test isequal_interval(log2(bareinterval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), bareinterval(-0x2.02BF4547CF74AP+8, -0xD.D527F669B7AA0P+4)) - @test isequal_interval(log2(interval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), interval(-0xE.CD1F394A2C268P+4, +0xE.CAA4613C31FD0P+4)) + @test isequal_interval(log2(bareinterval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), bareinterval(-0xE.CD1F394A2C268P+4, +0xE.CAA4613C31FD0P+4)) - @test isequal_interval(log2(interval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), interval(-0x1.E8D93AC78E47CP+8, -0x1.C23B6E9F9BE73P+8)) + @test isequal_interval(log2(bareinterval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), bareinterval(-0x1.E8D93AC78E47CP+8, -0x1.C23B6E9F9BE73P+8)) - @test isequal_interval(log2(interval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), interval(0xC.44A8D0A480900P+4, 0xE.30D042BD32E08P+4)) + @test isequal_interval(log2(bareinterval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), bareinterval(0xC.44A8D0A480900P+4, 0xE.30D042BD32E08P+4)) - @test isequal_interval(log2(interval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), interval(-0x2.945A6DE3564F2P+4, +0x1.15D18004DA527P+8)) + @test isequal_interval(log2(bareinterval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), bareinterval(-0x2.945A6DE3564F2P+4, +0x1.15D18004DA527P+8)) - @test isequal_interval(log2(interval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), interval(-0x1.DBB1A03AD9911P+8, +0xC.7305ECF8E75D8P+4)) + @test isequal_interval(log2(bareinterval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), bareinterval(-0x1.DBB1A03AD9911P+8, +0xC.7305ECF8E75D8P+4)) - @test isequal_interval(log2(interval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), interval(-0x1.74F450FB5F194P+8, +0x8.D8CE5C08208D0P+4)) + @test isequal_interval(log2(bareinterval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), bareinterval(-0x1.74F450FB5F194P+8, +0x8.D8CE5C08208D0P+4)) - @test isequal_interval(log2(interval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), interval(-0x2.FFC54D5EF9E5AP+8, -0x1.472E83799CCFAP+8)) + @test isequal_interval(log2(bareinterval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), bareinterval(-0x2.FFC54D5EF9E5AP+8, -0x1.472E83799CCFAP+8)) - @test isequal_interval(log2(interval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), interval(-0x2.41B8EC5041B68P+8, -0x8.29BE215800410P+4)) + @test isequal_interval(log2(bareinterval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), bareinterval(-0x2.41B8EC5041B68P+8, -0x8.29BE215800410P+4)) - @test isequal_interval(log2(interval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), interval(0x7.562AE05DF4698P+4, 0x1.15E7F7FA196AAP+8)) + @test isequal_interval(log2(bareinterval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), bareinterval(0x7.562AE05DF4698P+4, 0x1.15E7F7FA196AAP+8)) - @test isequal_interval(log2(interval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), interval(-0x6.250C3695FCF20P+4, +0xC.CDBDC5938D560P+4)) + @test isequal_interval(log2(bareinterval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), bareinterval(-0x6.250C3695FCF20P+4, +0xC.CDBDC5938D560P+4)) - @test isequal_interval(log2(interval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), interval(0x6.3EA22BED11920P+0, 0x2.53F7565A6FA4CP+8)) + @test isequal_interval(log2(bareinterval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), bareinterval(0x6.3EA22BED11920P+0, 0x2.53F7565A6FA4CP+8)) - @test isequal_interval(log2(interval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), interval(0x1.55A7D090E9BC4P+4, 0x2.75A230A6EF148P+8)) + @test isequal_interval(log2(bareinterval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), bareinterval(0x1.55A7D090E9BC4P+4, 0x2.75A230A6EF148P+8)) - @test isequal_interval(log2(interval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), interval(-0xA.EDC8C6AE09A00P+4, -0x1.57A778189781EP+4)) + @test isequal_interval(log2(bareinterval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), bareinterval(-0xA.EDC8C6AE09A00P+4, -0x1.57A778189781EP+4)) - @test isequal_interval(log2(interval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), interval(-0x2.2E58E661BEF52P+8, +0x3.9BD9297418726P+8)) + @test isequal_interval(log2(bareinterval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), bareinterval(-0x2.2E58E661BEF52P+8, +0x3.9BD9297418726P+8)) - @test isequal_interval(log2(interval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), interval(-0x1.D27F4D5811EC0P+8, -0x9.F55D8E4A51F88P+4)) + @test isequal_interval(log2(bareinterval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), bareinterval(-0x1.D27F4D5811EC0P+8, -0x9.F55D8E4A51F88P+4)) - @test isequal_interval(log2(interval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), interval(-0x2.11D98CE9F01E8P+8, +0x1.4588C1B9F05FCP+8)) + @test isequal_interval(log2(bareinterval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), bareinterval(-0x2.11D98CE9F01E8P+8, +0x1.4588C1B9F05FCP+8)) - @test isequal_interval(log2(interval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), interval(0x9.247C4A0D6A240P+4, 0xC.5C40234316DE0P+4)) + @test isequal_interval(log2(bareinterval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), bareinterval(0x9.247C4A0D6A240P+4, 0xC.5C40234316DE0P+4)) - @test isequal_interval(log2(interval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), interval(-0x1.45CA7D7508D73P+8, -0xE.FE7480A8A6A70P+4)) + @test isequal_interval(log2(bareinterval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), bareinterval(-0x1.45CA7D7508D73P+8, -0xE.FE7480A8A6A70P+4)) - @test isequal_interval(log2(interval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), interval(0x1.6B54440063A2FP+8, 0x2.0FF6AC0A1DF08P+8)) + @test isequal_interval(log2(bareinterval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), bareinterval(0x1.6B54440063A2FP+8, 0x2.0FF6AC0A1DF08P+8)) - @test isequal_interval(log2(interval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), interval(-0x6.94ADB7A807630P+4, +0x8.9B227CD69B7B0P+4)) + @test isequal_interval(log2(bareinterval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), bareinterval(-0x6.94ADB7A807630P+4, +0x8.9B227CD69B7B0P+4)) - @test isequal_interval(log2(interval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), interval(-0x1.612C877FDEFC9P+8, -0x4.B58789B7D2AB8P+4)) + @test isequal_interval(log2(bareinterval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), bareinterval(-0x1.612C877FDEFC9P+8, -0x4.B58789B7D2AB8P+4)) - @test isequal_interval(log2(interval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), interval(-0xF.96282D809EDE0P+4, -0x2.0785B9A270C10P+4)) + @test isequal_interval(log2(bareinterval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), bareinterval(-0xF.96282D809EDE0P+4, -0x2.0785B9A270C10P+4)) - @test isequal_interval(log2(interval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), interval(-0x1.F46B75E4932F4P+8, +0x4.A3152AC221298P+4)) + @test isequal_interval(log2(bareinterval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), bareinterval(-0x1.F46B75E4932F4P+8, +0x4.A3152AC221298P+4)) - @test isequal_interval(log2(interval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), interval(-0xD.47274C2E0B298P+4, +0xC.0DB8D252704A8P+4)) + @test isequal_interval(log2(bareinterval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), bareinterval(-0xD.47274C2E0B298P+4, +0xC.0DB8D252704A8P+4)) - @test isequal_interval(log2(interval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), interval(-0x2.AF16E4D3D6128P+8, -0x9.048930492A7A0P+4)) + @test isequal_interval(log2(bareinterval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), bareinterval(-0x2.AF16E4D3D6128P+8, -0x9.048930492A7A0P+4)) - @test isequal_interval(log2(interval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), interval(0xC.1866CEA5B0408P+4, 0x1.0545D0C4DA7BAP+8)) + @test isequal_interval(log2(bareinterval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), bareinterval(0xC.1866CEA5B0408P+4, 0x1.0545D0C4DA7BAP+8)) - @test isequal_interval(log2(interval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), interval(-0x1.51830AD8B30FCP+8, +0x2.4E221EC1DB53EP+8)) + @test isequal_interval(log2(bareinterval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), bareinterval(-0x1.51830AD8B30FCP+8, +0x2.4E221EC1DB53EP+8)) - @test isequal_interval(log2(interval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), interval(-0xB.005C8501548A8P+4, -0x9.4ACCA02A24828P+4)) + @test isequal_interval(log2(bareinterval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), bareinterval(-0xB.005C8501548A8P+4, -0x9.4ACCA02A24828P+4)) - @test isequal_interval(log10(interval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), interval(-0x4.E61D94C4C8D58P+4, +0x1.CBB1247192AE0P+4)) + @test isequal_interval(log10(bareinterval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), bareinterval(-0x4.E61D94C4C8D58P+4, +0x1.CBB1247192AE0P+4)) - @test isequal_interval(log10(interval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), interval(-0x9.AF44F24283358P+4, -0x4.29FE8451F9E24P+4)) + @test isequal_interval(log10(bareinterval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), bareinterval(-0x9.AF44F24283358P+4, -0x4.29FE8451F9E24P+4)) - @test isequal_interval(log10(interval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), interval(-0x4.74A3ADB971C48P+4, +0x4.73E4925024C64P+4)) + @test isequal_interval(log10(bareinterval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), bareinterval(-0x4.74A3ADB971C48P+4, +0x4.73E4925024C64P+4)) - @test isequal_interval(log10(interval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), interval(-0x9.32877CA0160B8P+4, -0x8.7888BDDBCE5D0P+4)) + @test isequal_interval(log10(bareinterval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), bareinterval(-0x9.32877CA0160B8P+4, -0x8.7888BDDBCE5D0P+4)) - @test isequal_interval(log10(interval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), interval(0x3.B16EC52507DF2P+4, 0x4.4595F97548968P+4)) + @test isequal_interval(log10(bareinterval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), bareinterval(0x3.B16EC52507DF2P+4, 0x4.4595F97548968P+4)) - @test isequal_interval(log10(interval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), interval(-0xC.6C93FFEF64F78P+0, +0x5.3A1B471A21FF4P+4)) + @test isequal_interval(log10(bareinterval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), bareinterval(-0xC.6C93FFEF64F78P+0, +0x5.3A1B471A21FF4P+4)) - @test isequal_interval(log10(interval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), interval(-0x8.F32B7DBB21008P+4, +0x3.BF63BA7A3C658P+4)) + @test isequal_interval(log10(bareinterval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), bareinterval(-0x8.F32B7DBB21008P+4, +0x3.BF63BA7A3C658P+4)) - @test isequal_interval(log10(interval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), interval(-0x7.0453C2F061648P+4, +0x2.A9C64A16830FCP+4)) + @test isequal_interval(log10(bareinterval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), bareinterval(-0x7.0453C2F061648P+4, +0x2.A9C64A16830FCP+4)) - @test isequal_interval(log10(interval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), interval(-0xE.71F3C5029D848P+4, -0x6.27DD331C437F0P+4)) + @test isequal_interval(log10(bareinterval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), bareinterval(-0xE.71F3C5029D848P+4, -0x6.27DD331C437F0P+4)) - @test isequal_interval(log10(interval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), interval(-0xA.DE968FD95ABE0P+4, -0x2.7513429684674P+4)) + @test isequal_interval(log10(bareinterval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), bareinterval(-0xA.DE968FD95ABE0P+4, -0x2.7513429684674P+4)) - @test isequal_interval(log10(interval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), interval(0x2.35627EFD00A60P+4, 0x5.3A877F4AD58E8P+4)) + @test isequal_interval(log10(bareinterval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), bareinterval(0x2.35627EFD00A60P+4, 0x5.3A877F4AD58E8P+4)) - @test isequal_interval(log10(interval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), interval(-0x1.D988D7EBC5AE3P+4, +0x3.DAB2CD7F2625EP+4)) + @test isequal_interval(log10(bareinterval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), bareinterval(-0x1.D988D7EBC5AE3P+4, +0x3.DAB2CD7F2625EP+4)) - @test isequal_interval(log10(interval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), interval(0x1.E13C93CF0C5D8P+0, 0xB.367584AC914D0P+4)) + @test isequal_interval(log10(bareinterval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), bareinterval(0x1.E13C93CF0C5D8P+0, 0xB.367584AC914D0P+4)) - @test isequal_interval(log10(interval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), interval(0x6.6D93B54D66420P+0, 0xB.D89E0CA927598P+4)) + @test isequal_interval(log10(bareinterval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), bareinterval(0x6.6D93B54D66420P+0, 0xB.D89E0CA927598P+4)) - @test isequal_interval(log10(interval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), interval(-0x3.4A378CAAD54DAP+4, -0x6.773414D886C14P+0)) + @test isequal_interval(log10(bareinterval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), bareinterval(-0x3.4A378CAAD54DAP+4, -0x6.773414D886C14P+0)) - @test isequal_interval(log10(interval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), interval(-0xA.8144B5B8F5DD8P+4, +0x1.161B25DAC86ECP+8)) + @test isequal_interval(log10(bareinterval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), bareinterval(-0xA.8144B5B8F5DD8P+4, +0x1.161B25DAC86ECP+8)) - @test isequal_interval(log10(interval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), interval(-0x8.C6DFF01C76970P+4, -0x2.FF6F7B088B0CCP+4)) + @test isequal_interval(log10(bareinterval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), bareinterval(-0x8.C6DFF01C76970P+4, -0x2.FF6F7B088B0CCP+4)) - @test isequal_interval(log10(interval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), interval(-0x9.F802CE339E840P+4, +0x6.1FEDD0FB88D78P+4)) + @test isequal_interval(log10(bareinterval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), bareinterval(-0x9.F802CE339E840P+4, +0x6.1FEDD0FB88D78P+4)) - @test isequal_interval(log10(interval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), interval(0x2.C08E6C63F32E4P+4, 0x3.B888C99289754P+4)) + @test isequal_interval(log10(bareinterval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), bareinterval(0x2.C08E6C63F32E4P+4, 0x3.B888C99289754P+4)) - @test isequal_interval(log10(interval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), interval(-0x6.212A6B69124F0P+4, -0x4.837D7868C93BCP+4)) + @test isequal_interval(log10(bareinterval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), bareinterval(-0x6.212A6B69124F0P+4, -0x4.837D7868C93BCP+4)) - @test isequal_interval(log10(interval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), interval(0x6.D5F7B5F14DD48P+4, 0x9.EEED0801EA480P+4)) + @test isequal_interval(log10(bareinterval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), bareinterval(0x6.D5F7B5F14DD48P+4, 0x9.EEED0801EA480P+4)) - @test isequal_interval(log10(interval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), interval(-0x1.FB238786D64F9P+4, +0x2.9735AA99F42AAP+4)) + @test isequal_interval(log10(bareinterval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), bareinterval(-0x1.FB238786D64F9P+4, +0x2.9735AA99F42AAP+4)) - @test isequal_interval(log10(interval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), interval(-0x6.A50E2200DFF14P+4, -0x1.6AE688B7C8203P+4)) + @test isequal_interval(log10(bareinterval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), bareinterval(-0x6.A50E2200DFF14P+4, -0x1.6AE688B7C8203P+4)) - @test isequal_interval(log10(interval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), interval(-0x4.B1282C68FE4F8P+4, -0x9.C644DFB9EE3E0P+0)) + @test isequal_interval(log10(bareinterval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), bareinterval(-0x4.B1282C68FE4F8P+4, -0x9.C644DFB9EE3E0P+0)) - @test isequal_interval(log10(interval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), interval(-0x9.6A430336AD680P+4, +0x1.6558F570C1420P+4)) + @test isequal_interval(log10(bareinterval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), bareinterval(-0x9.6A430336AD680P+4, +0x1.6558F570C1420P+4)) - @test isequal_interval(log10(interval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), interval(-0x3.FF3F46384E0E2P+4, +0x3.A0E51611FF75EP+4)) + @test isequal_interval(log10(bareinterval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), bareinterval(-0x3.FF3F46384E0E2P+4, +0x3.A0E51611FF75EP+4)) - @test isequal_interval(log10(interval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), interval(-0xC.ED5A39E5D4878P+4, -0x2.B6F044CDE4A0CP+4)) + @test isequal_interval(log10(bareinterval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), bareinterval(-0xC.ED5A39E5D4878P+4, -0x2.B6F044CDE4A0CP+4)) - @test isequal_interval(log10(interval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), interval(0x3.A41C190FE9E7AP+4, 0x4.EA6A3021E4FB8P+4)) + @test isequal_interval(log10(bareinterval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), bareinterval(0x3.A41C190FE9E7AP+4, 0x4.EA6A3021E4FB8P+4)) - @test isequal_interval(log10(interval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), interval(-0x6.599E84FEF71BCP+4, +0xB.1A5D77BC55F98P+4)) + @test isequal_interval(log10(bareinterval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), bareinterval(-0x6.599E84FEF71BCP+4, +0xB.1A5D77BC55F98P+4)) - @test isequal_interval(log10(interval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), interval(-0x3.4FCF2BC10B840P+4, -0x2.CC1706E0167D2P+4)) + @test isequal_interval(log10(bareinterval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), bareinterval(-0x3.4FCF2BC10B840P+4, -0x2.CC1706E0167D2P+4)) - @test isequal_interval(sin(interval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944)), interval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F10P-944)) + @test isequal_interval(sin(bareinterval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944)), bareinterval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F10P-944)) - @test isequal_interval(sin(interval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624)), interval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FE8P-624)) + @test isequal_interval(sin(bareinterval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624)), bareinterval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FE8P-624)) - @test isequal_interval(sin(interval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960)), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) + @test isequal_interval(sin(bareinterval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960)), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) - @test isequal_interval(sin(interval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)), interval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)) + @test isequal_interval(sin(bareinterval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)), bareinterval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)) - @test isequal_interval(sin(interval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564)), interval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025104P-564)) + @test isequal_interval(sin(bareinterval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564)), bareinterval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025104P-564)) - @test isequal_interval(sin(interval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412)), interval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4DEP-412)) + @test isequal_interval(sin(bareinterval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412)), bareinterval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4DEP-412)) - @test isequal_interval(sin(interval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792)), interval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C80P-792)) + @test isequal_interval(sin(bareinterval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792)), bareinterval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C80P-792)) - @test isequal_interval(sin(interval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204)), interval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301854P-204)) + @test isequal_interval(sin(bareinterval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204)), bareinterval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301854P-204)) - @test isequal_interval(sin(interval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80)), interval(0xF.4077C7E8CD698P-268, 0x3.753426098AC5AP-80)) + @test isequal_interval(sin(bareinterval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80)), bareinterval(0xF.4077C7E8CD698P-268, 0x3.753426098AC5AP-80)) - @test isequal_interval(sin(interval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916)), interval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05AP-916)) + @test isequal_interval(sin(bareinterval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916)), bareinterval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05AP-916)) - @test isequal_interval(sin(interval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16)), interval(-0xD.947CA427FDFE0P-592, +0xE.3BE491D517170P-16)) + @test isequal_interval(sin(bareinterval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16)), bareinterval(-0xD.947CA427FDFE0P-592, +0xE.3BE491D517170P-16)) - @test isequal_interval(sin(interval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576)), interval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B6P-576)) + @test isequal_interval(sin(bareinterval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576)), bareinterval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B6P-576)) - @test isequal_interval(sin(interval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)), interval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)) + @test isequal_interval(sin(bareinterval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)), bareinterval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)) - @test isequal_interval(sin(interval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20)), interval(-0x3.560EF91C47DEAP-492, +0x5.413664DCFF7D4P-20)) + @test isequal_interval(sin(bareinterval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20)), bareinterval(-0x3.560EF91C47DEAP-492, +0x5.413664DCFF7D4P-20)) - @test isequal_interval(sin(interval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836)), interval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D50EP-836)) + @test isequal_interval(sin(bareinterval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836)), bareinterval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D50EP-836)) - @test isequal_interval(sin(interval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760)), interval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99665P-760)) + @test isequal_interval(sin(bareinterval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760)), bareinterval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99665P-760)) - @test isequal_interval(sin(interval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780)), interval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0664P-780)) + @test isequal_interval(sin(bareinterval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780)), bareinterval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0664P-780)) - @test isequal_interval(sin(interval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)), interval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)) + @test isequal_interval(sin(bareinterval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)), bareinterval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)) - @test isequal_interval(sin(interval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)), interval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)) + @test isequal_interval(sin(bareinterval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)), bareinterval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)) - @test isequal_interval(sin(interval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548)), interval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106CP-548)) + @test isequal_interval(sin(bareinterval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548)), bareinterval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106CP-548)) - @test isequal_interval(sin(interval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008)), interval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF502P-1008)) + @test isequal_interval(sin(bareinterval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008)), bareinterval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF502P-1008)) - @test isequal_interval(sin(interval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)), interval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)) + @test isequal_interval(sin(bareinterval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)), bareinterval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)) - @test isequal_interval(sin(interval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928)), interval(-0x3.CF0053257533AP-776, -0x1.7883A587654E4P-928)) + @test isequal_interval(sin(bareinterval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928)), bareinterval(-0x3.CF0053257533AP-776, -0x1.7883A587654E4P-928)) - @test isequal_interval(sin(interval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28)), interval(0x1.455801D3D2B62P-704, 0x3.A4C915783D07AP-28)) + @test isequal_interval(sin(bareinterval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28)), bareinterval(0x1.455801D3D2B62P-704, 0x3.A4C915783D07AP-28)) - @test isequal_interval(sin(interval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)), interval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)) + @test isequal_interval(sin(bareinterval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)), bareinterval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)) - @test isequal_interval(sin(interval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540)), interval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F44P-540)) + @test isequal_interval(sin(bareinterval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540)), bareinterval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F44P-540)) - @test isequal_interval(sin(interval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496)), interval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756420P-496)) + @test isequal_interval(sin(bareinterval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496)), bareinterval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756420P-496)) - @test isequal_interval(sin(interval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876)), interval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F4P-876)) + @test isequal_interval(sin(bareinterval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876)), bareinterval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F4P-876)) - @test isequal_interval(sin(interval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)), interval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)) + @test isequal_interval(sin(bareinterval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)), bareinterval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)) - @test isequal_interval(sin(interval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432)), interval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B78P-432)) + @test isequal_interval(sin(bareinterval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432)), bareinterval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B78P-432)) - @test isequal_interval(cos(interval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960)), interval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960)), bareinterval(-0x1.0000000000000P+0, +0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16)), interval(0xF.FFFFF9AB27E58P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16)), bareinterval(0xF.FFFFF9AB27E58P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20)), interval(0xF.FFFFFFFF231A0P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20)), bareinterval(0xF.FFFFFFFF231A0P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(cos(interval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(cos(bareinterval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tan(interval(0x4.6AF931A62EB70P+4, 0x4.6C0D89ACF83F0P+4)), interval(-0x4.2B94A5B864748P+16, -0xE.CC7EFFC39BBE8P+0)) + @test isequal_interval(tan(bareinterval(0x4.6AF931A62EB70P+4, 0x4.6C0D89ACF83F0P+4)), bareinterval(-0x4.2B94A5B864748P+16, -0xE.CC7EFFC39BBE8P+0)) - @test isequal_interval(tan(interval(0x9.B824319678E98P+4, 0x9.B8365416B3188P+4)), interval(-0x9.517610C9FF4F0P+28, -0xE.1DCEBD0ABA128P+4)) + @test isequal_interval(tan(bareinterval(0x9.B824319678E98P+4, 0x9.B8365416B3188P+4)), bareinterval(-0x9.517610C9FF4F0P+28, -0xE.1DCEBD0ABA128P+4)) - @test isequal_interval(tan(interval(0xE.231D6DE6B2910P+0, 0xE.232155989FD58P+0)), interval(-0x1.1A74CC770CA81P+20, -0x4.09E5FC000B430P+12)) + @test isequal_interval(tan(bareinterval(0xE.231D6DE6B2910P+0, 0xE.232155989FD58P+0)), bareinterval(-0x1.1A74CC770CA81P+20, -0x4.09E5FC000B430P+12)) - @test isequal_interval(tan(interval(0x3.A1E994576AF38P+4, 0x3.A1F62CB3D8B0CP+4)), interval(-0x3.EDBBE63A85A20P+12, -0x1.3EC2E09B0B82DP+8)) + @test isequal_interval(tan(bareinterval(0x3.A1E994576AF38P+4, 0x3.A1F62CB3D8B0CP+4)), bareinterval(-0x3.EDBBE63A85A20P+12, -0x1.3EC2E09B0B82DP+8)) - @test isequal_interval(tan(interval(0x4.504512C674C88P+8, 0x4.5045147DF4570P+8)), interval(-0xC.5E819F2BCA708P+28, -0x9.51D20751384C0P+12)) + @test isequal_interval(tan(bareinterval(0x4.504512C674C88P+8, 0x4.5045147DF4570P+8)), bareinterval(-0xC.5E819F2BCA708P+28, -0x9.51D20751384C0P+12)) - @test isequal_interval(tan(interval(0x7.DA9E8C267B000P+0, 0xA.CCC7028A13E50P+0)), interval(-0x8.CE26DA7B8CCA8P+20, +0x5.0BA299C8F763CP+0)) + @test isequal_interval(tan(bareinterval(0x7.DA9E8C267B000P+0, 0xA.CCC7028A13E50P+0)), bareinterval(-0x8.CE26DA7B8CCA8P+20, +0x5.0BA299C8F763CP+0)) - @test isequal_interval(tan(interval(0xC.CA9E956E09870P+12, 0xC.CA9FEB35E8D28P+12)), interval(-0x9.40D68D3420248P+16, -0xB.F4CB43C962B98P+0)) + @test isequal_interval(tan(bareinterval(0xC.CA9E956E09870P+12, 0xC.CA9FEB35E8D28P+12)), bareinterval(-0x9.40D68D3420248P+16, -0xB.F4CB43C962B98P+0)) - @test isequal_interval(tan(interval(0x2.F6B1D30E1AC2CP+8, 0x2.F6B1EAD90ED6EP+8)), interval(-0x1.1E211833A60A2P+20, -0xA.BBFD5C235E8E8P+8)) + @test isequal_interval(tan(bareinterval(0x2.F6B1D30E1AC2CP+8, 0x2.F6B1EAD90ED6EP+8)), bareinterval(-0x1.1E211833A60A2P+20, -0xA.BBFD5C235E8E8P+8)) - @test isequal_interval(tan(interval(0xB.C33774AC8C510P+8, 0xB.C3378F9640B80P+8)), interval(-0x3.B8E9A3359EA76P+12, -0x8.33C065B080F78P+8)) + @test isequal_interval(tan(bareinterval(0xB.C33774AC8C510P+8, 0xB.C3378F9640B80P+8)), bareinterval(-0x3.B8E9A3359EA76P+12, -0x8.33C065B080F78P+8)) - @test isequal_interval(tan(interval(0x4.B65F2027400ECP+0, 0x4.B65F690A4503CP+0)), interval(-0x2.D46AD27DDB548P+24, -0x3.7ECF31F99ADC4P+16)) + @test isequal_interval(tan(bareinterval(0x4.B65F2027400ECP+0, 0x4.B65F690A4503CP+0)), bareinterval(-0x2.D46AD27DDB548P+24, -0x3.7ECF31F99ADC4P+16)) - @test isequal_interval(tan(interval(0x3.C60A2C774D8A6P+8, 0x3.C60A76B28E42CP+8)), interval(-0x3.28E3C44C11B44P+24, -0x3.72D85B31BD660P+8)) + @test isequal_interval(tan(bareinterval(0x3.C60A2C774D8A6P+8, 0x3.C60A76B28E42CP+8)), bareinterval(-0x3.28E3C44C11B44P+24, -0x3.72D85B31BD660P+8)) - @test isequal_interval(tan(interval(0x7.DA9E8A5DF3B7CP+0, 0x7.DAA9CFE45466CP+0)), interval(-0x1.D9B11082E8FC3P+28, -0x1.6B6333E88C1DFP+12)) + @test isequal_interval(tan(bareinterval(0x7.DA9E8A5DF3B7CP+0, 0x7.DAA9CFE45466CP+0)), bareinterval(-0x1.D9B11082E8FC3P+28, -0x1.6B6333E88C1DFP+12)) - @test isequal_interval(tan(interval(0x3.A1E953315B022P+4, 0x3.A3624FC9B84C0P+4)), interval(-0x4.91A5298A762FCP+24, -0xA.D59BACA695F48P+0)) + @test isequal_interval(tan(bareinterval(0x3.A1E953315B022P+4, 0x3.A3624FC9B84C0P+4)), bareinterval(-0x4.91A5298A762FCP+24, -0xA.D59BACA695F48P+0)) - @test isequal_interval(tan(interval(0x7.DA9E8AB1B7B7CP+0, 0x8.E4A2BCBB988B0P+0)), interval(-0x2.C52AD8545AC54P+24, -0x9.691CCDB9751E8P-4)) + @test isequal_interval(tan(bareinterval(0x7.DA9E8AB1B7B7CP+0, 0x8.E4A2BCBB988B0P+0)), bareinterval(-0x2.C52AD8545AC54P+24, -0x9.691CCDB9751E8P-4)) - @test isequal_interval(tan(interval(0x5.48783C12B018CP+8, 0x5.487863A8A0C78P+8)), interval(-0x4.7465D978FF1E8P+4, -0x4.455187267B294P+4)) + @test isequal_interval(tan(bareinterval(0x5.48783C12B018CP+8, 0x5.487863A8A0C78P+8)), bareinterval(-0x4.7465D978FF1E8P+4, -0x4.455187267B294P+4)) - @test isequal_interval(tan(interval(0x1.AB41B772619C2P+4, 0x1.AB96C295E1A23P+4)), interval(-0x2.55DE9F429F276P+16, -0x3.02439C1296068P+4)) + @test isequal_interval(tan(bareinterval(0x1.AB41B772619C2P+4, 0x1.AB96C295E1A23P+4)), bareinterval(-0x2.55DE9F429F276P+16, -0x3.02439C1296068P+4)) - @test isequal_interval(tan(interval(0x1.87E20C8B7CCC1P+16, 0x1.87E20E060934FP+16)), interval(-0x7.5F7BB0C55311CP+28, -0xA.D1F5D5F3730E8P+4)) + @test isequal_interval(tan(bareinterval(0x1.87E20C8B7CCC1P+16, 0x1.87E20E060934FP+16)), bareinterval(-0x7.5F7BB0C55311CP+28, -0xA.D1F5D5F3730E8P+4)) - @test isequal_interval(tan(interval(0x2.5BA5629043048P+16, 0x2.5BA5A6106DDF4P+16)), interval(-0x4.BDE3C915168D8P+4, -0x3.84ED584601B4CP+0)) + @test isequal_interval(tan(bareinterval(0x2.5BA5629043048P+16, 0x2.5BA5A6106DDF4P+16)), bareinterval(-0x4.BDE3C915168D8P+4, -0x3.84ED584601B4CP+0)) - @test isequal_interval(tan(interval(0x1.A9AF913EE27CFP+8, 0x1.A9AFA6D06E549P+8)), interval(-0x2.CB455269CB954P+16, -0xB.ACE6E2EAA9098P+8)) + @test isequal_interval(tan(bareinterval(0x1.A9AF913EE27CFP+8, 0x1.A9AFA6D06E549P+8)), bareinterval(-0x2.CB455269CB954P+16, -0xB.ACE6E2EAA9098P+8)) - @test isequal_interval(tan(interval(0x7.64CF403A51948P+8, 0x7.64D139F1912E4P+8)), interval(-0x5.38F704820A47CP+28, -0x8.19686283B81E8P+4)) + @test isequal_interval(tan(bareinterval(0x7.64CF403A51948P+8, 0x7.64D139F1912E4P+8)), bareinterval(-0x5.38F704820A47CP+28, -0x8.19686283B81E8P+4)) - @test isequal_interval(tan(interval(0x4.1437B08F8BA70P+16, 0x4.1439A27E86D50P+16)), interval(-0x1.3ADB30F7A9B56P+24, +0x6.48C7464A8F9A0P-4)) + @test isequal_interval(tan(bareinterval(0x4.1437B08F8BA70P+16, 0x4.1439A27E86D50P+16)), bareinterval(-0x1.3ADB30F7A9B56P+24, +0x6.48C7464A8F9A0P-4)) - @test isequal_interval(tan(interval(0x2.74518B3BAFB7CP+4, 0x2.74518DE5A60C0P+4)), interval(-0xF.8E3A10DB36640P+24, -0x5.FF456443FD8B8P+16)) + @test isequal_interval(tan(bareinterval(0x2.74518B3BAFB7CP+4, 0x2.74518DE5A60C0P+4)), bareinterval(-0xF.8E3A10DB36640P+24, -0x5.FF456443FD8B8P+16)) - @test isequal_interval(tan(interval(0x1.DD85A7816A0FFP+4, 0x1.DD89849DFDF09P+4)), interval(-0x3.FA5C8BD1A67ECP+20, -0x4.23D96B0387510P+8)) + @test isequal_interval(tan(bareinterval(0x1.DD85A7816A0FFP+4, 0x1.DD89849DFDF09P+4)), bareinterval(-0x3.FA5C8BD1A67ECP+20, -0x4.23D96B0387510P+8)) - @test isequal_interval(tan(interval(0x1.AB41B29964887P+4, 0x1.B5CBD4ED0D1DDP+4)), interval(-0x7.FC8B577B97310P+16, -0x1.4AB8A7BB81552P+0)) + @test isequal_interval(tan(bareinterval(0x1.AB41B29964887P+4, 0x1.B5CBD4ED0D1DDP+4)), bareinterval(-0x7.FC8B577B97310P+16, -0x1.4AB8A7BB81552P+0)) - @test isequal_interval(tan(interval(0x1.19454E95BC804P+12, 0x1.194551E9AD95AP+12)), interval(-0x1.2A53ECF4C9B1AP+12, -0x3.D27F074C2DA94P+8)) + @test isequal_interval(tan(bareinterval(0x1.19454E95BC804P+12, 0x1.194551E9AD95AP+12)), bareinterval(-0x1.2A53ECF4C9B1AP+12, -0x3.D27F074C2DA94P+8)) - @test isequal_interval(tan(interval(0x4.C4823D2C30D00P+8, 0x4.C482DEAE395CCP+8)), interval(-0x7.F7B434A3F3544P+28, -0x1.95C659F53B09BP+8)) + @test isequal_interval(tan(bareinterval(0x4.C4823D2C30D00P+8, 0x4.C482DEAE395CCP+8)), bareinterval(-0x7.F7B434A3F3544P+28, -0x1.95C659F53B09BP+8)) - @test isequal_interval(tan(interval(0x1.DD85BAAB9BAF9P+4, 0x1.DD8660423BAACP+4)), interval(-0xD.2F5338751C9C8P+12, -0x1.623D682415BE0P+12)) + @test isequal_interval(tan(bareinterval(0x1.DD85BAAB9BAF9P+4, 0x1.DD8660423BAACP+4)), bareinterval(-0xD.2F5338751C9C8P+12, -0x1.623D682415BE0P+12)) - @test isequal_interval(tan(interval(0x2.F798BB3536690P+16, 0x2.F79A363308C32P+16)), interval(-0x2.F8C1AC15A9CCEP+16, -0x1.731B7ACF94603P-4)) + @test isequal_interval(tan(bareinterval(0x2.F798BB3536690P+16, 0x2.F79A363308C32P+16)), bareinterval(-0x2.F8C1AC15A9CCEP+16, -0x1.731B7ACF94603P-4)) - @test isequal_interval(tan(interval(0x1.78FDB9F143616P+4, 0x1.78FDB9F143616P+4)), interval(-0xC.9CFD638FE0A18P+24, -0xC.9CFD638FE0A10P+24)) + @test isequal_interval(tan(bareinterval(0x1.78FDB9F143616P+4, 0x1.78FDB9F143616P+4)), bareinterval(-0xC.9CFD638FE0A18P+24, -0xC.9CFD638FE0A10P+24)) - @test isequal_interval(tan(interval(0x1.78FDB9F143616P+4, 0x1.79367E02D4EAAP+4)), interval(-0xC.9CFD638FE0A18P+24, -0x4.826BF805C4E68P+4)) + @test isequal_interval(tan(bareinterval(0x1.78FDB9F143616P+4, 0x1.79367E02D4EAAP+4)), bareinterval(-0xC.9CFD638FE0A18P+24, -0x4.826BF805C4E68P+4)) - @test isequal_interval(cot(interval(0x4.51D73651EA89CP+4, 0x4.52EB8E58B411CP+4)), interval(0xE.CC7EFFC39DE08P+0, 0x4.2B94A5E391E20P+16)) + @test isequal_interval(cot(bareinterval(0x4.51D73651EA89CP+4, 0x4.52EB8E58B411CP+4)), bareinterval(0xE.CC7EFFC39DE08P+0, 0x4.2B94A5E391E20P+16)) - @test isequal_interval(cot(interval(0x9.9F02364234BC8P+4, 0x9.9F1458C26EEB8P+4)), interval(0xE.1DCEBD0AA72D0P+4, 0x9.516DD4FA21CF0P+28)) + @test isequal_interval(cot(bareinterval(0x9.9F02364234BC8P+4, 0x9.9F1458C26EEB8P+4)), bareinterval(0xE.1DCEBD0AA72D0P+4, 0x9.516DD4FA21CF0P+28)) - @test isequal_interval(cot(interval(0xC.90FDB8A26FBF8P+0, 0xC.9101A0545D040P+0)), interval(0x4.09E5FC0006C38P+12, 0x1.1A74CC76B6B71P+20)) + @test isequal_interval(cot(bareinterval(0xC.90FDB8A26FBF8P+0, 0xC.9101A0545D040P+0)), bareinterval(0x4.09E5FC0006C38P+12, 0x1.1A74CC76B6B71P+20)) - @test isequal_interval(cot(interval(0x3.88C7990326C68P+4, 0x3.88D4315F9483CP+4)), interval(0x1.3EC2E09B0928AP+8, 0x3.EDBBE6390EF44P+12)) + @test isequal_interval(cot(bareinterval(0x3.88C7990326C68P+4, 0x3.88D4315F9483CP+4)), bareinterval(0x1.3EC2E09B0928AP+8, 0x3.EDBBE6390EF44P+12)) - @test isequal_interval(cot(interval(0x4.4EB2F3113085CP+8, 0x4.4EB2F4C8B0144P+8)), interval(0x9.51D206F220E70P+12, 0xC.5DDA26E3680B8P+28)) + @test isequal_interval(cot(bareinterval(0x4.4EB2F3113085CP+8, 0x4.4EB2F4C8B0144P+8)), bareinterval(0x9.51D206F220E70P+12, 0xC.5DDA26E3680B8P+28)) - @test isequal_interval(cot(interval(0x6.487ED6E2382ECP+0, 0x9.3AA74D45D1138P+0)), interval(-0x5.0BA299C8F7644P+0, +0x8.CE26D93009840P+20)) + @test isequal_interval(cot(bareinterval(0x6.487ED6E2382ECP+0, 0x9.3AA74D45D1138P+0)), bareinterval(-0x5.0BA299C8F7644P+0, +0x8.CE26D93009840P+20)) - @test isequal_interval(cot(interval(0xC.CA857372B5428P+12, 0xC.CA86C93A948E0P+12)), interval(0xB.F4CB43CC4C9E8P+0, 0x9.40D848DDFC130P+16)) + @test isequal_interval(cot(bareinterval(0xC.CA857372B5428P+12, 0xC.CA86C93A948E0P+12)), bareinterval(0xB.F4CB43CC4C9E8P+0, 0x9.40D848DDFC130P+16)) - @test isequal_interval(cot(interval(0x2.F51FB358D6800P+8, 0x2.F51FCB23CA942P+8)), interval(0xA.BBFD5C1B7C1D8P+8, 0x1.1E2116D584957P+20)) + @test isequal_interval(cot(bareinterval(0x2.F51FB358D6800P+8, 0x2.F51FCB23CA942P+8)), bareinterval(0xA.BBFD5C1B7C1D8P+8, 0x1.1E2116D584957P+20)) - @test isequal_interval(cot(interval(0xB.C1A554F7480E0P+8, 0xB.C1A56FE0FC750P+8)), interval(0x8.33C065BCB81C8P+8, 0x3.B8E9A35DDF6BCP+12)) + @test isequal_interval(cot(bareinterval(0xB.C1A554F7480E0P+8, 0xB.C1A56FE0FC750P+8)), bareinterval(0x8.33C065BCB81C8P+8, 0x3.B8E9A35DDF6BCP+12)) - @test isequal_interval(cot(interval(0x3.243F6AE2FD3D8P+0, 0x3.243FB3C602324P+0)), interval(0x3.7ECF31F964F42P+16, 0x2.D46AD05A0B746P+24)) + @test isequal_interval(cot(bareinterval(0x3.243F6AE2FD3D8P+0, 0x3.243FB3C602324P+0)), bareinterval(0x3.7ECF31F964F42P+16, 0x2.D46AD05A0B746P+24)) - @test isequal_interval(cot(interval(0x3.C4780CC209478P+8, 0x3.C47856FD49FFEP+8)), interval(0x3.72D85B3269A44P+8, 0x3.28E454E439A90P+24)) + @test isequal_interval(cot(bareinterval(0x3.C4780CC209478P+8, 0x3.C47856FD49FFEP+8)), bareinterval(0x3.72D85B3269A44P+8, 0x3.28E454E439A90P+24)) - @test isequal_interval(cot(interval(0x6.487ED519B0E68P+0, 0x6.488A1AA011958P+0)), interval(0x1.6B6333E883806P+12, 0x1.D9B101DF34E20P+28)) + @test isequal_interval(cot(bareinterval(0x6.487ED519B0E68P+0, 0x6.488A1AA011958P+0)), bareinterval(0x1.6B6333E883806P+12, 0x1.D9B101DF34E20P+28)) - @test isequal_interval(cot(interval(0x3.88C757DD16D52P+4, 0x3.8A405475741F0P+4)), interval(0xA.D59BACA695410P+0, 0x4.91A509DE53224P+24)) + @test isequal_interval(cot(bareinterval(0x3.88C757DD16D52P+4, 0x3.8A405475741F0P+4)), bareinterval(0xA.D59BACA695410P+0, 0x4.91A509DE53224P+24)) - @test isequal_interval(cot(interval(0x6.487ED56D74E68P+0, 0x7.5283077755B9CP+0)), interval(0x9.691CCDB975190P-4, 0x2.C52AD6475D346P+24)) + @test isequal_interval(cot(bareinterval(0x6.487ED56D74E68P+0, 0x7.5283077755B9CP+0)), bareinterval(0x9.691CCDB975190P-4, 0x2.C52AD6475D346P+24)) - @test isequal_interval(cot(interval(0x5.46E61C5D6BD60P+8, 0x5.46E643F35C84CP+8)), interval(0x4.4551872667304P+4, 0x4.7465D978E9638P+4)) + @test isequal_interval(cot(bareinterval(0x5.46E61C5D6BD60P+8, 0x5.46E643F35C84CP+8)), bareinterval(0x4.4551872667304P+4, 0x4.7465D978E9638P+4)) - @test isequal_interval(cot(interval(0x1.921FBC1E1D6F1P+4, 0x1.9274C7419D752P+4)), interval(0x3.02439C1295BB8P+4, 0x2.55DE9F3FCCF28P+16)) + @test isequal_interval(cot(bareinterval(0x1.921FBC1E1D6F1P+4, 0x1.9274C7419D752P+4)), bareinterval(0x3.02439C1295BB8P+4, 0x2.55DE9F3FCCF28P+16)) - @test isequal_interval(cot(interval(0x1.87E07A6BC787DP+16, 0x1.87E07BE653F0BP+16)), interval(0xA.D1F5D5DED35E0P+4, 0x7.55F4ABD4357C8P+28)) + @test isequal_interval(cot(bareinterval(0x1.87E07A6BC787DP+16, 0x1.87E07BE653F0BP+16)), bareinterval(0xA.D1F5D5DED35E0P+4, 0x7.55F4ABD4357C8P+28)) - @test isequal_interval(cot(interval(0x2.5BA3D0708DC04P+16, 0x2.5BA413F0B89B0P+16)), interval(0x3.84ED5845DBFB2P+0, 0x4.BDE3C91120740P+4)) + @test isequal_interval(cot(bareinterval(0x2.5BA3D0708DC04P+16, 0x2.5BA413F0B89B0P+16)), bareinterval(0x3.84ED5845DBFB2P+0, 0x4.BDE3C91120740P+4)) - @test isequal_interval(cot(interval(0x1.A81D71899E3A2P+8, 0x1.A81D871B2A11CP+8)), interval(0xB.ACE6E2E9DA370P+8, 0x2.CB45525DF368EP+16)) + @test isequal_interval(cot(bareinterval(0x1.A81D71899E3A2P+8, 0x1.A81D871B2A11CP+8)), bareinterval(0xB.ACE6E2E9DA370P+8, 0x2.CB45525DF368EP+16)) - @test isequal_interval(cot(interval(0x7.633D20850D51CP+8, 0x7.633F1A3C4CEB8P+8)), interval(0x8.19686283704C0P+4, 0x5.38D928BC4D11CP+28)) + @test isequal_interval(cot(bareinterval(0x7.633D20850D51CP+8, 0x7.633F1A3C4CEB8P+8)), bareinterval(0x8.19686283704C0P+4, 0x5.38D928BC4D11CP+28)) - @test isequal_interval(cot(interval(0x4.14361E6FD662CP+16, 0x4.1438105ED190CP+16)), interval(-0x6.48C7464AC3A74P-4, +0x1.3AD6ED9B4C193P+24)) + @test isequal_interval(cot(bareinterval(0x4.14361E6FD662CP+16, 0x4.1438105ED190CP+16)), bareinterval(-0x6.48C7464AC3A74P-4, +0x1.3AD6ED9B4C193P+24)) - @test isequal_interval(cot(interval(0x2.5B2F8FE76B8ACP+4, 0x2.5B2F929161DF0P+4)), interval(0x5.FF45640D6BF8CP+16, 0xF.8E38A1B8F3CE0P+24)) + @test isequal_interval(cot(bareinterval(0x2.5B2F8FE76B8ACP+4, 0x2.5B2F929161DF0P+4)), bareinterval(0x5.FF45640D6BF8CP+16, 0xF.8E38A1B8F3CE0P+24)) - @test isequal_interval(cot(interval(0x1.C463AC2D25E2EP+4, 0x1.C4678949B9C38P+4)), interval(0x4.23D96B037E734P+8, 0x3.FA5C8B4EB13BAP+20)) + @test isequal_interval(cot(bareinterval(0x1.C463AC2D25E2EP+4, 0x1.C4678949B9C38P+4)), bareinterval(0x4.23D96B037E734P+8, 0x3.FA5C8B4EB13BAP+20)) - @test isequal_interval(cot(interval(0x1.921FB745205B6P+4, 0x1.9CA9D998C8F0CP+4)), interval(0x1.4AB8A7BB8153CP+0, 0x7.FC8B575A99618P+16)) + @test isequal_interval(cot(bareinterval(0x1.921FB745205B6P+4, 0x1.9CA9D998C8F0CP+4)), bareinterval(0x1.4AB8A7BB8153CP+0, 0x7.FC8B575A99618P+16)) - @test isequal_interval(cot(interval(0x1.192C2C9A683C1P+12, 0x1.192C2FEE59517P+12)), interval(0x3.D27F074ED4C1AP+8, 0x1.2A53ECF8BBB09P+12)) + @test isequal_interval(cot(bareinterval(0x1.192C2C9A683C1P+12, 0x1.192C2FEE59517P+12)), bareinterval(0x3.D27F074ED4C1AP+8, 0x1.2A53ECF8BBB09P+12)) - @test isequal_interval(cot(interval(0x4.C2F01D76EC8D4P+8, 0x4.C2F0BEF8F51A0P+8)), interval(0x1.95C659F50F06FP+8, 0x7.F76EB663A7898P+28)) + @test isequal_interval(cot(bareinterval(0x4.C2F01D76EC8D4P+8, 0x4.C2F0BEF8F51A0P+8)), bareinterval(0x1.95C659F50F06FP+8, 0x7.F76EB663A7898P+28)) - @test isequal_interval(cot(interval(0x1.C463BF5757828P+4, 0x1.C46464EDF77DBP+4)), interval(0x1.623D682405E56P+12, 0xD.2F53386F7DF28P+12)) + @test isequal_interval(cot(bareinterval(0x1.C463BF5757828P+4, 0x1.C46464EDF77DBP+4)), bareinterval(0x1.623D682405E56P+12, 0xD.2F53386F7DF28P+12)) - @test isequal_interval(cot(interval(0x2.F79729158124CP+16, 0x2.F798A413537EEP+16)), interval(0x1.731B7ACF66E92P-4, 0x2.F8C19331ECBFCP+16)) + @test isequal_interval(cot(bareinterval(0x2.F79729158124CP+16, 0x2.F798A413537EEP+16)), bareinterval(0x1.731B7ACF66E92P-4, 0x2.F8C19331ECBFCP+16)) - @test isequal_interval(cot(interval(0x3.371943E536E9EP+8, 0x3.371D0784693FAP+8)), interval(0x3.E06D09FC7DDC2P+4, 0x2.C1B5E6F32FDEEP+8)) + @test isequal_interval(cot(bareinterval(0x3.371943E536E9EP+8, 0x3.371D0784693FAP+8)), bareinterval(0x3.E06D09FC7DDC2P+4, 0x2.C1B5E6F32FDEEP+8)) - @test isequal_interval(cot(interval(0x1.5FDBBE9CFF344P+4, 0x1.601482AE90BD8P+4)), interval(0x4.826BF805C583CP+4, 0xC.9CFDB05DEF930P+24)) + @test isequal_interval(cot(bareinterval(0x1.5FDBBE9CFF344P+4, 0x1.601482AE90BD8P+4)), bareinterval(0x4.826BF805C583CP+4, 0xC.9CFDB05DEF930P+24)) - @test isequal_interval(asin(interval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), interval(-0x3.11A309475E764P-164, -0xC.3784302E15500P-680)) + @test isequal_interval(asin(bareinterval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), bareinterval(-0x3.11A309475E764P-164, -0xC.3784302E15500P-680)) - @test isequal_interval(asin(interval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), interval(-0x5.7DD17A4248D3CP-280, -0x2.898FC0F386F74P-640)) + @test isequal_interval(asin(bareinterval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), bareinterval(-0x5.7DD17A4248D3CP-280, -0x2.898FC0F386F74P-640)) - @test isequal_interval(asin(interval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), interval(-0xE.D83DCD7F564A8P-296, -0x1.62F61FBA0F40FP-764)) + @test isequal_interval(asin(bareinterval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), bareinterval(-0xE.D83DCD7F564A8P-296, -0x1.62F61FBA0F40FP-764)) - @test isequal_interval(asin(interval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), interval(-0x1.67712A1E64C2DP-944, -0x1.C0102C4D258EFP-976)) + @test isequal_interval(asin(bareinterval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), bareinterval(-0x1.67712A1E64C2DP-944, -0x1.C0102C4D258EFP-976)) - @test isequal_interval(asin(interval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), interval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4BP-612)) + @test isequal_interval(asin(bareinterval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), bareinterval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4BP-612)) - @test isequal_interval(asin(interval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), interval(-0x1.BCD3FEB3B0176P-640, +0x1.BEBE69E3BF3C3P-536)) + @test isequal_interval(asin(bareinterval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), bareinterval(-0x1.BCD3FEB3B0176P-640, +0x1.BEBE69E3BF3C3P-536)) - @test isequal_interval(asin(interval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), interval(-0x1.2469575189328P-372, -0x7.51C0C39F58A4CP-1008)) + @test isequal_interval(asin(bareinterval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), bareinterval(-0x1.2469575189328P-372, -0x7.51C0C39F58A4CP-1008)) - @test isequal_interval(asin(interval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), interval(-0x1.C4D163A6CCCDAP-336, -0x1.3BEE6DAB70397P-796)) + @test isequal_interval(asin(bareinterval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), bareinterval(-0x1.C4D163A6CCCDAP-336, -0x1.3BEE6DAB70397P-796)) - @test isequal_interval(asin(interval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), interval(-0x2.0FAE5DE90C98EP-896, -0x2.2079777EC2418P-976)) + @test isequal_interval(asin(bareinterval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), bareinterval(-0x2.0FAE5DE90C98EP-896, -0x2.2079777EC2418P-976)) - @test isequal_interval(asin(interval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), interval(-0x1.08C248C37E53CP-816, +0x2.8C9F04EE5DE86P-948)) + @test isequal_interval(asin(bareinterval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), bareinterval(-0x1.08C248C37E53CP-816, +0x2.8C9F04EE5DE86P-948)) - @test isequal_interval(asin(interval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), interval(-0x2.0002542B01476P-228, +0x2.4D59F217BF74EP-796)) + @test isequal_interval(asin(bareinterval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), bareinterval(-0x2.0002542B01476P-228, +0x2.4D59F217BF74EP-796)) - @test isequal_interval(asin(interval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), interval(0xD.D4033889729A0P-844, 0x7.44451BF919D7CP-556)) + @test isequal_interval(asin(bareinterval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), bareinterval(0xD.D4033889729A0P-844, 0x7.44451BF919D7CP-556)) - @test isequal_interval(asin(interval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), interval(-0x2.08918B016995EP-64, +0x3.3FC26450C6E4CP-268)) + @test isequal_interval(asin(bareinterval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), bareinterval(-0x2.08918B016995EP-64, +0x3.3FC26450C6E4CP-268)) - @test isequal_interval(asin(interval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), interval(-0x2.66C95BD8D7718P-388, +0x1.7E16B310F878BP-232)) + @test isequal_interval(asin(bareinterval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), bareinterval(-0x2.66C95BD8D7718P-388, +0x1.7E16B310F878BP-232)) - @test isequal_interval(asin(interval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), interval(-0x3.D9C66BD30B776P-256, -0x4.A8C30F678CB68P-456)) + @test isequal_interval(asin(bareinterval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), bareinterval(-0x3.D9C66BD30B776P-256, -0x4.A8C30F678CB68P-456)) - @test isequal_interval(asin(interval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), interval(-0x1.AA045CCB15AEEP-804, +0xD.450C473266E68P-24)) + @test isequal_interval(asin(bareinterval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), bareinterval(-0x1.AA045CCB15AEEP-804, +0xD.450C473266E68P-24)) - @test isequal_interval(asin(interval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), interval(-0x2.23ADFA571FC3EP-344, -0x1.30D1074DC059EP-868)) + @test isequal_interval(asin(bareinterval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), bareinterval(-0x2.23ADFA571FC3EP-344, -0x1.30D1074DC059EP-868)) - @test isequal_interval(asin(interval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), interval(-0x3.DFBC1A4BF388AP-68, -0x4.A89E39B247C84P-840)) + @test isequal_interval(asin(bareinterval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), bareinterval(-0x3.DFBC1A4BF388AP-68, -0x4.A89E39B247C84P-840)) - @test isequal_interval(asin(interval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), interval(0x9.583064525D370P-496, 0x2.C67652F06A560P-408)) + @test isequal_interval(asin(bareinterval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), bareinterval(0x9.583064525D370P-496, 0x2.C67652F06A560P-408)) - @test isequal_interval(asin(interval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), interval(-0x3.38BF880EC3084P-304, -0x7.7B19877E536ACP-512)) + @test isequal_interval(asin(bareinterval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), bareinterval(-0x3.38BF880EC3084P-304, -0x7.7B19877E536ACP-512)) - @test isequal_interval(asin(interval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), interval(-0x2.ADBF037238704P-44, +0x1.98DC940C3AE1FP-564)) + @test isequal_interval(asin(bareinterval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), bareinterval(-0x2.ADBF037238704P-44, +0x1.98DC940C3AE1FP-564)) - @test isequal_interval(asin(interval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), interval(-0x4.E4A79C48B3A5CP-328, +0xA.28B02E59D39E0P-856)) + @test isequal_interval(asin(bareinterval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), bareinterval(-0x4.E4A79C48B3A5CP-328, +0xA.28B02E59D39E0P-856)) - @test isequal_interval(asin(interval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), interval(-0x6.80D3E87B911DCP-232, -0x2.3DF54212C46E4P-520)) + @test isequal_interval(asin(bareinterval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), bareinterval(-0x6.80D3E87B911DCP-232, -0x2.3DF54212C46E4P-520)) - @test isequal_interval(asin(interval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), interval(-0x1.4E54C309C46F9P-480, +0x9.47E982AC83FA0P-688)) + @test isequal_interval(asin(bareinterval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), bareinterval(-0x1.4E54C309C46F9P-480, +0x9.47E982AC83FA0P-688)) - @test isequal_interval(asin(interval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), interval(-0x2.276202227A6E0P-808, +0x1.C53E9BA64FAE0P-768)) + @test isequal_interval(asin(bareinterval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), bareinterval(-0x2.276202227A6E0P-808, +0x1.C53E9BA64FAE0P-768)) - @test isequal_interval(asin(interval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), interval(-0x4.8E4B4D7BA6DD4P-212, -0x1.4B35284C1064BP-548)) + @test isequal_interval(asin(bareinterval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), bareinterval(-0x4.8E4B4D7BA6DD4P-212, -0x1.4B35284C1064BP-548)) - @test isequal_interval(asin(interval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), interval(-0x3.5C52B8D9FF584P-248, -0x2.AF868D652B866P-912)) + @test isequal_interval(asin(bareinterval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), bareinterval(-0x3.5C52B8D9FF584P-248, -0x2.AF868D652B866P-912)) - @test isequal_interval(asin(interval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), interval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38170P-664)) + @test isequal_interval(asin(bareinterval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), bareinterval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38170P-664)) - @test isequal_interval(asin(interval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), interval(-0x3.68B35F23B2508P-560, +0x9.F9C9246D05140P-304)) + @test isequal_interval(asin(bareinterval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), bareinterval(-0x3.68B35F23B2508P-560, +0x9.F9C9246D05140P-304)) - @test isequal_interval(asin(interval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), interval(-0xA.BDE70B6850EA8P-516, +0x2.BB76D5BF703FCP-1020)) + @test isequal_interval(asin(bareinterval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), bareinterval(-0xA.BDE70B6850EA8P-516, +0x2.BB76D5BF703FCP-1020)) - @test isequal_interval(acos(interval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), interval(0x1.921FA7FF368A5P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), bareinterval(0x1.921FA7FF368A5P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442FC7P+0)) + @test isequal_interval(acos(bareinterval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442FC7P+0)) - @test isequal_interval(acos(interval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), interval(0x1.7A77BFCCF5A9DP-232, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), bareinterval(0x1.7A77BFCCF5A9DP-232, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), interval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) + @test isequal_interval(atan(bareinterval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), bareinterval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) - @test isequal_interval(atan(interval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), interval(0xE.20FF41BD18050P-204, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), bareinterval(0xE.20FF41BD18050P-204, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), interval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) + @test isequal_interval(atan(bareinterval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), bareinterval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) - @test isequal_interval(atan(interval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), interval(0xE.3062E34353278P-4, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), bareinterval(0xE.3062E34353278P-4, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), interval(0x2.404E44C49C642P-440, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), bareinterval(0x2.404E44C49C642P-440, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), interval(0x1.63A15E999EB63P-344, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), bareinterval(0x1.63A15E999EB63P-344, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), interval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) + @test isequal_interval(atan(bareinterval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), bareinterval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) - @test isequal_interval(atan(interval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), interval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) + @test isequal_interval(atan(bareinterval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), bareinterval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) - @test isequal_interval(atan(interval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), interval(0x2.6ABC15579B2B0P-48, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), bareinterval(0x2.6ABC15579B2B0P-48, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), interval(0x1.920057E3A66F1P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), bareinterval(0x1.920057E3A66F1P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), interval(0x1.921FB54442D13P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), bareinterval(0x1.921FB54442D13P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), interval(0x6.3E590E6264518P-172, 0x1.9172A3136EB8DP+0)) + @test isequal_interval(atan(bareinterval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), bareinterval(0x6.3E590E6264518P-172, 0x1.9172A3136EB8DP+0)) - @test isequal_interval(atan(interval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), interval(0x6.ACFA418D8F928P-544, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), bareinterval(0x6.ACFA418D8F928P-544, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), interval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) + @test isequal_interval(atan(bareinterval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), bareinterval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) - @test isequal_interval(atan(interval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), interval(0xC.41329461A0C28P-512, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), bareinterval(0xC.41329461A0C28P-512, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), interval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) + @test isequal_interval(atan(bareinterval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), bareinterval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) - @test isequal_interval(atan(interval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), interval(0x6.65D7E0A247774P-56, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), bareinterval(0x6.65D7E0A247774P-56, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), interval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) + @test isequal_interval(atan(bareinterval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), bareinterval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) - @test isequal_interval(atan(interval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), interval(0x6.36B661DCE2684P-236, 0x1.921700D14CFE5P+0)) + @test isequal_interval(atan(bareinterval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), bareinterval(0x6.36B661DCE2684P-236, 0x1.921700D14CFE5P+0)) - @test isequal_interval(atan(interval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), interval(0x1.EB0E1AB78F313P-480, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), bareinterval(0x1.EB0E1AB78F313P-480, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), interval(0x7.4CF193131FA60P-192, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), bareinterval(0x7.4CF193131FA60P-192, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), interval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) + @test isequal_interval(atan(bareinterval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), bareinterval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) - @test isequal_interval(atan(interval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), interval(0x3.A0EE84451C92AP-324, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), bareinterval(0x3.A0EE84451C92AP-324, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), interval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) + @test isequal_interval(atan(bareinterval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), bareinterval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) - @test isequal_interval(acot(interval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), interval(0x6.5B5B8AA0A6884P-116, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), bareinterval(0x6.5B5B8AA0A6884P-116, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), interval(0x6.23FD67FFA09A4P-276, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), bareinterval(0x6.23FD67FFA09A4P-276, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), interval(0x6.70A3F8408ABF0P-296, 0xC.099B90EB0FA30P-256)) + @test isequal_interval(acot(bareinterval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), bareinterval(0x6.70A3F8408ABF0P-296, 0xC.099B90EB0FA30P-256)) - @test isequal_interval(acot(interval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), interval(0x3.3FB79247499D6P-336, 0xA.F1987100D9F08P-4)) + @test isequal_interval(acot(bareinterval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), bareinterval(0x3.3FB79247499D6P-336, 0xA.F1987100D9F08P-4)) - @test isequal_interval(acot(interval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), interval(0x2.38F904C465F6AP-240, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), bareinterval(0x2.38F904C465F6AP-240, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), interval(0x2.87E9C09D98938P-176, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), bareinterval(0x2.87E9C09D98938P-176, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), interval(0x8.3E949ACCB0F88P-316, 0x9.443E1DD721FE8P-184)) + @test isequal_interval(acot(bareinterval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), bareinterval(0x8.3E949ACCB0F88P-316, 0x9.443E1DD721FE8P-184)) - @test isequal_interval(acot(interval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), interval(0x5.9028FAA64FBC8P-260, 0x1.921FB54442CF2P+0)) + @test isequal_interval(acot(bareinterval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), bareinterval(0x5.9028FAA64FBC8P-260, 0x1.921FB54442CF2P+0)) - @test isequal_interval(acot(interval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), interval(0x1.2067D7F96AFE5P-656, 0x1.F5D609C62725FP-12)) + @test isequal_interval(acot(bareinterval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), bareinterval(0x1.2067D7F96AFE5P-656, 0x1.F5D609C62725FP-12)) - @test isequal_interval(acot(interval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), interval(0x6.09322FE56F794P-692, 0x4.E7223FE097808P-52)) + @test isequal_interval(acot(bareinterval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), bareinterval(0x6.09322FE56F794P-692, 0x4.E7223FE097808P-52)) - @test isequal_interval(acot(interval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), interval(0xA.D1230D418C238P-12, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), bareinterval(0xA.D1230D418C238P-12, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), interval(0x6.3F7C8D3DDFC74P-992, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), bareinterval(0x6.3F7C8D3DDFC74P-992, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), interval(0x9.E1C9C04F15630P-356, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), bareinterval(0x9.E1C9C04F15630P-356, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), interval(0x1.326922CF32B2EP-240, 0x2.7ECD966556E9CP-192)) + @test isequal_interval(acot(bareinterval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), bareinterval(0x1.326922CF32B2EP-240, 0x2.7ECD966556E9CP-192)) - @test isequal_interval(acot(interval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), interval(0x1.5F401B7014200P-568, 0x1.3A84A0CB7AC42P-428)) + @test isequal_interval(acot(bareinterval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), bareinterval(0x1.5F401B7014200P-568, 0x1.3A84A0CB7AC42P-428)) - @test isequal_interval(acot(interval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), interval(0x4.59002C447A028P-172, 0x1.921FB54442D18P+0)) + @test isequal_interval(acot(bareinterval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), bareinterval(0x4.59002C447A028P-172, 0x1.921FB54442D18P+0)) - @test isequal_interval(acot(interval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), interval(0x8.B472F5D335130P-16, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), bareinterval(0x8.B472F5D335130P-16, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), interval(0xA.042BAEF7787B8P-136, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), bareinterval(0xA.042BAEF7787B8P-136, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), interval(0x9.21EF65D6A5190P-224, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), bareinterval(0x9.21EF65D6A5190P-224, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), interval(0x1.6F8ED062CAC9BP-328, 0x8.C7ADFB6368868P-256)) + @test isequal_interval(acot(bareinterval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), bareinterval(0x1.6F8ED062CAC9BP-328, 0x8.C7ADFB6368868P-256)) - @test isequal_interval(acot(interval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), interval(0x1.03413E0E19942P-652, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), bareinterval(0x1.03413E0E19942P-652, 0x1.921FB54442D19P+0)) - @test isequal_interval(acot(interval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(acot(bareinterval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(sinh(interval(-0x3.53DC9496DE0A0P-160, -0xC.287E0E10EC1B8P-960)), interval(-0x3.53DC9496DE0A2P-160, -0xC.287E0E10EC1B8P-960)) + @test isequal_interval(sinh(bareinterval(-0x3.53DC9496DE0A0P-160, -0xC.287E0E10EC1B8P-960)), bareinterval(-0x3.53DC9496DE0A2P-160, -0xC.287E0E10EC1B8P-960)) - @test isequal_interval(sinh(interval(-0x1.CF3637DCBCC9AP-452, -0x5.E4846462FF33CP-636)), interval(-0x1.CF3637DCBCC9BP-452, -0x5.E4846462FF33CP-636)) + @test isequal_interval(sinh(bareinterval(-0x1.CF3637DCBCC9AP-452, -0x5.E4846462FF33CP-636)), bareinterval(-0x1.CF3637DCBCC9BP-452, -0x5.E4846462FF33CP-636)) - @test isequal_interval(sinh(interval(-0x1.0362421843787P+0, -0x3.3D2CCEF698A5AP-972)), interval(-0x1.32197576F3697P+0, -0x3.3D2CCEF698A5AP-972)) + @test isequal_interval(sinh(bareinterval(-0x1.0362421843787P+0, -0x3.3D2CCEF698A5AP-972)), bareinterval(-0x1.32197576F3697P+0, -0x3.3D2CCEF698A5AP-972)) - @test isequal_interval(sinh(interval(-0x1.494A24A7585D1P-380, +0x1.A0790A9E3013EP-604)), interval(-0x1.494A24A7585D2P-380, +0x1.A0790A9E3013FP-604)) + @test isequal_interval(sinh(bareinterval(-0x1.494A24A7585D1P-380, +0x1.A0790A9E3013EP-604)), bareinterval(-0x1.494A24A7585D2P-380, +0x1.A0790A9E3013FP-604)) - @test isequal_interval(sinh(interval(-0x2.B64BC5E999866P-368, -0xF.0633041110C28P-572)), interval(-0x2.B64BC5E999868P-368, -0xF.0633041110C28P-572)) + @test isequal_interval(sinh(bareinterval(-0x2.B64BC5E999866P-368, -0xF.0633041110C28P-572)), bareinterval(-0x2.B64BC5E999868P-368, -0xF.0633041110C28P-572)) - @test isequal_interval(sinh(interval(-0x7.56F52F4FED854P-336, -0x4.F40A3934B3354P-416)), interval(-0x7.56F52F4FED858P-336, -0x4.F40A3934B3354P-416)) + @test isequal_interval(sinh(bareinterval(-0x7.56F52F4FED854P-336, -0x4.F40A3934B3354P-416)), bareinterval(-0x7.56F52F4FED858P-336, -0x4.F40A3934B3354P-416)) - @test isequal_interval(sinh(interval(-0xA.0E33C2BA95C88P-48, -0x1.1927CA3847669P-808)), interval(-0xA.0E33C2BA95C90P-48, -0x1.1927CA3847669P-808)) + @test isequal_interval(sinh(bareinterval(-0xA.0E33C2BA95C88P-48, -0x1.1927CA3847669P-808)), bareinterval(-0xA.0E33C2BA95C90P-48, -0x1.1927CA3847669P-808)) - @test isequal_interval(sinh(interval(-0x1.1BBBD6FE8B950P-208, -0x1.463A32DBA649DP-220)), interval(-0x1.1BBBD6FE8B951P-208, -0x1.463A32DBA649DP-220)) + @test isequal_interval(sinh(bareinterval(-0x1.1BBBD6FE8B950P-208, -0x1.463A32DBA649DP-220)), bareinterval(-0x1.1BBBD6FE8B951P-208, -0x1.463A32DBA649DP-220)) - @test isequal_interval(sinh(interval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C3P-96)), interval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C4P-96)) + @test isequal_interval(sinh(bareinterval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C3P-96)), bareinterval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C4P-96)) - @test isequal_interval(sinh(interval(-0x2.E7332C654ABB6P-384, -0x1.4363967367F55P-932)), interval(-0x2.E7332C654ABB8P-384, -0x1.4363967367F55P-932)) + @test isequal_interval(sinh(bareinterval(-0x2.E7332C654ABB6P-384, -0x1.4363967367F55P-932)), bareinterval(-0x2.E7332C654ABB8P-384, -0x1.4363967367F55P-932)) - @test isequal_interval(sinh(interval(-0x1.55EBB1D70A46EP-592, +0x4.733FA51468530P-20)), interval(-0x1.55EBB1D70A46FP-592, +0x4.733FA51477038P-20)) + @test isequal_interval(sinh(bareinterval(-0x1.55EBB1D70A46EP-592, +0x4.733FA51468530P-20)), bareinterval(-0x1.55EBB1D70A46FP-592, +0x4.733FA51477038P-20)) - @test isequal_interval(sinh(interval(-0x1.1B4B8388A3D92P-340, -0xD.51D4A3CE4C490P-600)), interval(-0x1.1B4B8388A3D93P-340, -0xD.51D4A3CE4C490P-600)) + @test isequal_interval(sinh(bareinterval(-0x1.1B4B8388A3D92P-340, -0xD.51D4A3CE4C490P-600)), bareinterval(-0x1.1B4B8388A3D93P-340, -0xD.51D4A3CE4C490P-600)) - @test isequal_interval(sinh(interval(-0x4.21B73745BC4C0P-952, +0xD.E40D83923C3E0P-404)), interval(-0x4.21B73745BC4C4P-952, +0xD.E40D83923C3E8P-404)) + @test isequal_interval(sinh(bareinterval(-0x4.21B73745BC4C0P-952, +0xD.E40D83923C3E0P-404)), bareinterval(-0x4.21B73745BC4C4P-952, +0xD.E40D83923C3E8P-404)) - @test isequal_interval(sinh(interval(-0x1.73D14FA7DA1CBP-504, +0x1.5B3AFEEB17A85P-28)), interval(-0x1.73D14FA7DA1CCP-504, +0x1.5B3AFEEB17A86P-28)) + @test isequal_interval(sinh(bareinterval(-0x1.73D14FA7DA1CBP-504, +0x1.5B3AFEEB17A85P-28)), bareinterval(-0x1.73D14FA7DA1CCP-504, +0x1.5B3AFEEB17A86P-28)) - @test isequal_interval(sinh(interval(-0x3.3CD34997DF066P-320, -0x1.606C7BCE75819P-852)), interval(-0x3.3CD34997DF068P-320, -0x1.606C7BCE75819P-852)) + @test isequal_interval(sinh(bareinterval(-0x3.3CD34997DF066P-320, -0x1.606C7BCE75819P-852)), bareinterval(-0x3.3CD34997DF068P-320, -0x1.606C7BCE75819P-852)) - @test isequal_interval(sinh(interval(-0xC.5356A56E59748P-516, -0x1.33B9A95C55513P-772)), interval(-0xC.5356A56E59750P-516, -0x1.33B9A95C55513P-772)) + @test isequal_interval(sinh(bareinterval(-0xC.5356A56E59748P-516, -0x1.33B9A95C55513P-772)), bareinterval(-0xC.5356A56E59750P-516, -0x1.33B9A95C55513P-772)) - @test isequal_interval(sinh(interval(-0x5.FA887950A63CCP-588, -0x2.B707741B15478P-800)), interval(-0x5.FA887950A63D0P-588, -0x2.B707741B15478P-800)) + @test isequal_interval(sinh(bareinterval(-0x5.FA887950A63CCP-588, -0x2.B707741B15478P-800)), bareinterval(-0x5.FA887950A63D0P-588, -0x2.B707741B15478P-800)) - @test isequal_interval(sinh(interval(-0x2.9476464AAE5BAP-548, +0x4.0734E17C026D4P-784)), interval(-0x2.9476464AAE5BCP-548, +0x4.0734E17C026D8P-784)) + @test isequal_interval(sinh(bareinterval(-0x2.9476464AAE5BAP-548, +0x4.0734E17C026D4P-784)), bareinterval(-0x2.9476464AAE5BCP-548, +0x4.0734E17C026D8P-784)) - @test isequal_interval(sinh(interval(-0xF.A46AC05B0EAA8P-68, +0x1.EFA89F34F4188P-684)), interval(-0xF.A46AC05B0EAB0P-68, +0x1.EFA89F34F4189P-684)) + @test isequal_interval(sinh(bareinterval(-0xF.A46AC05B0EAA8P-68, +0x1.EFA89F34F4188P-684)), bareinterval(-0xF.A46AC05B0EAB0P-68, +0x1.EFA89F34F4189P-684)) - @test isequal_interval(sinh(interval(-0x9.9488CB205AFA8P-124, -0x2.940180D1AA2AEP-556)), interval(-0x9.9488CB205AFB0P-124, -0x2.940180D1AA2AEP-556)) + @test isequal_interval(sinh(bareinterval(-0x9.9488CB205AFA8P-124, -0x2.940180D1AA2AEP-556)), bareinterval(-0x9.9488CB205AFB0P-124, -0x2.940180D1AA2AEP-556)) - @test isequal_interval(sinh(interval(-0x3.F9D9FE5792CE0P-912, -0x3.F00FC8CE24ADCP-1016)), interval(-0x3.F9D9FE5792CE2P-912, -0x3.F00FC8CE24ADCP-1016)) + @test isequal_interval(sinh(bareinterval(-0x3.F9D9FE5792CE0P-912, -0x3.F00FC8CE24ADCP-1016)), bareinterval(-0x3.F9D9FE5792CE2P-912, -0x3.F00FC8CE24ADCP-1016)) - @test isequal_interval(sinh(interval(-0x7.D5A28EF80D6B0P-176, +0xC.5D2B8FFCB2AD8P-756)), interval(-0x7.D5A28EF80D6B4P-176, +0xC.5D2B8FFCB2AE0P-756)) + @test isequal_interval(sinh(bareinterval(-0x7.D5A28EF80D6B0P-176, +0xC.5D2B8FFCB2AD8P-756)), bareinterval(-0x7.D5A28EF80D6B4P-176, +0xC.5D2B8FFCB2AE0P-756)) - @test isequal_interval(sinh(interval(-0x5.B5DCAA821A628P-784, -0x1.48532232C10FDP-940)), interval(-0x5.B5DCAA821A62CP-784, -0x1.48532232C10FDP-940)) + @test isequal_interval(sinh(bareinterval(-0x5.B5DCAA821A628P-784, -0x1.48532232C10FDP-940)), bareinterval(-0x5.B5DCAA821A62CP-784, -0x1.48532232C10FDP-940)) - @test isequal_interval(sinh(interval(0x3.8110D13AB0378P-720, 0x2.77422E18981C2P-44)), interval(0x3.8110D13AB0378P-720, 0x2.77422E18981C4P-44)) + @test isequal_interval(sinh(bareinterval(0x3.8110D13AB0378P-720, 0x2.77422E18981C2P-44)), bareinterval(0x3.8110D13AB0378P-720, 0x2.77422E18981C4P-44)) - @test isequal_interval(sinh(interval(-0x1.4AD562C0B5178P-380, +0x3.CEB34F40EA9BAP-792)), interval(-0x1.4AD562C0B5179P-380, +0x3.CEB34F40EA9BCP-792)) + @test isequal_interval(sinh(bareinterval(-0x1.4AD562C0B5178P-380, +0x3.CEB34F40EA9BAP-792)), bareinterval(-0x1.4AD562C0B5179P-380, +0x3.CEB34F40EA9BCP-792)) - @test isequal_interval(sinh(interval(-0x7.ED02EF56E40B0P-92, -0x1.8C80275A696B0P-552)), interval(-0x7.ED02EF56E40B4P-92, -0x1.8C80275A696B0P-552)) + @test isequal_interval(sinh(bareinterval(-0x7.ED02EF56E40B0P-92, -0x1.8C80275A696B0P-552)), bareinterval(-0x7.ED02EF56E40B4P-92, -0x1.8C80275A696B0P-552)) - @test isequal_interval(sinh(interval(-0x1.56FBE834FC822P-296, -0x3.66041558BACA8P-516)), interval(-0x1.56FBE834FC823P-296, -0x3.66041558BACA8P-516)) + @test isequal_interval(sinh(bareinterval(-0x1.56FBE834FC822P-296, -0x3.66041558BACA8P-516)), bareinterval(-0x1.56FBE834FC823P-296, -0x3.66041558BACA8P-516)) - @test isequal_interval(sinh(interval(-0x6.44524F6FCCF8CP-340, -0x5.3E8ED576A1334P-896)), interval(-0x6.44524F6FCCF90P-340, -0x5.3E8ED576A1334P-896)) + @test isequal_interval(sinh(bareinterval(-0x6.44524F6FCCF8CP-340, -0x5.3E8ED576A1334P-896)), bareinterval(-0x6.44524F6FCCF90P-340, -0x5.3E8ED576A1334P-896)) - @test isequal_interval(sinh(interval(-0x8.92F5BEDA59C78P-268, +0x2.51B11C2EC76BAP-612)), interval(-0x8.92F5BEDA59C80P-268, +0x2.51B11C2EC76BCP-612)) + @test isequal_interval(sinh(bareinterval(-0x8.92F5BEDA59C78P-268, +0x2.51B11C2EC76BAP-612)), bareinterval(-0x8.92F5BEDA59C80P-268, +0x2.51B11C2EC76BCP-612)) - @test isequal_interval(sinh(interval(-0x4.785C46BDC2A50P-244, -0x1.BA5C062DE8F00P-432)), interval(-0x4.785C46BDC2A54P-244, -0x1.BA5C062DE8F00P-432)) + @test isequal_interval(sinh(bareinterval(-0x4.785C46BDC2A50P-244, -0x1.BA5C062DE8F00P-432)), bareinterval(-0x4.785C46BDC2A54P-244, -0x1.BA5C062DE8F00P-432)) - @test isequal_interval(cosh(interval(-0x3.53DC9496DE0A0P-160, -0xC.287E0E10EC1B8P-960)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x3.53DC9496DE0A0P-160, -0xC.287E0E10EC1B8P-960)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.CF3637DCBCC9AP-452, -0x5.E4846462FF33CP-636)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.CF3637DCBCC9AP-452, -0x5.E4846462FF33CP-636)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.0362421843787P+0, -0x3.3D2CCEF698A5AP-972)), interval(0x1.0000000000000P+0, 0x1.8F0A39674B193P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.0362421843787P+0, -0x3.3D2CCEF698A5AP-972)), bareinterval(0x1.0000000000000P+0, 0x1.8F0A39674B193P+0)) - @test isequal_interval(cosh(interval(-0x1.494A24A7585D1P-380, +0x1.A0790A9E3013EP-604)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.494A24A7585D1P-380, +0x1.A0790A9E3013EP-604)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x2.B64BC5E999866P-368, -0xF.0633041110C28P-572)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x2.B64BC5E999866P-368, -0xF.0633041110C28P-572)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x7.56F52F4FED854P-336, -0x4.F40A3934B3354P-416)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x7.56F52F4FED854P-336, -0x4.F40A3934B3354P-416)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0xA.0E33C2BA95C88P-48, -0x1.1927CA3847669P-808)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0xA.0E33C2BA95C88P-48, -0x1.1927CA3847669P-808)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.1BBBD6FE8B950P-208, -0x1.463A32DBA649DP-220)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.1BBBD6FE8B950P-208, -0x1.463A32DBA649DP-220)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C3P-96)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(0x5.290FE84915530P-268, 0x1.8C9AF520C22C3P-96)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x2.E7332C654ABB6P-384, -0x1.4363967367F55P-932)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x2.E7332C654ABB6P-384, -0x1.4363967367F55P-932)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.55EBB1D70A46EP-592, +0x4.733FA51468530P-20)), interval(0x1.0000000000000P+0, 0x1.0000000009E6FP+0)) + @test isequal_interval(cosh(bareinterval(-0x1.55EBB1D70A46EP-592, +0x4.733FA51468530P-20)), bareinterval(0x1.0000000000000P+0, 0x1.0000000009E6FP+0)) - @test isequal_interval(cosh(interval(-0x1.1B4B8388A3D92P-340, -0xD.51D4A3CE4C490P-600)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.1B4B8388A3D92P-340, -0xD.51D4A3CE4C490P-600)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x4.21B73745BC4C0P-952, +0xD.E40D83923C3E0P-404)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x4.21B73745BC4C0P-952, +0xD.E40D83923C3E0P-404)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.73D14FA7DA1CBP-504, +0x1.5B3AFEEB17A85P-28)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.73D14FA7DA1CBP-504, +0x1.5B3AFEEB17A85P-28)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x3.3CD34997DF066P-320, -0x1.606C7BCE75819P-852)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x3.3CD34997DF066P-320, -0x1.606C7BCE75819P-852)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0xC.5356A56E59748P-516, -0x1.33B9A95C55513P-772)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0xC.5356A56E59748P-516, -0x1.33B9A95C55513P-772)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x5.FA887950A63CCP-588, -0x2.B707741B15478P-800)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x5.FA887950A63CCP-588, -0x2.B707741B15478P-800)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x2.9476464AAE5BAP-548, +0x4.0734E17C026D4P-784)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x2.9476464AAE5BAP-548, +0x4.0734E17C026D4P-784)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0xF.A46AC05B0EAA8P-68, +0x1.EFA89F34F4188P-684)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0xF.A46AC05B0EAA8P-68, +0x1.EFA89F34F4188P-684)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x9.9488CB205AFA8P-124, -0x2.940180D1AA2AEP-556)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x9.9488CB205AFA8P-124, -0x2.940180D1AA2AEP-556)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x3.F9D9FE5792CE0P-912, -0x3.F00FC8CE24ADCP-1016)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x3.F9D9FE5792CE0P-912, -0x3.F00FC8CE24ADCP-1016)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x7.D5A28EF80D6B0P-176, +0xC.5D2B8FFCB2AD8P-756)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x7.D5A28EF80D6B0P-176, +0xC.5D2B8FFCB2AD8P-756)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x5.B5DCAA821A628P-784, -0x1.48532232C10FDP-940)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x5.B5DCAA821A628P-784, -0x1.48532232C10FDP-940)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(0x3.8110D13AB0378P-720, 0x2.77422E18981C2P-44)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(0x3.8110D13AB0378P-720, 0x2.77422E18981C2P-44)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.4AD562C0B5178P-380, +0x3.CEB34F40EA9BAP-792)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.4AD562C0B5178P-380, +0x3.CEB34F40EA9BAP-792)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x7.ED02EF56E40B0P-92, -0x1.8C80275A696B0P-552)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x7.ED02EF56E40B0P-92, -0x1.8C80275A696B0P-552)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x1.56FBE834FC822P-296, -0x3.66041558BACA8P-516)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x1.56FBE834FC822P-296, -0x3.66041558BACA8P-516)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x6.44524F6FCCF8CP-340, -0x5.3E8ED576A1334P-896)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x6.44524F6FCCF8CP-340, -0x5.3E8ED576A1334P-896)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x8.92F5BEDA59C78P-268, +0x2.51B11C2EC76BAP-612)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x8.92F5BEDA59C78P-268, +0x2.51B11C2EC76BAP-612)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(cosh(interval(-0x4.785C46BDC2A50P-244, -0x1.BA5C062DE8F00P-432)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(cosh(bareinterval(-0x4.785C46BDC2A50P-244, -0x1.BA5C062DE8F00P-432)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(tanh(interval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), interval(0x1.7A77BFCCF5A9DP-232, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), bareinterval(0x1.7A77BFCCF5A9DP-232, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), interval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) + @test isequal_interval(tanh(bareinterval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), bareinterval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) - @test isequal_interval(tanh(interval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), interval(0xE.20FF41BD18050P-204, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), bareinterval(0xE.20FF41BD18050P-204, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), interval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) + @test isequal_interval(tanh(bareinterval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), bareinterval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) - @test isequal_interval(tanh(interval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), interval(0xD.772335E624B98P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), bareinterval(0xD.772335E624B98P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), interval(0x2.404E44C49C642P-440, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), bareinterval(0x2.404E44C49C642P-440, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), interval(0x1.63A15E999EB63P-344, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), bareinterval(0x1.63A15E999EB63P-344, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), interval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) + @test isequal_interval(tanh(bareinterval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), bareinterval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) - @test isequal_interval(tanh(interval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), interval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) + @test isequal_interval(tanh(bareinterval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), bareinterval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) - @test isequal_interval(tanh(interval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), interval(0x2.6ABC15579B2B0P-48, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), bareinterval(0x2.6ABC15579B2B0P-48, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x8.297A99ED9ED08P+8, 0xE.33C49CF5B8790P+652)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x3.436DFE8F08194P+48, 0x2.A69A969772FDEP+688)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), interval(0x6.3E590E6264518P-172, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), bareinterval(0x6.3E590E6264518P-172, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), interval(0x6.ACFA418D8F928P-544, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), bareinterval(0x6.ACFA418D8F928P-544, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), interval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) + @test isequal_interval(tanh(bareinterval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), bareinterval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) - @test isequal_interval(tanh(interval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), interval(0xC.41329461A0C28P-512, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), bareinterval(0xC.41329461A0C28P-512, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), interval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) + @test isequal_interval(tanh(bareinterval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), bareinterval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) - @test isequal_interval(tanh(interval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0xD.05E9CCF66CF58P+424, 0xB.A944253373080P+564)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), interval(0x6.65D7E0A247774P-56, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), bareinterval(0x6.65D7E0A247774P-56, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), interval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) + @test isequal_interval(tanh(bareinterval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), bareinterval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) - @test isequal_interval(tanh(interval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), interval(0x6.36B661DCE2684P-236, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), bareinterval(0x6.36B661DCE2684P-236, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), interval(0x1.EB0E1AB78F313P-480, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), bareinterval(0x1.EB0E1AB78F313P-480, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), interval(0x7.4CF193131FA60P-192, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), bareinterval(0x7.4CF193131FA60P-192, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), interval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) + @test isequal_interval(tanh(bareinterval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), bareinterval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) - @test isequal_interval(tanh(interval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), interval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), bareinterval(0xF.FFFFFFFFFFFF8P-4, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), interval(0x3.A0EE84451C92AP-324, 0x1.0000000000000P+0)) + @test isequal_interval(tanh(bareinterval(0x3.A0EE84451C92CP-324, 0xF.CC937FA330E40P+648)), bareinterval(0x3.A0EE84451C92AP-324, 0x1.0000000000000P+0)) - @test isequal_interval(tanh(interval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), interval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) + @test isequal_interval(tanh(bareinterval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), bareinterval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) - @test isequal_interval(coth(interval(0x5.9D7EEEA9B9EE0P-264, 0x3.F03D06503CAA2P+92)), interval(0x1.0000000000000P+0, 0x2.D97240157D2C8P+260)) + @test isequal_interval(coth(bareinterval(0x5.9D7EEEA9B9EE0P-264, 0x3.F03D06503CAA2P+92)), bareinterval(0x1.0000000000000P+0, 0x2.D97240157D2C8P+260)) - @test isequal_interval(coth(interval(-0x3.F03D06503CAA2P+92, -0x5.9D7EEEA9B9EE0P-264)), interval(-0x2.D97240157D2C8P+260, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x3.F03D06503CAA2P+92, -0x5.9D7EEEA9B9EE0P-264)), bareinterval(-0x2.D97240157D2C8P+260, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0xB.6600F238FE060P-520, 0x1.BB63631B595B0P-224)), interval(0x9.3CEA8A8C76FC0P+220, 0x1.6758D7D180F69P+516)) + @test isequal_interval(coth(bareinterval(0xB.6600F238FE060P-520, 0x1.BB63631B595B0P-224)), bareinterval(0x9.3CEA8A8C76FC0P+220, 0x1.6758D7D180F69P+516)) - @test isequal_interval(coth(interval(-0x1.BB63631B595B0P-224, -0xB.6600F238FE060P-520)), interval(-0x1.6758D7D180F69P+516, -0x9.3CEA8A8C76FC0P+220)) + @test isequal_interval(coth(bareinterval(-0x1.BB63631B595B0P-224, -0xB.6600F238FE060P-520)), bareinterval(-0x1.6758D7D180F69P+516, -0x9.3CEA8A8C76FC0P+220)) - @test isequal_interval(coth(interval(0x4.DC89ED0034C6CP-240, 0xD.A1D118A3891E8P+232)), interval(0x1.0000000000000P+0, 0x3.4A8AB6B06359AP+236)) + @test isequal_interval(coth(bareinterval(0x4.DC89ED0034C6CP-240, 0xD.A1D118A3891E8P+232)), bareinterval(0x1.0000000000000P+0, 0x3.4A8AB6B06359AP+236)) - @test isequal_interval(coth(interval(-0xD.A1D118A3891E8P+232, -0x4.DC89ED0034C6CP-240)), interval(-0x3.4A8AB6B06359AP+236, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0xD.A1D118A3891E8P+232, -0x4.DC89ED0034C6CP-240)), bareinterval(-0x3.4A8AB6B06359AP+236, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x4.7F93F879A61A4P-492, 0x1.BDC6388153882P-452)), interval(0x9.3041F45FA3D78P+448, 0x3.8E8E46D77A03EP+488)) + @test isequal_interval(coth(bareinterval(0x4.7F93F879A61A4P-492, 0x1.BDC6388153882P-452)), bareinterval(0x9.3041F45FA3D78P+448, 0x3.8E8E46D77A03EP+488)) - @test isequal_interval(coth(interval(-0x1.BDC6388153882P-452, -0x4.7F93F879A61A4P-492)), interval(-0x3.8E8E46D77A03EP+488, -0x9.3041F45FA3D78P+448)) + @test isequal_interval(coth(bareinterval(-0x1.BDC6388153882P-452, -0x4.7F93F879A61A4P-492)), bareinterval(-0x3.8E8E46D77A03EP+488, -0x9.3041F45FA3D78P+448)) - @test isequal_interval(coth(interval(0xF.C7C928D9BB718P+192, 0x8.41A7954605A98P+224)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(coth(bareinterval(0xF.C7C928D9BB718P+192, 0x8.41A7954605A98P+224)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(coth(interval(-0x8.41A7954605A98P+224, -0xF.C7C928D9BB718P+192)), interval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x8.41A7954605A98P+224, -0xF.C7C928D9BB718P+192)), bareinterval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x3.F07C0B8005270P-44, 0x2.DD3C8580FCBE0P+276)), interval(0x1.0000000000000P+0, 0x4.0FC1103283A70P+40)) + @test isequal_interval(coth(bareinterval(0x3.F07C0B8005270P-44, 0x2.DD3C8580FCBE0P+276)), bareinterval(0x1.0000000000000P+0, 0x4.0FC1103283A70P+40)) - @test isequal_interval(coth(interval(-0x2.DD3C8580FCBE0P+276, -0x3.F07C0B8005270P-44)), interval(-0x4.0FC1103283A70P+40, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x2.DD3C8580FCBE0P+276, -0x3.F07C0B8005270P-44)), bareinterval(-0x4.0FC1103283A70P+40, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0xA.A97DED29FFF30P-480, 0x5.35EEA9C504860P+196)), interval(0x1.0000000000000P+0, 0x1.802A4F4EFE3B2P+476)) + @test isequal_interval(coth(bareinterval(0xA.A97DED29FFF30P-480, 0x5.35EEA9C504860P+196)), bareinterval(0x1.0000000000000P+0, 0x1.802A4F4EFE3B2P+476)) - @test isequal_interval(coth(interval(-0x5.35EEA9C504860P+196, -0xA.A97DED29FFF30P-480)), interval(-0x1.802A4F4EFE3B2P+476, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x5.35EEA9C504860P+196, -0xA.A97DED29FFF30P-480)), bareinterval(-0x1.802A4F4EFE3B2P+476, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x3.CF4B727451402P-376, 0x1.759F6C21DAF9AP+140)), interval(0x1.0000000000000P+0, 0x4.33233873998C8P+372)) + @test isequal_interval(coth(bareinterval(0x3.CF4B727451402P-376, 0x1.759F6C21DAF9AP+140)), bareinterval(0x1.0000000000000P+0, 0x4.33233873998C8P+372)) - @test isequal_interval(coth(interval(-0x1.759F6C21DAF9AP+140, -0x3.CF4B727451402P-376)), interval(-0x4.33233873998C8P+372, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x1.759F6C21DAF9AP+140, -0x3.CF4B727451402P-376)), bareinterval(-0x4.33233873998C8P+372, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x6.55376F4C1C50CP-772, 0x1.0120DD4EBC019P-328)), interval(0xF.EE06735C6D910P+324, 0x2.86C88F09A2CBEP+768)) + @test isequal_interval(coth(bareinterval(0x6.55376F4C1C50CP-772, 0x1.0120DD4EBC019P-328)), bareinterval(0xF.EE06735C6D910P+324, 0x2.86C88F09A2CBEP+768)) - @test isequal_interval(coth(interval(-0x1.0120DD4EBC019P-328, -0x6.55376F4C1C50CP-772)), interval(-0x2.86C88F09A2CBEP+768, -0xF.EE06735C6D910P+324)) + @test isequal_interval(coth(bareinterval(-0x1.0120DD4EBC019P-328, -0x6.55376F4C1C50CP-772)), bareinterval(-0x2.86C88F09A2CBEP+768, -0xF.EE06735C6D910P+324)) - @test isequal_interval(coth(interval(0x1.B63F1F7AED49EP-580, 0x2.245AF5BCB3356P-132)), interval(0x7.7838528478BF8P+128, 0x9.58A984202B8E8P+576)) + @test isequal_interval(coth(bareinterval(0x1.B63F1F7AED49EP-580, 0x2.245AF5BCB3356P-132)), bareinterval(0x7.7838528478BF8P+128, 0x9.58A984202B8E8P+576)) - @test isequal_interval(coth(interval(-0x2.245AF5BCB3356P-132, -0x1.B63F1F7AED49EP-580)), interval(-0x9.58A984202B8E8P+576, -0x7.7838528478BF8P+128)) + @test isequal_interval(coth(bareinterval(-0x2.245AF5BCB3356P-132, -0x1.B63F1F7AED49EP-580)), bareinterval(-0x9.58A984202B8E8P+576, -0x7.7838528478BF8P+128)) - @test isequal_interval(coth(interval(0x2.73B23CC8D8F76P+116, 0x1.F1E4F59403FC3P+276)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(coth(bareinterval(0x2.73B23CC8D8F76P+116, 0x1.F1E4F59403FC3P+276)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(coth(interval(-0x1.F1E4F59403FC3P+276, -0x2.73B23CC8D8F76P+116)), interval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x1.F1E4F59403FC3P+276, -0x2.73B23CC8D8F76P+116)), bareinterval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x2.5B4F5F71CA5FCP-100, 0x1.5C244CE1AC6B3P+204)), interval(0x1.0000000000000P+0, 0x6.CA09D0DDC330CP+96)) + @test isequal_interval(coth(bareinterval(0x2.5B4F5F71CA5FCP-100, 0x1.5C244CE1AC6B3P+204)), bareinterval(0x1.0000000000000P+0, 0x6.CA09D0DDC330CP+96)) - @test isequal_interval(coth(interval(-0x1.5C244CE1AC6B3P+204, -0x2.5B4F5F71CA5FCP-100)), interval(-0x6.CA09D0DDC330CP+96, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x1.5C244CE1AC6B3P+204, -0x2.5B4F5F71CA5FCP-100)), bareinterval(-0x6.CA09D0DDC330CP+96, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x1.4E7212DD5ABB9P+4, 0xD.9F35E61FDF7E8P+592)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(coth(bareinterval(0x1.4E7212DD5ABB9P+4, 0xD.9F35E61FDF7E8P+592)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(coth(interval(-0xD.9F35E61FDF7E8P+592, -0x1.4E7212DD5ABB9P+4)), interval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0xD.9F35E61FDF7E8P+592, -0x1.4E7212DD5ABB9P+4)), bareinterval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x1.271B33491E515P+20, 0x2.B3031CF3AF4ECP+628)), interval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) + @test isequal_interval(coth(bareinterval(0x1.271B33491E515P+20, 0x2.B3031CF3AF4ECP+628)), bareinterval(0x1.0000000000000P+0, 0x1.0000000000001P+0)) - @test isequal_interval(coth(interval(-0x2.B3031CF3AF4ECP+628, -0x1.271B33491E515P+20)), interval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) + @test isequal_interval(coth(bareinterval(-0x2.B3031CF3AF4ECP+628, -0x1.271B33491E515P+20)), bareinterval(-0x1.0000000000001P+0, -0x1.0000000000000P+0)) - @test isequal_interval(coth(interval(0x9.DB635E2FF52B0P-180, 0x2.AF04176524D06P-24)), interval(0x5.F646A7779F114P+20, 0x1.9F8AFAA8DBFF9P+176)) + @test isequal_interval(coth(bareinterval(0x9.DB635E2FF52B0P-180, 0x2.AF04176524D06P-24)), bareinterval(0x5.F646A7779F114P+20, 0x1.9F8AFAA8DBFF9P+176)) - @test isequal_interval(coth(interval(-0x2.AF04176524D06P-24, -0x9.DB635E2FF52B0P-180)), interval(-0x1.9F8AFAA8DBFF9P+176, -0x5.F646A7779F114P+20)) + @test isequal_interval(coth(bareinterval(-0x2.AF04176524D06P-24, -0x9.DB635E2FF52B0P-180)), bareinterval(-0x1.9F8AFAA8DBFF9P+176, -0x5.F646A7779F114P+20)) - @test isequal_interval(asinh(interval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), interval(0x1.7A77BFCCF5A9DP-232, 0x4.F3FA9CD060658P+4)) + @test isequal_interval(asinh(bareinterval(0x1.7A77BFCCF5A9EP-232, 0x2.8457BC029986EP+112)), bareinterval(0x1.7A77BFCCF5A9DP-232, 0x4.F3FA9CD060658P+4)) - @test isequal_interval(asinh(interval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), interval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) + @test isequal_interval(asinh(bareinterval(0x3.C5EC30FBB68C8P-508, 0x6.05C0BB1BCB730P-220)), bareinterval(0x3.C5EC30FBB68C6P-508, 0x6.05C0BB1BCB730P-220)) - @test isequal_interval(asinh(interval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), interval(0xE.20FF41BD18050P-204, 0xB.E2FD554E373E0P+4)) + @test isequal_interval(asinh(bareinterval(0xE.20FF41BD18058P-204, 0x2.9B09919BF9D9EP+272)), bareinterval(0xE.20FF41BD18050P-204, 0xB.E2FD554E373E0P+4)) - @test isequal_interval(asinh(interval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), interval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) + @test isequal_interval(asinh(bareinterval(0x2.075DF98B2478CP-456, 0x1.1503444763FC5P-416)), bareinterval(0x2.075DF98B2478AP-456, 0x1.1503444763FC5P-416)) - @test isequal_interval(asinh(interval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), interval(0xA.FA69A93525138P+4, 0xC.C008F1DBA8390P+4)) + @test isequal_interval(asinh(bareinterval(0x1.5444E676976F1P+252, 0x2.7C064F6929234P+292)), bareinterval(0xA.FA69A93525138P+4, 0xC.C008F1DBA8390P+4)) - @test isequal_interval(asinh(interval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), interval(0x1.086AFFAE230B6P+0, 0xE.8698B81E22AB0P+4)) + @test isequal_interval(asinh(bareinterval(0x1.3A01905E36F84P+0, 0x4.ECBC855871080P+332)), bareinterval(0x1.086AFFAE230B6P+0, 0xE.8698B81E22AB0P+4)) - @test isequal_interval(asinh(interval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), interval(0x2.404E44C49C642P-440, 0xA.63FF3E7D6B730P+4)) + @test isequal_interval(asinh(bareinterval(0x2.404E44C49C644P-440, 0x7.32EDAB7F60A50P+236)), bareinterval(0x2.404E44C49C642P-440, 0xA.63FF3E7D6B730P+4)) - @test isequal_interval(asinh(interval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), interval(0x1.63A15E999EB63P-344, 0x7.9C22B35B1CEE0P+4)) + @test isequal_interval(asinh(bareinterval(0x1.63A15E999EB64P-344, 0x6.5263CF84EF388P+172)), bareinterval(0x1.63A15E999EB63P-344, 0x7.9C22B35B1CEE0P+4)) - @test isequal_interval(asinh(interval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), interval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) + @test isequal_interval(asinh(bareinterval(0x6.941F470A70074P-756, 0x1.4171976A1CA54P-288)), bareinterval(0x6.941F470A70070P-756, 0x1.4171976A1CA54P-288)) - @test isequal_interval(asinh(interval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), interval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) + @test isequal_interval(asinh(bareinterval(0x7.78A1F475A306CP-564, 0x4.69BB1D34B9570P-76)), bareinterval(0x7.78A1F475A3068P-564, 0x4.69BB1D34B9570P-76)) - @test isequal_interval(asinh(interval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), interval(0x7.E017D1421AED4P+4, 0xD.99E3CCF428D70P+4)) + @test isequal_interval(asinh(bareinterval(0x1.BA04D452BBB35P+180, 0x1.F0D19ADCB5D74P+312)), bareinterval(0x7.E017D1421AED4P+4, 0xD.99E3CCF428D70P+4)) - @test isequal_interval(asinh(interval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), interval(0x2.6ABC15579B2B0P-48, 0xB.331FC2BC20E70P+4)) + @test isequal_interval(asinh(bareinterval(0x2.6ABC15579B2B2P-48, 0x2.E046DB554037CP+256)), bareinterval(0x2.6ABC15579B2B0P-48, 0xB.331FC2BC20E70P+4)) - @test isequal_interval(asinh(interval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), interval(0x6.3E590E6264518P-172, 0x6.A13A85E654788P+0)) + @test isequal_interval(asinh(bareinterval(0x6.3E590E626451CP-172, 0x1.7AAA15EBBD3F2P+8)), bareinterval(0x6.3E590E6264518P-172, 0x6.A13A85E654788P+0)) - @test isequal_interval(asinh(interval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), interval(0x6.ACFA418D8F928P-544, 0x2.AE767FF2330E0P+8)) + @test isequal_interval(asinh(bareinterval(0x6.ACFA418D8F92CP-544, 0x2.8F9204BC4041EP+988)), bareinterval(0x6.ACFA418D8F928P-544, 0x2.AE767FF2330E0P+8)) - @test isequal_interval(asinh(interval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), interval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) + @test isequal_interval(asinh(bareinterval(0x2.BB570B356C6CAP-440, 0x2.B00450A48D586P-148)), bareinterval(0x2.BB570B356C6C8P-440, 0x2.B00450A48D586P-148)) - @test isequal_interval(asinh(interval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), interval(0xC.41329461A0C28P-512, 0xF.529AF3B8107E0P+4)) + @test isequal_interval(asinh(bareinterval(0xC.41329461A0C30P-512, 0x1.9E7DDBBE00F75P+352)), bareinterval(0xC.41329461A0C28P-512, 0xF.529AF3B8107E0P+4)) - @test isequal_interval(asinh(interval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), interval(0x8.4DCECB852E1E8P+4, 0xA.6DE648AA01A20P+4)) + @test isequal_interval(asinh(bareinterval(0x6.6978492A3064CP+188, 0xD.5E2045CEE9720P+236)), bareinterval(0x8.4DCECB852E1E8P+4, 0xA.6DE648AA01A20P+4)) - @test isequal_interval(asinh(interval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), interval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) + @test isequal_interval(asinh(bareinterval(0x7.DEA605DEC97CCP-316, 0x1.5BD629B25AA23P-236)), bareinterval(0x7.DEA605DEC97C8P-316, 0x1.5BD629B25AA23P-236)) - @test isequal_interval(asinh(interval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), interval(0x6.65D7E0A247774P-56, 0x7.671E008768830P+4)) + @test isequal_interval(asinh(bareinterval(0x6.65D7E0A247778P-56, 0x3.AE1DC13A652CAP+168)), bareinterval(0x6.65D7E0A247774P-56, 0x7.671E008768830P+4)) - @test isequal_interval(asinh(interval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), interval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) + @test isequal_interval(asinh(bareinterval(0x5.2B55801231EC8P-344, 0xA.27B4555158148P-68)), bareinterval(0x5.2B55801231EC4P-344, 0xA.27B4555158148P-68)) - @test isequal_interval(asinh(interval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), interval(0x6.36B661DCE2684P-236, 0x9.9E9F4F5A56088P+0)) + @test isequal_interval(asinh(bareinterval(0x6.36B661DCE2688P-236, 0x1.D68A6BA7E617FP+12)), bareinterval(0x6.36B661DCE2684P-236, 0x9.9E9F4F5A56088P+0)) - @test isequal_interval(asinh(interval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), interval(0x1.EB0E1AB78F313P-480, 0x5.CA82DEDB3D320P+4)) + @test isequal_interval(asinh(bareinterval(0x1.EB0E1AB78F314P-480, 0x1.98EF0C6A8BD66P+132)), bareinterval(0x1.EB0E1AB78F313P-480, 0x5.CA82DEDB3D320P+4)) - @test isequal_interval(asinh(interval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), interval(0x7.4CF193131FA60P-192, 0x9.9BF0B87669850P+4)) + @test isequal_interval(asinh(bareinterval(0x7.4CF193131FA64P-192, 0x1.C08152CC09416P+220)), bareinterval(0x7.4CF193131FA60P-192, 0x9.9BF0B87669850P+4)) - @test isequal_interval(asinh(interval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), interval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) + @test isequal_interval(asinh(bareinterval(0x1.7036C237D5B00P-672, 0x6.F70E0DA4D2BA0P-140)), bareinterval(0x1.7036C237D5AFFP-672, 0x6.F70E0DA4D2BA0P-140)) - @test isequal_interval(asinh(interval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), interval(0xA.FF762A8B30EA0P+4, 0xE.3AF0836B2F5B0P+4)) + @test isequal_interval(asinh(bareinterval(0x1.D283CF8F05665P+252, 0xB.24D19E00C8460P+324)), bareinterval(0xA.FF762A8B30EA0P+4, 0xE.3AF0836B2F5B0P+4)) - @test isequal_interval(asinh(interval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), interval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) + @test isequal_interval(asinh(bareinterval(0x1.8BCA641025A83P-124, 0x5.F775993940188P-120)), bareinterval(0x1.8BCA641025A82P-124, 0x5.F775993940188P-120)) - @test isequal_interval(acosh(interval(0x5.AD89AD14DDC74P+272, 0x2.6EC5D31670A5EP+860)), interval(0xB.EF73BF42C19D8P+4, 0x2.55B05064B6C2AP+8)) + @test isequal_interval(acosh(bareinterval(0x5.AD89AD14DDC74P+272, 0x2.6EC5D31670A5EP+860)), bareinterval(0xB.EF73BF42C19D8P+4, 0x2.55B05064B6C2AP+8)) - @test isequal_interval(acosh(interval(0x4.A457C35864940P+344, 0x2.3ADEFB54BC048P+444)), interval(0xF.0ABC113DB1AF0P+4, 0x1.3540A29BC6B5EP+8)) + @test isequal_interval(acosh(bareinterval(0x4.A457C35864940P+344, 0x2.3ADEFB54BC048P+444)), bareinterval(0xF.0ABC113DB1AF0P+4, 0x1.3540A29BC6B5EP+8)) - @test isequal_interval(acosh(interval(0x6.941C8B9506D90P+56, 0x3.B11D8083AE958P+744)), interval(0x2.964A9197BF832P+4, 0x2.05B3663FAE652P+8)) + @test isequal_interval(acosh(bareinterval(0x6.941C8B9506D90P+56, 0x3.B11D8083AE958P+744)), bareinterval(0x2.964A9197BF832P+4, 0x2.05B3663FAE652P+8)) - @test isequal_interval(acosh(interval(0x1.09A940A083EE3P+132, 0x1.047FD514ADF08P+384)), interval(0x5.C39C22D7AA908P+4, 0x1.0AE10BDF7FE81P+8)) + @test isequal_interval(acosh(bareinterval(0x1.09A940A083EE3P+132, 0x1.047FD514ADF08P+384)), bareinterval(0x5.C39C22D7AA908P+4, 0x1.0AE10BDF7FE81P+8)) - @test isequal_interval(acosh(interval(0x7.710740B71A0D4P+256, 0xF.C0798D156BFA0P+560)), interval(0xB.42559B5CF34E8P+4, 0x1.879CCE87EE3A1P+8)) + @test isequal_interval(acosh(bareinterval(0x7.710740B71A0D4P+256, 0xF.C0798D156BFA0P+560)), bareinterval(0xB.42559B5CF34E8P+4, 0x1.879CCE87EE3A1P+8)) - @test isequal_interval(acosh(interval(0x2.3721A01F70456P+564, 0x9.C62BBF31FD290P+728)), interval(0x1.886C6F1DDDFF7P+8, 0x1.FB958311209BFP+8)) + @test isequal_interval(acosh(bareinterval(0x2.3721A01F70456P+564, 0x9.C62BBF31FD290P+728)), bareinterval(0x1.886C6F1DDDFF7P+8, 0x1.FB958311209BFP+8)) - @test isequal_interval(acosh(interval(0x6.F06D452BDCEF0P+44, 0x2.4825931366BBCP+520)), interval(0x2.120F95BD1F706P+4, 0x1.69F464545899AP+8)) + @test isequal_interval(acosh(bareinterval(0x6.F06D452BDCEF0P+44, 0x2.4825931366BBCP+520)), bareinterval(0x2.120F95BD1F706P+4, 0x1.69F464545899AP+8)) - @test isequal_interval(acosh(interval(0x5.D326D4B0883D8P+76, 0x1.77175C5A113ADP+528)), interval(0x3.7226BF0157930P+4, 0x1.6F0E8DBF98710P+8)) + @test isequal_interval(acosh(bareinterval(0x5.D326D4B0883D8P+76, 0x1.77175C5A113ADP+528)), bareinterval(0x3.7226BF0157930P+4, 0x1.6F0E8DBF98710P+8)) - @test isequal_interval(acosh(interval(0x1.05ADFE119D4C2P+296, 0x2.6BCDF50E05E34P+1020)), interval(0xC.DE2FBE78FEC28P+4, 0x2.C49666459E1A4P+8)) + @test isequal_interval(acosh(bareinterval(0x1.05ADFE119D4C2P+296, 0x2.6BCDF50E05E34P+1020)), bareinterval(0xC.DE2FBE78FEC28P+4, 0x2.C49666459E1A4P+8)) - @test isequal_interval(acosh(interval(0xA.7F5D255B81268P+408, 0x1.9D1EDDC132B36P+864)), interval(0x1.1DD92C82827A1P+8, 0x2.580D06072BF20P+8)) + @test isequal_interval(acosh(bareinterval(0xA.7F5D255B81268P+408, 0x1.9D1EDDC132B36P+864)), bareinterval(0x1.1DD92C82827A1P+8, 0x2.580D06072BF20P+8)) - @test isequal_interval(acosh(interval(0xC.FBE4E2C6D0A80P+484, 0x4.DF75BDC17C330P+868)), interval(0x1.52BD770642386P+8, 0x2.5BEDB7E376E18P+8)) + @test isequal_interval(acosh(bareinterval(0xC.FBE4E2C6D0A80P+484, 0x4.DF75BDC17C330P+868)), bareinterval(0x1.52BD770642386P+8, 0x2.5BEDB7E376E18P+8)) - @test isequal_interval(acosh(interval(0xB.241032F9700A0P+380, 0x1.04A65B06B2920P+640)), interval(0x1.0A7FEC190CCEEP+8, 0x1.BC5349B021815P+8)) + @test isequal_interval(acosh(bareinterval(0xB.241032F9700A0P+380, 0x1.04A65B06B2920P+640)), bareinterval(0x1.0A7FEC190CCEEP+8, 0x1.BC5349B021815P+8)) - @test isequal_interval(acosh(interval(0x5.F207EAF5F8BB4P+608, 0xA.BC87C6F90AEE0P+648)), interval(0x1.A7E8C5069EA32P+8, 0x1.C439E5E8A511CP+8)) + @test isequal_interval(acosh(bareinterval(0x5.F207EAF5F8BB4P+608, 0xA.BC87C6F90AEE0P+648)), bareinterval(0x1.A7E8C5069EA32P+8, 0x1.C439E5E8A511CP+8)) - @test isequal_interval(acosh(interval(0x1.BCD62C46ADFD7P+16, 0xA.CD289B35ECD00P+564)), interval(0xC.56062C0C41518P+0, 0x1.8A0201556D85AP+8)) + @test isequal_interval(acosh(bareinterval(0x1.BCD62C46ADFD7P+16, 0xA.CD289B35ECD00P+564)), bareinterval(0xC.56062C0C41518P+0, 0x1.8A0201556D85AP+8)) - @test isequal_interval(acosh(interval(0x6.534BBA40A0B44P+224, 0x1.8DE35856E91FBP+452)), interval(0x9.DCD7CC0C7FFB8P+4, 0x1.3A6FC95911674P+8)) + @test isequal_interval(acosh(bareinterval(0x6.534BBA40A0B44P+224, 0x1.8DE35856E91FBP+452)), bareinterval(0x9.DCD7CC0C7FFB8P+4, 0x1.3A6FC95911674P+8)) - @test isequal_interval(acosh(interval(0x2.C4F59012F4E48P+508, 0x1.1854765A9A205P+688)), interval(0x1.61D49DF92AB79P+8, 0x1.DDAB5081E5A0EP+8)) + @test isequal_interval(acosh(bareinterval(0x2.C4F59012F4E48P+508, 0x1.1854765A9A205P+688)), bareinterval(0x1.61D49DF92AB79P+8, 0x1.DDAB5081E5A0EP+8)) - @test isequal_interval(acosh(interval(0x8.6F890522C18B0P+44, 0x3.F87592D71E06CP+220)), interval(0x2.152F7D2DBF2BCP+4, 0x9.A907E7C701690P+4)) + @test isequal_interval(acosh(bareinterval(0x8.6F890522C18B0P+44, 0x3.F87592D71E06CP+220)), bareinterval(0x2.152F7D2DBF2BCP+4, 0x9.A907E7C701690P+4)) - @test isequal_interval(acosh(interval(0x9.2A9035A578970P+124, 0x1.35EE42DCA8B75P+608)), interval(0x5.8DBE2A7E96990P+4, 0x1.A6515B9ECF2F1P+8)) + @test isequal_interval(acosh(bareinterval(0x9.2A9035A578970P+124, 0x1.35EE42DCA8B75P+608)), bareinterval(0x5.8DBE2A7E96990P+4, 0x1.A6515B9ECF2F1P+8)) - @test isequal_interval(acosh(interval(0x5.2641115F86D38P+204, 0x7.BE33D080E6584P+252)), interval(0x8.FBBEB3B84C708P+4, 0xB.169BBE1313F68P+4)) + @test isequal_interval(acosh(bareinterval(0x5.2641115F86D38P+204, 0x7.BE33D080E6584P+252)), bareinterval(0x8.FBBEB3B84C708P+4, 0xB.169BBE1313F68P+4)) - @test isequal_interval(acosh(interval(0xA.8746F72A1BD90P+72, 0x5.6ABE29A315520P+872)), interval(0x3.4F42DBFC0E4B4P+4, 0x2.5ECE9922C7894P+8)) + @test isequal_interval(acosh(bareinterval(0xA.8746F72A1BD90P+72, 0x5.6ABE29A315520P+872)), bareinterval(0x3.4F42DBFC0E4B4P+4, 0x2.5ECE9922C7894P+8)) - @test isequal_interval(acosh(interval(0xB.D0973FF704000P+224, 0x2.2FD9ABBD09D34P+976)), interval(0x9.E6D6EA0633070P+4, 0x2.A5FCBEDD15F2CP+8)) + @test isequal_interval(acosh(bareinterval(0xB.D0973FF704000P+224, 0x2.2FD9ABBD09D34P+976)), bareinterval(0x9.E6D6EA0633070P+4, 0x2.A5FCBEDD15F2CP+8)) - @test isequal_interval(acosh(interval(0xA.C15D51DB7D9F0P+536, 0x1.7207A70831D7AP+796)), interval(0x1.76986E964982DP+8, 0x2.28CE847F69DCAP+8)) + @test isequal_interval(acosh(bareinterval(0xA.C15D51DB7D9F0P+536, 0x1.7207A70831D7AP+796)), bareinterval(0x1.76986E964982DP+8, 0x2.28CE847F69DCAP+8)) - @test isequal_interval(acosh(interval(0x4.280BEC7911E7CP+180, 0x6.B4F11E86ECA38P+792)), interval(0x7.EE261446DD5F8P+4, 0x2.27919F48F2C20P+8)) + @test isequal_interval(acosh(bareinterval(0x4.280BEC7911E7CP+180, 0x6.B4F11E86ECA38P+792)), bareinterval(0x7.EE261446DD5F8P+4, 0x2.27919F48F2C20P+8)) - @test isequal_interval(acosh(interval(0x3.4B22674960B0EP+468, 0xA.505A061DF4CD8P+808)), interval(0x1.4647297977E4EP+8, 0x2.3316ED57009D4P+8)) + @test isequal_interval(acosh(bareinterval(0x3.4B22674960B0EP+468, 0xA.505A061DF4CD8P+808)), bareinterval(0x1.4647297977E4EP+8, 0x2.3316ED57009D4P+8)) - @test isequal_interval(acosh(interval(0x2.383FC27D5E4E4P+756, 0x5.88E9C96565E54P+920)), interval(0x2.0D82822002358P+8, 0x2.801980299550CP+8)) + @test isequal_interval(acosh(bareinterval(0x2.383FC27D5E4E4P+756, 0x5.88E9C96565E54P+920)), bareinterval(0x2.0D82822002358P+8, 0x2.801980299550CP+8)) - @test isequal_interval(acosh(interval(0x1.20E762C8AAB55P+72, 0x1.DBB7B8FE35847P+960)), interval(0x3.2B87D37C9EAFAP+4, 0x2.9ABBED2A77E62P+8)) + @test isequal_interval(acosh(bareinterval(0x1.20E762C8AAB55P+72, 0x1.DBB7B8FE35847P+960)), bareinterval(0x3.2B87D37C9EAFAP+4, 0x2.9ABBED2A77E62P+8)) - @test isequal_interval(acosh(interval(0x1.1265074E9E3DFP+792, 0x2.229B285A709C0P+920)), interval(0x2.25BC2FC876EBCP+8, 0x2.7F25A89FE16E6P+8)) + @test isequal_interval(acosh(bareinterval(0x1.1265074E9E3DFP+792, 0x2.229B285A709C0P+920)), bareinterval(0x2.25BC2FC876EBCP+8, 0x2.7F25A89FE16E6P+8)) - @test isequal_interval(acosh(interval(0x1.054DCDEF21349P+436, 0x1.618994D07D9A7P+636)), interval(0x1.2EED02D819A15P+8, 0x1.B9DB8970CC5ECP+8)) + @test isequal_interval(acosh(bareinterval(0x1.054DCDEF21349P+436, 0x1.618994D07D9A7P+636)), bareinterval(0x1.2EED02D819A15P+8, 0x1.B9DB8970CC5ECP+8)) - @test isequal_interval(acosh(interval(0x4.5BE0D9A7FF0CCP+460, 0x2.6F2C55F16354AP+568)), interval(0x1.4103588C86AB6P+8, 0x1.8B4A572E180D4P+8)) + @test isequal_interval(acosh(bareinterval(0x4.5BE0D9A7FF0CCP+460, 0x2.6F2C55F16354AP+568)), bareinterval(0x1.4103588C86AB6P+8, 0x1.8B4A572E180D4P+8)) - @test isequal_interval(acosh(interval(0x9.BD8B9A7FB6630P+80, 0x2.AD5F8458C8722P+768)), interval(0x3.A6BD416FCCF70P+4, 0x2.1603D4EDCB36AP+8)) + @test isequal_interval(acosh(bareinterval(0x9.BD8B9A7FB6630P+80, 0x2.AD5F8458C8722P+768)), bareinterval(0x3.A6BD416FCCF70P+4, 0x2.1603D4EDCB36AP+8)) - @test isequal_interval(atanh(interval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), interval(-0x3.11A309475E764P-164, -0xC.3784302E15500P-680)) + @test isequal_interval(atanh(bareinterval(-0x3.11A309475E762P-164, -0xC.3784302E15500P-680)), bareinterval(-0x3.11A309475E764P-164, -0xC.3784302E15500P-680)) - @test isequal_interval(atanh(interval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), interval(-0x5.7DD17A4248D3CP-280, -0x2.898FC0F386F74P-640)) + @test isequal_interval(atanh(bareinterval(-0x5.7DD17A4248D38P-280, -0x2.898FC0F386F74P-640)), bareinterval(-0x5.7DD17A4248D3CP-280, -0x2.898FC0F386F74P-640)) - @test isequal_interval(atanh(interval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), interval(-0xE.D83DCD7F564A8P-296, -0x1.62F61FBA0F40FP-764)) + @test isequal_interval(atanh(bareinterval(-0xE.D83DCD7F564A0P-296, -0x1.62F61FBA0F40FP-764)), bareinterval(-0xE.D83DCD7F564A8P-296, -0x1.62F61FBA0F40FP-764)) - @test isequal_interval(atanh(interval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), interval(-0x1.67712A1E64C2DP-944, -0x1.C0102C4D258EFP-976)) + @test isequal_interval(atanh(bareinterval(-0x1.67712A1E64C2CP-944, -0x1.C0102C4D258EFP-976)), bareinterval(-0x1.67712A1E64C2DP-944, -0x1.C0102C4D258EFP-976)) - @test isequal_interval(atanh(interval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), interval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4BP-612)) + @test isequal_interval(atanh(bareinterval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4AP-612)), bareinterval(0x2.E3D991AE84668P-728, 0x1.92C3C728CCF4BP-612)) - @test isequal_interval(atanh(interval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), interval(-0x1.BCD3FEB3B0176P-640, +0x1.BEBE69E3BF3C3P-536)) + @test isequal_interval(atanh(bareinterval(-0x1.BCD3FEB3B0175P-640, +0x1.BEBE69E3BF3C2P-536)), bareinterval(-0x1.BCD3FEB3B0176P-640, +0x1.BEBE69E3BF3C3P-536)) - @test isequal_interval(atanh(interval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), interval(-0x1.2469575189328P-372, -0x7.51C0C39F58A4CP-1008)) + @test isequal_interval(atanh(bareinterval(-0x1.2469575189327P-372, -0x7.51C0C39F58A4CP-1008)), bareinterval(-0x1.2469575189328P-372, -0x7.51C0C39F58A4CP-1008)) - @test isequal_interval(atanh(interval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), interval(-0x1.C4D163A6CCCDAP-336, -0x1.3BEE6DAB70397P-796)) + @test isequal_interval(atanh(bareinterval(-0x1.C4D163A6CCCD9P-336, -0x1.3BEE6DAB70397P-796)), bareinterval(-0x1.C4D163A6CCCDAP-336, -0x1.3BEE6DAB70397P-796)) - @test isequal_interval(atanh(interval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), interval(-0x2.0FAE5DE90C98EP-896, -0x2.2079777EC2418P-976)) + @test isequal_interval(atanh(bareinterval(-0x2.0FAE5DE90C98CP-896, -0x2.2079777EC2418P-976)), bareinterval(-0x2.0FAE5DE90C98EP-896, -0x2.2079777EC2418P-976)) - @test isequal_interval(atanh(interval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), interval(-0x1.08C248C37E53CP-816, +0x2.8C9F04EE5DE86P-948)) + @test isequal_interval(atanh(bareinterval(-0x1.08C248C37E53BP-816, +0x2.8C9F04EE5DE84P-948)), bareinterval(-0x1.08C248C37E53CP-816, +0x2.8C9F04EE5DE86P-948)) - @test isequal_interval(atanh(interval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), interval(-0x2.0002542B01476P-228, +0x2.4D59F217BF74EP-796)) + @test isequal_interval(atanh(bareinterval(-0x2.0002542B01474P-228, +0x2.4D59F217BF74CP-796)), bareinterval(-0x2.0002542B01476P-228, +0x2.4D59F217BF74EP-796)) - @test isequal_interval(atanh(interval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), interval(0xD.D4033889729A0P-844, 0x7.44451BF919D7CP-556)) + @test isequal_interval(atanh(bareinterval(0xD.D4033889729A0P-844, 0x7.44451BF919D78P-556)), bareinterval(0xD.D4033889729A0P-844, 0x7.44451BF919D7CP-556)) - @test isequal_interval(atanh(interval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), interval(-0x2.08918B016995EP-64, +0x3.3FC26450C6E4CP-268)) + @test isequal_interval(atanh(bareinterval(-0x2.08918B016995CP-64, +0x3.3FC26450C6E4AP-268)), bareinterval(-0x2.08918B016995EP-64, +0x3.3FC26450C6E4CP-268)) - @test isequal_interval(atanh(interval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), interval(-0x2.66C95BD8D7718P-388, +0x1.7E16B310F878BP-232)) + @test isequal_interval(atanh(bareinterval(-0x2.66C95BD8D7716P-388, +0x1.7E16B310F878AP-232)), bareinterval(-0x2.66C95BD8D7718P-388, +0x1.7E16B310F878BP-232)) - @test isequal_interval(atanh(interval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), interval(-0x3.D9C66BD30B776P-256, -0x4.A8C30F678CB68P-456)) + @test isequal_interval(atanh(bareinterval(-0x3.D9C66BD30B774P-256, -0x4.A8C30F678CB68P-456)), bareinterval(-0x3.D9C66BD30B776P-256, -0x4.A8C30F678CB68P-456)) - @test isequal_interval(atanh(interval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), interval(-0x1.AA045CCB15AEEP-804, +0xD.450C4732686C0P-24)) + @test isequal_interval(atanh(bareinterval(-0x1.AA045CCB15AEDP-804, +0xD.450C473265610P-24)), bareinterval(-0x1.AA045CCB15AEEP-804, +0xD.450C4732686C0P-24)) - @test isequal_interval(atanh(interval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), interval(-0x2.23ADFA571FC3EP-344, -0x1.30D1074DC059EP-868)) + @test isequal_interval(atanh(bareinterval(-0x2.23ADFA571FC3CP-344, -0x1.30D1074DC059EP-868)), bareinterval(-0x2.23ADFA571FC3EP-344, -0x1.30D1074DC059EP-868)) - @test isequal_interval(atanh(interval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), interval(-0x3.DFBC1A4BF388AP-68, -0x4.A89E39B247C84P-840)) + @test isequal_interval(atanh(bareinterval(-0x3.DFBC1A4BF3888P-68, -0x4.A89E39B247C84P-840)), bareinterval(-0x3.DFBC1A4BF388AP-68, -0x4.A89E39B247C84P-840)) - @test isequal_interval(atanh(interval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), interval(0x9.583064525D370P-496, 0x2.C67652F06A560P-408)) + @test isequal_interval(atanh(bareinterval(0x9.583064525D370P-496, 0x2.C67652F06A55EP-408)), bareinterval(0x9.583064525D370P-496, 0x2.C67652F06A560P-408)) - @test isequal_interval(atanh(interval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), interval(-0x3.38BF880EC3084P-304, -0x7.7B19877E536ACP-512)) + @test isequal_interval(atanh(bareinterval(-0x3.38BF880EC3082P-304, -0x7.7B19877E536ACP-512)), bareinterval(-0x3.38BF880EC3084P-304, -0x7.7B19877E536ACP-512)) - @test isequal_interval(atanh(interval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), interval(-0x2.ADBF037238704P-44, +0x1.98DC940C3AE1FP-564)) + @test isequal_interval(atanh(bareinterval(-0x2.ADBF037238702P-44, +0x1.98DC940C3AE1EP-564)), bareinterval(-0x2.ADBF037238704P-44, +0x1.98DC940C3AE1FP-564)) - @test isequal_interval(atanh(interval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), interval(-0x4.E4A79C48B3A5CP-328, +0xA.28B02E59D39E0P-856)) + @test isequal_interval(atanh(bareinterval(-0x4.E4A79C48B3A58P-328, +0xA.28B02E59D39D8P-856)), bareinterval(-0x4.E4A79C48B3A5CP-328, +0xA.28B02E59D39E0P-856)) - @test isequal_interval(atanh(interval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), interval(-0x6.80D3E87B911DCP-232, -0x2.3DF54212C46E4P-520)) + @test isequal_interval(atanh(bareinterval(-0x6.80D3E87B911D8P-232, -0x2.3DF54212C46E4P-520)), bareinterval(-0x6.80D3E87B911DCP-232, -0x2.3DF54212C46E4P-520)) - @test isequal_interval(atanh(interval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), interval(-0x1.4E54C309C46F9P-480, +0x9.47E982AC83FA0P-688)) + @test isequal_interval(atanh(bareinterval(-0x1.4E54C309C46F8P-480, +0x9.47E982AC83F98P-688)), bareinterval(-0x1.4E54C309C46F9P-480, +0x9.47E982AC83FA0P-688)) - @test isequal_interval(atanh(interval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), interval(-0x2.276202227A6E0P-808, +0x1.C53E9BA64FAE0P-768)) + @test isequal_interval(atanh(bareinterval(-0x2.276202227A6DEP-808, +0x1.C53E9BA64FADFP-768)), bareinterval(-0x2.276202227A6E0P-808, +0x1.C53E9BA64FAE0P-768)) - @test isequal_interval(atanh(interval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), interval(-0x4.8E4B4D7BA6DD4P-212, -0x1.4B35284C1064BP-548)) + @test isequal_interval(atanh(bareinterval(-0x4.8E4B4D7BA6DD0P-212, -0x1.4B35284C1064BP-548)), bareinterval(-0x4.8E4B4D7BA6DD4P-212, -0x1.4B35284C1064BP-548)) - @test isequal_interval(atanh(interval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), interval(-0x3.5C52B8D9FF584P-248, -0x2.AF868D652B866P-912)) + @test isequal_interval(atanh(bareinterval(-0x3.5C52B8D9FF582P-248, -0x2.AF868D652B866P-912)), bareinterval(-0x3.5C52B8D9FF584P-248, -0x2.AF868D652B866P-912)) - @test isequal_interval(atanh(interval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), interval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38170P-664)) + @test isequal_interval(atanh(bareinterval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38168P-664)), bareinterval(0x1.6938CC5EE183AP-692, 0xB.F7A583AC38170P-664)) - @test isequal_interval(atanh(interval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), interval(-0x3.68B35F23B2508P-560, +0x9.F9C9246D05140P-304)) + @test isequal_interval(atanh(bareinterval(-0x3.68B35F23B2506P-560, +0x9.F9C9246D05138P-304)), bareinterval(-0x3.68B35F23B2508P-560, +0x9.F9C9246D05140P-304)) - @test isequal_interval(atanh(interval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), interval(-0xA.BDE70B6850EA8P-516, +0x2.BB76D5BF703FCP-1020)) + @test isequal_interval(atanh(bareinterval(-0xA.BDE70B6850EA0P-516, +0x2.BB76D5BF703FAP-1020)), bareinterval(-0xA.BDE70B6850EA8P-516, +0x2.BB76D5BF703FCP-1020)) - @test isequal_interval(acoth(interval(0x5.AD89AD14DDC78P+272, 0x2.6EC5D31670A60P+860)), interval(0x6.93B8C1A4ADA4CP-864, 0x2.D165505974CDCP-276)) + @test isequal_interval(acoth(bareinterval(0x5.AD89AD14DDC78P+272, 0x2.6EC5D31670A60P+860)), bareinterval(0x6.93B8C1A4ADA4CP-864, 0x2.D165505974CDCP-276)) - @test isequal_interval(acoth(interval(-0x2.6EC5D31670A60P+860, -0x5.AD89AD14DDC78P+272)), interval(-0x2.D165505974CDCP-276, -0x6.93B8C1A4ADA4CP-864)) + @test isequal_interval(acoth(bareinterval(-0x2.6EC5D31670A60P+860, -0x5.AD89AD14DDC78P+272)), bareinterval(-0x2.D165505974CDCP-276, -0x6.93B8C1A4ADA4CP-864)) - @test isequal_interval(acoth(interval(0x4.A457C35864944P+344, 0x2.3ADEFB54BC04AP+444)), interval(0x7.2CCCD8F3E4D84P-448, 0x3.726295CD6E028P-348)) + @test isequal_interval(acoth(bareinterval(0x4.A457C35864944P+344, 0x2.3ADEFB54BC04AP+444)), bareinterval(0x7.2CCCD8F3E4D84P-448, 0x3.726295CD6E028P-348)) - @test isequal_interval(acoth(interval(-0x2.3ADEFB54BC04AP+444, -0x4.A457C35864944P+344)), interval(-0x3.726295CD6E028P-348, -0x7.2CCCD8F3E4D84P-448)) + @test isequal_interval(acoth(bareinterval(-0x2.3ADEFB54BC04AP+444, -0x4.A457C35864944P+344)), bareinterval(-0x3.726295CD6E028P-348, -0x7.2CCCD8F3E4D84P-448)) - @test isequal_interval(acoth(interval(0x6.941C8B9506D98P+56, 0x3.B11D8083AE95CP+744)), interval(0x4.55780C09BB248P-748, 0x2.6EA0EC606D92CP-60)) + @test isequal_interval(acoth(bareinterval(0x6.941C8B9506D98P+56, 0x3.B11D8083AE95CP+744)), bareinterval(0x4.55780C09BB248P-748, 0x2.6EA0EC606D92CP-60)) - @test isequal_interval(acoth(interval(-0x3.B11D8083AE95CP+744, -0x6.941C8B9506D98P+56)), interval(-0x2.6EA0EC606D92CP-60, -0x4.55780C09BB248P-748)) + @test isequal_interval(acoth(bareinterval(-0x3.B11D8083AE95CP+744, -0x6.941C8B9506D98P+56)), bareinterval(-0x2.6EA0EC606D92CP-60, -0x4.55780C09BB248P-748)) - @test isequal_interval(acoth(interval(0x1.09A940A083EE4P+132, 0x1.047FD514ADF09P+384)), interval(0xF.B940FE60125C0P-388, 0xF.6B0B0DCA2D740P-136)) + @test isequal_interval(acoth(bareinterval(0x1.09A940A083EE4P+132, 0x1.047FD514ADF09P+384)), bareinterval(0xF.B940FE60125C0P-388, 0xF.6B0B0DCA2D740P-136)) - @test isequal_interval(acoth(interval(-0x1.047FD514ADF09P+384, -0x1.09A940A083EE4P+132)), interval(-0xF.6B0B0DCA2D740P-136, -0xF.B940FE60125C0P-388)) + @test isequal_interval(acoth(bareinterval(-0x1.047FD514ADF09P+384, -0x1.09A940A083EE4P+132)), bareinterval(-0xF.6B0B0DCA2D740P-136, -0xF.B940FE60125C0P-388)) - @test isequal_interval(acoth(interval(0x7.710740B71A0DCP+256, 0xF.C0798D156BFB0P+560)), interval(0x1.04086A3447A55P-564, 0x2.266CE7A905524P-260)) + @test isequal_interval(acoth(bareinterval(0x7.710740B71A0DCP+256, 0xF.C0798D156BFB0P+560)), bareinterval(0x1.04086A3447A55P-564, 0x2.266CE7A905524P-260)) - @test isequal_interval(acoth(interval(-0xF.C0798D156BFB0P+560, -0x7.710740B71A0DCP+256)), interval(-0x2.266CE7A905524P-260, -0x1.04086A3447A55P-564)) + @test isequal_interval(acoth(bareinterval(-0xF.C0798D156BFB0P+560, -0x7.710740B71A0DCP+256)), bareinterval(-0x2.266CE7A905524P-260, -0x1.04086A3447A55P-564)) - @test isequal_interval(acoth(interval(0x2.3721A01F70458P+564, 0x9.C62BBF31FD298P+728)), interval(0x1.A3110641EF7BCP-732, 0x7.38E97DB7ABD94P-568)) + @test isequal_interval(acoth(bareinterval(0x2.3721A01F70458P+564, 0x9.C62BBF31FD298P+728)), bareinterval(0x1.A3110641EF7BCP-732, 0x7.38E97DB7ABD94P-568)) - @test isequal_interval(acoth(interval(-0x9.C62BBF31FD298P+728, -0x2.3721A01F70458P+564)), interval(-0x7.38E97DB7ABD94P-568, -0x1.A3110641EF7BCP-732)) + @test isequal_interval(acoth(bareinterval(-0x9.C62BBF31FD298P+728, -0x2.3721A01F70458P+564)), bareinterval(-0x7.38E97DB7ABD94P-568, -0x1.A3110641EF7BCP-732)) - @test isequal_interval(acoth(interval(0x6.F06D452BDCEF8P+44, 0x2.4825931366BBEP+520)), interval(0x7.030E427A5F700P-524, 0x2.4E45C5E18EA0EP-48)) + @test isequal_interval(acoth(bareinterval(0x6.F06D452BDCEF8P+44, 0x2.4825931366BBEP+520)), bareinterval(0x7.030E427A5F700P-524, 0x2.4E45C5E18EA0EP-48)) - @test isequal_interval(acoth(interval(-0x2.4825931366BBEP+520, -0x6.F06D452BDCEF8P+44)), interval(-0x2.4E45C5E18EA0EP-48, -0x7.030E427A5F700P-524)) + @test isequal_interval(acoth(bareinterval(-0x2.4825931366BBEP+520, -0x6.F06D452BDCEF8P+44)), bareinterval(-0x2.4E45C5E18EA0EP-48, -0x7.030E427A5F700P-524)) - @test isequal_interval(acoth(interval(0x5.D326D4B0883DCP+76, 0x1.77175C5A113AEP+528)), interval(0xA.EB85BC1375C18P-532, 0x2.BF32E14DB1D26P-80)) + @test isequal_interval(acoth(bareinterval(0x5.D326D4B0883DCP+76, 0x1.77175C5A113AEP+528)), bareinterval(0xA.EB85BC1375C18P-532, 0x2.BF32E14DB1D26P-80)) - @test isequal_interval(acoth(interval(-0x1.77175C5A113AEP+528, -0x5.D326D4B0883DCP+76)), interval(-0x2.BF32E14DB1D26P-80, -0xA.EB85BC1375C18P-532)) + @test isequal_interval(acoth(bareinterval(-0x1.77175C5A113AEP+528, -0x5.D326D4B0883DCP+76)), bareinterval(-0x2.BF32E14DB1D26P-80, -0xA.EB85BC1375C18P-532)) - @test isequal_interval(acoth(interval(0x1.05ADFE119D4C3P+296, 0x2.6BCDF50E05E36P+1020)), interval(0x6.9BC8F6BE69A84P-1024, 0xF.A7190DED61120P-300)) + @test isequal_interval(acoth(bareinterval(0x1.05ADFE119D4C3P+296, 0x2.6BCDF50E05E36P+1020)), bareinterval(0x6.9BC8F6BE69A84P-1024, 0xF.A7190DED61120P-300)) - @test isequal_interval(acoth(interval(-0x2.6BCDF50E05E36P+1020, -0x1.05ADFE119D4C3P+296)), interval(-0xF.A7190DED61120P-300, -0x6.9BC8F6BE69A84P-1024)) + @test isequal_interval(acoth(bareinterval(-0x2.6BCDF50E05E36P+1020, -0x1.05ADFE119D4C3P+296)), bareinterval(-0xF.A7190DED61120P-300, -0x6.9BC8F6BE69A84P-1024)) - @test isequal_interval(acoth(interval(0xA.7F5D255B81270P+408, 0x1.9D1EDDC132B38P+864)), interval(0x9.EA2F16D4B51A8P-868, 0x1.8630054C790C6P-412)) + @test isequal_interval(acoth(bareinterval(0xA.7F5D255B81270P+408, 0x1.9D1EDDC132B38P+864)), bareinterval(0x9.EA2F16D4B51A8P-868, 0x1.8630054C790C6P-412)) - @test isequal_interval(acoth(interval(-0x1.9D1EDDC132B38P+864, -0xA.7F5D255B81270P+408)), interval(-0x1.8630054C790C6P-412, -0x9.EA2F16D4B51A8P-868)) + @test isequal_interval(acoth(bareinterval(-0x1.9D1EDDC132B38P+864, -0xA.7F5D255B81270P+408)), bareinterval(-0x1.8630054C790C6P-412, -0x9.EA2F16D4B51A8P-868)) - @test isequal_interval(acoth(interval(0xC.FBE4E2C6D0A90P+484, 0x4.DF75BDC17C334P+868)), interval(0x3.4891A2770DF7CP-872, 0x1.3B7754395DD7FP-488)) + @test isequal_interval(acoth(bareinterval(0xC.FBE4E2C6D0A90P+484, 0x4.DF75BDC17C334P+868)), bareinterval(0x3.4891A2770DF7CP-872, 0x1.3B7754395DD7FP-488)) - @test isequal_interval(acoth(interval(-0x4.DF75BDC17C334P+868, -0xC.FBE4E2C6D0A90P+484)), interval(-0x1.3B7754395DD7FP-488, -0x3.4891A2770DF7CP-872)) + @test isequal_interval(acoth(bareinterval(-0x4.DF75BDC17C334P+868, -0xC.FBE4E2C6D0A90P+484)), bareinterval(-0x1.3B7754395DD7FP-488, -0x3.4891A2770DF7CP-872)) - @test isequal_interval(acoth(interval(0xB.241032F9700A8P+380, 0x1.04A65B06B2921P+640)), interval(0xF.B6EE12E44E478P-644, 0x1.6FA7BD9AAC5D2P-384)) + @test isequal_interval(acoth(bareinterval(0xB.241032F9700A8P+380, 0x1.04A65B06B2921P+640)), bareinterval(0xF.B6EE12E44E478P-644, 0x1.6FA7BD9AAC5D2P-384)) - @test isequal_interval(acoth(interval(-0x1.04A65B06B2921P+640, -0xB.241032F9700A8P+380)), interval(-0x1.6FA7BD9AAC5D2P-384, -0xF.B6EE12E44E478P-644)) + @test isequal_interval(acoth(bareinterval(-0x1.04A65B06B2921P+640, -0xB.241032F9700A8P+380)), bareinterval(-0x1.6FA7BD9AAC5D2P-384, -0xF.B6EE12E44E478P-644)) - @test isequal_interval(acoth(interval(0x5.F207EAF5F8BB8P+608, 0xA.BC87C6F90AEE8P+648)), interval(0x1.7D8116060016CP-652, 0x2.B0EE9FA61C0DAP-612)) + @test isequal_interval(acoth(bareinterval(0x5.F207EAF5F8BB8P+608, 0xA.BC87C6F90AEE8P+648)), bareinterval(0x1.7D8116060016CP-652, 0x2.B0EE9FA61C0DAP-612)) - @test isequal_interval(acoth(interval(-0xA.BC87C6F90AEE8P+648, -0x5.F207EAF5F8BB8P+608)), interval(-0x2.B0EE9FA61C0DAP-612, -0x1.7D8116060016CP-652)) + @test isequal_interval(acoth(bareinterval(-0xA.BC87C6F90AEE8P+648, -0x5.F207EAF5F8BB8P+608)), bareinterval(-0x2.B0EE9FA61C0DAP-612, -0x1.7D8116060016CP-652)) - @test isequal_interval(acoth(interval(0x1.BCD62C46ADFD9P+16, 0xA.CD289B35ECD08P+564)), interval(0x1.7B35C74EEC020P-568, 0x9.35374E76B1BE8P-20)) + @test isequal_interval(acoth(bareinterval(0x1.BCD62C46ADFD9P+16, 0xA.CD289B35ECD08P+564)), bareinterval(0x1.7B35C74EEC020P-568, 0x9.35374E76B1BE8P-20)) - @test isequal_interval(acoth(interval(-0xA.CD289B35ECD08P+564, -0x1.BCD62C46ADFD9P+16)), interval(-0x9.35374E76B1BE8P-20, -0x1.7B35C74EEC020P-568)) + @test isequal_interval(acoth(bareinterval(-0xA.CD289B35ECD08P+564, -0x1.BCD62C46ADFD9P+16)), bareinterval(-0x9.35374E76B1BE8P-20, -0x1.7B35C74EEC020P-568)) - @test isequal_interval(acoth(interval(0x6.534BBA40A0B4CP+224, 0x1.8DE35856E91FDP+452)), interval(0xA.4B5AAEDFCE6A8P-456, 0x2.878CF52E5FBF8P-228)) + @test isequal_interval(acoth(bareinterval(0x6.534BBA40A0B4CP+224, 0x1.8DE35856E91FDP+452)), bareinterval(0xA.4B5AAEDFCE6A8P-456, 0x2.878CF52E5FBF8P-228)) - @test isequal_interval(acoth(interval(-0x1.8DE35856E91FDP+452, -0x6.534BBA40A0B4CP+224)), interval(-0x2.878CF52E5FBF8P-228, -0xA.4B5AAEDFCE6A8P-456)) + @test isequal_interval(acoth(bareinterval(-0x1.8DE35856E91FDP+452, -0x6.534BBA40A0B4CP+224)), bareinterval(-0x2.878CF52E5FBF8P-228, -0xA.4B5AAEDFCE6A8P-456)) - @test isequal_interval(expm1(interval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), interval(-0x1.0000000000000P+0, -0x1.B3E4076622F03P-232)) + @test isequal_interval(expm1(bareinterval(-0x1.16CC0DF1540F5P+112, -0x1.B3E4076622F04P-232)), bareinterval(-0x1.0000000000000P+0, -0x1.B3E4076622F03P-232)) - @test isequal_interval(expm1(interval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), interval(-0x2.42042B9A88438P-220, -0x2.A213429DB0506P-508)) + @test isequal_interval(expm1(bareinterval(-0x2.42042B9A88438P-220, -0x2.A213429DB0508P-508)), bareinterval(-0x2.42042B9A88438P-220, -0x2.A213429DB0506P-508)) - @test isequal_interval(expm1(interval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), interval(-0x1.0000000000000P+0, -0x1.5D74CFDA6B291P-200)) + @test isequal_interval(expm1(bareinterval(-0x2.0E2E40B15D814P+272, -0x1.5D74CFDA6B292P-200)), bareinterval(-0x1.0000000000000P+0, -0x1.5D74CFDA6B291P-200)) - @test isequal_interval(expm1(interval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), interval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3470P-456)) + @test isequal_interval(expm1(bareinterval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3472P-456)), bareinterval(-0x2.0EA791886F712P-416, -0x3.FE66A8D1A3470P-456)) - @test isequal_interval(expm1(interval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), interval(-0x1.0000000000000P+0, -0xD.45BCBA84EE268P-4)) + @test isequal_interval(expm1(bareinterval(-0x8.80EEFDF700148P+332, -0x1.C4E85E50A626DP+0)), bareinterval(-0x1.0000000000000P+0, -0xD.45BCBA84EE268P-4)) - @test isequal_interval(expm1(interval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), interval(-0x1.0000000000000P+0, -0x4.F0F28370909F8P-440)) + @test isequal_interval(expm1(bareinterval(-0x6.CA83546563A5CP+236, -0x4.F0F28370909FCP-440)), bareinterval(-0x1.0000000000000P+0, -0x4.F0F28370909F8P-440)) - @test isequal_interval(expm1(interval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), interval(-0x1.0000000000000P+0, -0x1.EB095183538C7P-344)) + @test isequal_interval(expm1(bareinterval(-0x4.E60572D4FCFD0P+172, -0x1.EB095183538C8P-344)), bareinterval(-0x1.0000000000000P+0, -0x1.EB095183538C7P-344)) - @test isequal_interval(expm1(interval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), interval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE88P-756)) + @test isequal_interval(expm1(bareinterval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE90P-756)), bareinterval(-0x2.7ED8954764B12P-288, -0x8.71DC22117BE88P-756)) - @test isequal_interval(expm1(interval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), interval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357A8P-564)) + @test isequal_interval(expm1(bareinterval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357B0P-564)), bareinterval(-0xD.CF39B8DD68B98P-76, -0x8.0205C5B1357A8P-564)) - @test isequal_interval(expm1(interval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), interval(-0x1.0000000000000P+0, -0x5.CBE2BD423AF1CP-48)) + @test isequal_interval(expm1(bareinterval(-0x4.AF296DD37FD74P+256, -0x5.CBE2BD423B02CP-48)), bareinterval(-0x1.0000000000000P+0, -0x5.CBE2BD423AF1CP-48)) - @test isequal_interval(expm1(interval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), interval(-0x1.0000000000000P+0, -0xF.FFFFFFFFFFFF8P-4)) + @test isequal_interval(expm1(bareinterval(-0x1.1FBA2D1252D2BP+656, -0x2.4B7A4095C91B4P+8)), bareinterval(-0x1.0000000000000P+0, -0xF.FFFFFFFFFFFF8P-4)) - @test isequal_interval(expm1(interval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), interval(-0x1.0000000000000P+0, -0x2.581DAD9AFE6DAP-172)) + @test isequal_interval(expm1(bareinterval(-0x1.44F2134E1901EP+8, -0x2.581DAD9AFE6DCP-172)), bareinterval(-0x1.0000000000000P+0, -0x2.581DAD9AFE6DAP-172)) - @test isequal_interval(expm1(interval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), interval(-0x1.0000000000000P+0, -0x7.19390F862F498P-544)) + @test isequal_interval(expm1(bareinterval(-0x2.9529E333F2ABAP+988, -0x7.19390F862F49CP-544)), bareinterval(-0x1.0000000000000P+0, -0x7.19390F862F498P-544)) - @test isequal_interval(expm1(interval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), interval(-0x1.58391FD92C387P-148, -0x4.0C12426A57190P-440)) + @test isequal_interval(expm1(bareinterval(-0x1.58391FD92C387P-148, -0x4.0C12426A57194P-440)), bareinterval(-0x1.58391FD92C387P-148, -0x4.0C12426A57190P-440)) - @test isequal_interval(expm1(interval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), interval(-0x1.0000000000000P+0, -0xF.13E388B2165E8P-512)) + @test isequal_interval(expm1(bareinterval(-0xB.FADC4FB83E140P+348, -0xF.13E388B2165F0P-512)), bareinterval(-0x1.0000000000000P+0, -0xF.13E388B2165E8P-512)) - @test isequal_interval(expm1(interval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), interval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED014P-316)) + @test isequal_interval(expm1(bareinterval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED018P-316)), bareinterval(-0x8.86826CE1AB700P-240, -0x4.FEA8D3A3ED014P-316)) - @test isequal_interval(expm1(interval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), interval(0x1.B7E151628AED2P+0, 0x6.63992E35376B8P+0)) + @test isequal_interval(expm1(bareinterval(0x1.0000000000000P+0, 0x2.0000000000000P+0)), bareinterval(0x1.B7E151628AED2P+0, 0x6.63992E35376B8P+0)) - @test isequal_interval(expm1(interval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), interval(-0xA.1D2A7274C4328P-4, +0x6.63992E35376B8P+0)) + @test isequal_interval(expm1(bareinterval(-0x1.0000000000000P+0, +0x2.0000000000000P+0)), bareinterval(-0xA.1D2A7274C4328P-4, +0x6.63992E35376B8P+0)) - @test isequal_interval(expm1(interval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), interval(-0xF.E466C01FF2AD0P-4, -0xF.341279998A7A8P-4)) + @test isequal_interval(expm1(bareinterval(-0x5.0000000000000P+0, -0x3.0000000000000P+0)), bareinterval(-0xF.E466C01FF2AD0P-4, -0xF.341279998A7A8P-4)) - @test isequal_interval(expm1(interval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), interval(-0xD.D5AAAB880FC70P-4, +0xD.27660B11A9EF8P-4)) + @test isequal_interval(expm1(bareinterval(-0x2.0000000000000P+0, +0x9.9999999999998P-4)), bareinterval(-0xD.D5AAAB880FC70P-4, +0xD.27660B11A9EF8P-4)) - @test isequal_interval(expm1(interval(0x4.0000000000000P-1076, 0x4.4444400000000P-1056)), interval(0x4.0000000000000P-1076, 0x4.4444800000000P-1056)) + @test isequal_interval(expm1(bareinterval(0x4.0000000000000P-1076, 0x4.4444400000000P-1056)), bareinterval(0x4.0000000000000P-1076, 0x4.4444800000000P-1056)) - @test isequal_interval(expm1(interval(0x4.4440000000000P-1064, 0x1.0000000000000P+0)), interval(0x4.4440000000000P-1064, 0x1.B7E151628AED3P+0)) + @test isequal_interval(expm1(bareinterval(0x4.4440000000000P-1064, 0x1.0000000000000P+0)), bareinterval(0x4.4440000000000P-1064, 0x1.B7E151628AED3P+0)) - @test isequal_interval(expm1(interval(-0x4.4444000000000P-1060, +0x4.4444000000000P-1060)), interval(-0x4.4444000000000P-1060, +0x4.4448000000000P-1060)) + @test isequal_interval(expm1(bareinterval(-0x4.4444000000000P-1060, +0x4.4444000000000P-1060)), bareinterval(-0x4.4444000000000P-1060, +0x4.4448000000000P-1060)) - @test isequal_interval(expm1(interval(-0x4.4400000000000P-1068, +0x1.FFF0000000000P+0)), interval(-0x4.4400000000000P-1068, +0x6.6322F8540CFB4P+0)) + @test isequal_interval(expm1(bareinterval(-0x4.4400000000000P-1068, +0x1.FFF0000000000P+0)), bareinterval(-0x4.4400000000000P-1068, +0x6.6322F8540CFB4P+0)) - @test isequal_interval(expm1(interval(-0x1.FFFF000000000P+0, -0x8.8888880000000P-1052)), interval(-0xD.D5A88131A6240P-4, -0x8.8888840000000P-1052)) + @test isequal_interval(expm1(bareinterval(-0x1.FFFF000000000P+0, -0x8.8888880000000P-1052)), bareinterval(-0xD.D5A88131A6240P-4, -0x8.8888840000000P-1052)) - @test isequal_interval(expm1(interval(-0x1.FFFFFFF000000P+0, +0x8.CD11555400000P-1044)), interval(-0xD.D5AAAB656A718P-4, +0x8.CD11555800000P-1044)) + @test isequal_interval(expm1(bareinterval(-0x1.FFFFFFF000000P+0, +0x8.CD11555400000P-1044)), bareinterval(-0xD.D5AAAB656A718P-4, +0x8.CD11555800000P-1044)) - @test isequal_interval(log1p(interval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), interval(0xC.4B4A6EB6B3AE8P-264, 0x4.227AD8183FB70P+4)) + @test isequal_interval(log1p(bareinterval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), bareinterval(0xC.4B4A6EB6B3AE8P-264, 0x4.227AD8183FB70P+4)) - @test isequal_interval(log1p(interval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), interval(0x2.6213E21B14892P-516, 0x6.6606F0995E5F4P-224)) + @test isequal_interval(log1p(bareinterval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), bareinterval(0x2.6213E21B14892P-516, 0x6.6606F0995E5F4P-224)) - @test isequal_interval(log1p(interval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), interval(0x9.0FF2CAA1B3040P-240, 0xA.40B346F454218P+4)) + @test isequal_interval(log1p(bareinterval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), bareinterval(0x9.0FF2CAA1B3040P-240, 0xA.40B346F454218P+4)) - @test isequal_interval(log1p(interval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), interval(0x8.E2ADA8DFBE930P-492, 0x3.67CB3BE0BB146P-452)) + @test isequal_interval(log1p(bareinterval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), bareinterval(0x8.E2ADA8DFBE930P-492, 0x3.67CB3BE0BB146P-452)) - @test isequal_interval(log1p(interval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), interval(0x8.80F0717A1DC40P+4, 0x9.D6130F01F8B78P+4)) + @test isequal_interval(log1p(bareinterval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), bareinterval(0x8.80F0717A1DC40P+4, 0x9.D6130F01F8B78P+4)) - @test isequal_interval(log1p(interval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), interval(0x6.A000A1283845CP-44, 0xC.091AAD1207058P+4)) + @test isequal_interval(log1p(bareinterval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), bareinterval(0x6.A000A1283845CP-44, 0xC.091AAD1207058P+4)) - @test isequal_interval(log1p(interval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), interval(0x1.3C84E4F9C80CDP-476, 0x8.A1137BDE55CF8P+4)) + @test isequal_interval(log1p(bareinterval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), bareinterval(0x1.3C84E4F9C80CDP-476, 0x8.A1137BDE55CF8P+4)) - @test isequal_interval(log1p(interval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), interval(0x8.41D2DB6D93540P-376, 0x6.21D80D9193AB8P+4)) + @test isequal_interval(log1p(bareinterval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), bareinterval(0x8.41D2DB6D93540P-376, 0x6.21D80D9193AB8P+4)) - @test isequal_interval(log1p(interval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), interval(0x1.2C18FEEBCAEADP-768, 0x1.C369E759DF5E3P-328)) + @test isequal_interval(log1p(bareinterval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), bareinterval(0x1.2C18FEEBCAEADP-768, 0x1.C369E759DF5E3P-328)) - @test isequal_interval(log1p(interval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), interval(0x4.D94E91619D3ECP-580, 0x2.9F6CAF6B5513EP-132)) + @test isequal_interval(log1p(bareinterval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), bareinterval(0x4.D94E91619D3ECP-580, 0x2.9F6CAF6B5513EP-132)) - @test isequal_interval(log1p(interval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), interval(0x5.15D8B410E0A5CP+4, 0xC.0A13DC536CD58P+4)) + @test isequal_interval(log1p(bareinterval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), bareinterval(0x5.15D8B410E0A5CP+4, 0xC.0A13DC536CD58P+4)) - @test isequal_interval(log1p(interval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), interval(0x3.36DE5C55594ECP-100, 0x8.DFF506FE0D9F8P+4)) + @test isequal_interval(log1p(bareinterval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), bareinterval(0x3.36DE5C55594ECP-100, 0x8.DFF506FE0D9F8P+4)) - @test isequal_interval(log1p(interval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), interval(0x4.5771391F308D8P+0, 0x1.9D179EA5204D0P+8)) + @test isequal_interval(log1p(bareinterval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), bareinterval(0x4.5771391F308D8P+0, 0x1.9D179EA5204D0P+8)) - @test isequal_interval(log1p(interval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), interval(0xE.CD14C501247C0P+0, 0x1.B46DC0D02B874P+8)) + @test isequal_interval(log1p(bareinterval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), bareinterval(0xE.CD14C501247C0P+0, 0x1.B46DC0D02B874P+8)) - @test isequal_interval(log1p(interval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), interval(0x2.33950F38F830CP-176, 0x5.BE0377E504F78P-24)) + @test isequal_interval(log1p(bareinterval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), bareinterval(0x2.33950F38F830CP-176, 0x5.BE0377E504F78P-24)) - @test isequal_interval(log1p(interval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), interval(0x3.24F03DF33568AP-560, 0x2.805CE2DC91036P+8)) + @test isequal_interval(log1p(bareinterval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), bareinterval(0x3.24F03DF33568AP-560, 0x2.805CE2DC91036P+8)) - @test isequal_interval(log1p(interval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), interval(0x2.D572639DC5FA6P-468, 0x1.95CF42AA171CDP-160)) + @test isequal_interval(log1p(bareinterval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), bareinterval(0x2.D572639DC5FA6P-468, 0x1.95CF42AA171CDP-160)) - @test isequal_interval(log1p(interval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), interval(0x4.705A028302DACP-532, 0xE.1A4A3523F2658P+4)) + @test isequal_interval(log1p(bareinterval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), bareinterval(0x4.705A028302DACP-532, 0xE.1A4A3523F2658P+4)) - @test isequal_interval(log1p(interval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), interval(0x6.564D09AD1D214P+4, 0x8.914A9531FD118P+4)) + @test isequal_interval(log1p(bareinterval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), bareinterval(0x6.564D09AD1D214P+4, 0x8.914A9531FD118P+4)) - @test isequal_interval(log1p(interval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), interval(0x4.9FA5A1E4DF73CP-328, 0x1.11B85141B78F6P-240)) + @test isequal_interval(log1p(bareinterval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), bareinterval(0x4.9FA5A1E4DF73CP-328, 0x1.11B85141B78F6P-240)) - @test isequal_interval(log1p(interval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), interval(0xF.BD7308ED73FF0P+4, 0x1.6DF4DA39DC5DDP+8)) + @test isequal_interval(log1p(bareinterval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), bareinterval(0xF.BD7308ED73FF0P+4, 0x1.6DF4DA39DC5DDP+8)) - @test isequal_interval(log1p(interval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), interval(0x6.88441038D56B4P-108, 0x5.F718BBF0CE2F8P+4)) + @test isequal_interval(log1p(bareinterval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), bareinterval(0x6.88441038D56B4P-108, 0x5.F718BBF0CE2F8P+4)) - @test isequal_interval(log1p(interval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), interval(0x7.1761CAB055130P-356, 0x1.92EFD09488689P-76)) + @test isequal_interval(log1p(bareinterval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), bareinterval(0x7.1761CAB055130P-356, 0x1.92EFD09488689P-76)) - @test isequal_interval(log1p(interval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), interval(0x6.2085E427413C4P-252, 0xB.8CDD3AFE235D0P-36)) + @test isequal_interval(log1p(bareinterval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), bareinterval(0x6.2085E427413C4P-252, 0xB.8CDD3AFE235D0P-36)) - @test isequal_interval(log1p(interval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), interval(0xB.F5F1C0FA33970P-504, 0x3.36D2B121508A8P+4)) + @test isequal_interval(log1p(bareinterval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), bareinterval(0xB.F5F1C0FA33970P-504, 0x3.36D2B121508A8P+4)) - @test isequal_interval(log1p(interval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), interval(0xB.BC7E37EB2D380P-216, 0x8.5ADC069F618A8P+4)) + @test isequal_interval(log1p(bareinterval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), bareinterval(0xB.BC7E37EB2D380P-216, 0x8.5ADC069F618A8P+4)) - @test isequal_interval(log1p(interval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), interval(0x1.E139DD116F867P-688, 0xD.2545346D68FD0P-148)) + @test isequal_interval(log1p(bareinterval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), bareinterval(0x1.E139DD116F867P-688, 0xD.2545346D68FD0P-148)) - @test isequal_interval(log1p(interval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), interval(0x8.6243148F46208P+4, 0xB.519B6E544F898P+4)) + @test isequal_interval(log1p(bareinterval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), bareinterval(0x8.6243148F46208P+4, 0xB.519B6E544F898P+4)) - @test isequal_interval(log1p(interval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), interval(0x5.9C4642ED78BC4P-340, 0x1.990C99B6124FEP+8)) + @test isequal_interval(log1p(bareinterval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), bareinterval(0x5.9C4642ED78BC4P-340, 0x1.990C99B6124FEP+8)) - @test isequal_interval(log1p(interval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), interval(0xF.C05EA810DFE80P-180, 0xA.05884FBED5F48P-152)) + @test isequal_interval(log1p(bareinterval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), bareinterval(0xF.C05EA810DFE80P-180, 0xA.05884FBED5F48P-152)) - @test isequal_interval(sqrt(interval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), interval(0x3.819C8C44FCAE8P-132, 0xD.2F2830FA93228P+44)) + @test isequal_interval(sqrt(bareinterval(0xC.4B4A6EB6B3AF0P-264, 0xA.DD2C4C1BE4B30P+92)), bareinterval(0x3.819C8C44FCAE8P-132, 0xD.2F2830FA93228P+44)) - @test isequal_interval(sqrt(interval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), interval(0x6.2CC8B5D1B7648P-260, 0x2.878F8E10E2752P-112)) + @test isequal_interval(sqrt(bareinterval(0x2.6213E21B14894P-516, 0x6.6606F0995E5F4P-224)), bareinterval(0x6.2CC8B5D1B7648P-260, 0x2.878F8E10E2752P-112)) - @test isequal_interval(sqrt(interval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), interval(0x3.02A74AB0BBF36P-120, 0x5.0979194446A10P+116)) + @test isequal_interval(sqrt(bareinterval(0x9.0FF2CAA1B3048P-240, 0x1.95F14B9BA7449P+236)), bareinterval(0x3.02A74AB0BBF36P-120, 0x5.0979194446A10P+116)) - @test isequal_interval(sqrt(interval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), interval(0xB.EC63BFE10BCC8P-248, 0x7.61AC89CF17804P-228)) + @test isequal_interval(sqrt(bareinterval(0x8.E2ADA8DFBE938P-492, 0x3.67CB3BE0BB146P-452)), bareinterval(0xB.EC63BFE10BCC8P-248, 0x7.61AC89CF17804P-228)) - @test isequal_interval(sqrt(interval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), interval(0x4.6CBEB2D8F6718P+96, 0x2.E0F32319AC30AP+112)) + @test isequal_interval(sqrt(bareinterval(0x1.394270BBCBA7EP+196, 0x8.4976F0BF45A40P+224)), bareinterval(0x4.6CBEB2D8F6718P+96, 0x2.E0F32319AC30AP+112)) - @test isequal_interval(sqrt(interval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), interval(0xA.4BAEE7F482900P-24, 0x7.830C8D5A5F3D8P+136)) + @test isequal_interval(sqrt(bareinterval(0x6.A000A12839A50P-44, 0x3.86DC59439415AP+276)), bareinterval(0xA.4BAEE7F482900P-24, 0x7.830C8D5A5F3D8P+136)) - @test isequal_interval(sqrt(interval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), interval(0x4.729F7C344CE30P-240, 0xC.14519D6697FF0P+96)) + @test isequal_interval(sqrt(bareinterval(0x1.3C84E4F9C80CEP-476, 0x9.1E9439C3B4358P+196)), bareinterval(0x4.729F7C344CE30P-240, 0xC.14519D6697FF0P+96)) - @test isequal_interval(sqrt(interval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), interval(0x2.DF9F14A64C77AP-188, 0x6.D87D667089BD8P+68)) + @test isequal_interval(sqrt(bareinterval(0x8.41D2DB6D93548P-376, 0x2.EDCF4A7919034P+140)), bareinterval(0x2.DF9F14A64C77AP-188, 0x6.D87D667089BD8P+68)) - @test isequal_interval(sqrt(interval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), interval(0x1.152C585EDDB6AP-384, 0x1.53F1A81CAA4A0P-164)) + @test isequal_interval(sqrt(bareinterval(0x1.2C18FEEBCAEAEP-768, 0x1.C369E759DF5E3P-328)), bareinterval(0x1.152C585EDDB6AP-384, 0x1.53F1A81CAA4A0P-164)) - @test isequal_interval(sqrt(interval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), interval(0x8.CEDC2135E05E8P-292, 0x6.7A5BEF2579C34P-68)) + @test isequal_interval(sqrt(bareinterval(0x4.D94E91619D3F0P-580, 0x2.9F6CAF6B5513EP-132)), bareinterval(0x8.CEDC2135E05E8P-292, 0x6.7A5BEF2579C34P-68)) - @test isequal_interval(sqrt(interval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), interval(0x6.7722C88D985D8P+56, 0x7.BE7173245A668P+136)) + @test isequal_interval(sqrt(bareinterval(0x2.9CD12C1D0AAC4P+116, 0x3.BF7E0E52DC1AAP+276)), bareinterval(0x6.7722C88D985D8P+56, 0x7.BE7173245A668P+136)) - @test isequal_interval(sqrt(interval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), interval(0x7.2BE248A308D24P-52, 0x5.630224B50BCF8P+100)) + @test isequal_interval(sqrt(bareinterval(0x3.36DE5C55594EEP-100, 0x1.D0460177B1553P+204)), bareinterval(0x7.2BE248A308D24P-52, 0x5.630224B50BCF8P+100)) - @test isequal_interval(sqrt(interval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), interval(0x8.B53B61217B4F8P+0, 0x3.F40FA54A699E2P+296)) + @test isequal_interval(sqrt(bareinterval(0x4.BD4031736F7A8P+4, 0xF.A10BB3C91C7B0P+592)), bareinterval(0x8.B53B61217B4F8P+0, 0x3.F40FA54A699E2P+296)) - @test isequal_interval(sqrt(interval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), interval(0x6.64E1F64817930P+8, 0x7.0BBE006E8934CP+312)) + @test isequal_interval(sqrt(bareinterval(0x2.8E258DB3C44F8P+20, 0x3.1A4EDE719A4C0P+628)), bareinterval(0x6.64E1F64817930P+8, 0x7.0BBE006E8934CP+312)) - @test isequal_interval(sqrt(interval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), interval(0x1.7BD69462CDAD2P-88, 0x2.6573BFB248EF0P-12)) + @test isequal_interval(sqrt(bareinterval(0x2.33950F38F830EP-176, 0x5.BE0388619B018P-24)), bareinterval(0x1.7BD69462CDAD2P-88, 0x2.6573BFB248EF0P-12)) - @test isequal_interval(sqrt(interval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), interval(0x1.C5F168118C2B1P-280, 0x3.CB8CCAD62ED10P+460)) + @test isequal_interval(sqrt(bareinterval(0x3.24F03DF33568CP-560, 0xE.67255823421E8P+920)), bareinterval(0x1.C5F168118C2B1P-280, 0x3.CB8CCAD62ED10P+460)) - @test isequal_interval(sqrt(interval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), interval(0x6.BBC8A036CC930P-236, 0x1.4250C275A7B2BP-80)) + @test isequal_interval(sqrt(bareinterval(0x2.D572639DC5FA8P-468, 0x1.95CF42AA171CDP-160)), bareinterval(0x6.BBC8A036CC930P-236, 0x1.4250C275A7B2BP-80)) - @test isequal_interval(sqrt(interval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), interval(0x8.6D6D9A3EA2160P-268, 0x6.CEB17F56F1B50P+160)) + @test isequal_interval(sqrt(bareinterval(0x4.705A028302DB0P-532, 0x2.E57341C14970CP+324)), bareinterval(0x8.6D6D9A3EA2160P-268, 0x6.CEB17F56F1B50P+160)) - @test isequal_interval(sqrt(interval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), interval(0x2.343E215EB2264P+72, 0x7.603E67F0E1DD0P+96)) + @test isequal_interval(sqrt(bareinterval(0x4.DBA1D21D6F308P+144, 0x3.667988C57865AP+196)), bareinterval(0x2.343E215EB2264P+72, 0x7.603E67F0E1DD0P+96)) - @test isequal_interval(sqrt(interval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), interval(0x2.26777C4E368BEP-164, 0x1.08B63617A4210P-120)) + @test isequal_interval(sqrt(bareinterval(0x4.9FA5A1E4DF740P-328, 0x1.11B85141B78F6P-240)), bareinterval(0x2.26777C4E368BEP-164, 0x1.08B63617A4210P-120)) - @test isequal_interval(sqrt(interval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), interval(0x3.2B934CDCC29E0P+180, 0xF.CC99981010AD0P+260)) + @test isequal_interval(sqrt(bareinterval(0xA.0CDE9DC015B08P+360, 0xF.99D84F862AC58P+524)), bareinterval(0x3.2B934CDCC29E0P+180, 0xF.CC99981010AD0P+260)) - @test isequal_interval(sqrt(interval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), interval(0xA.392C9B2283838P-56, 0x1.CCC9C68E6B873P+68)) + @test isequal_interval(sqrt(bareinterval(0x6.88441038D56B8P-108, 0x3.3D65C09938132P+136)), bareinterval(0xA.392C9B2283838P-56, 0x1.CCC9C68E6B873P+68)) - @test isequal_interval(sqrt(interval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), interval(0xA.A6DE001E1A878P-180, 0x5.04B0B42B185F4P-40)) + @test isequal_interval(sqrt(bareinterval(0x7.1761CAB055134P-356, 0x1.92EFD09488689P-76)), bareinterval(0xA.A6DE001E1A878P-180, 0x5.04B0B42B185F4P-40)) - @test isequal_interval(sqrt(interval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), interval(0x9.E6B17DD90B818P-128, 0xD.9821AE0A3F288P-20)) + @test isequal_interval(sqrt(bareinterval(0x6.2085E427413C8P-252, 0xB.8CDD3B024EA10P-36)), bareinterval(0x9.E6B17DD90B818P-128, 0xD.9821AE0A3F288P-20)) - @test isequal_interval(sqrt(interval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), interval(0x3.755B7F9B147FCP-252, 0x2.235AF64AA2532P+36)) + @test isequal_interval(sqrt(bareinterval(0xB.F5F1C0FA33978P-504, 0x4.924DD8D50B1CCP+72)), bareinterval(0x3.755B7F9B147FCP-252, 0x2.235AF64AA2532P+36)) - @test isequal_interval(sqrt(interval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), interval(0x3.6D0318CB65970P-108, 0x1.589B93C7CC280P+96)) + @test isequal_interval(sqrt(bareinterval(0xB.BC7E37EB2D388P-216, 0x1.CFE27BB53DEBBP+192)), bareinterval(0x3.6D0318CB65970P-108, 0x1.589B93C7CC280P+96)) - @test isequal_interval(sqrt(interval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), interval(0x1.5EFD65C23F515P-344, 0xE.80B36809CA340P-76)) + @test isequal_interval(sqrt(bareinterval(0x1.E139DD116F868P-688, 0xD.2545346D68FD0P-148)), bareinterval(0x1.5EFD65C23F515P-344, 0xE.80B36809CA340P-76)) - @test isequal_interval(sqrt(interval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), interval(0x1.B24CEBB3D4B84P+96, 0x6.37B4CD9068634P+128)) + @test isequal_interval(sqrt(bareinterval(0x2.E0C8E64A890ACP+192, 0x2.6A898D2CAA9A4P+260)), bareinterval(0x1.B24CEBB3D4B84P+96, 0x6.37B4CD9068634P+128)) - @test isequal_interval(sqrt(interval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), interval(0x9.797C4D6802170P-172, 0x8.60D1F01F1A8D8P+292)) + @test isequal_interval(sqrt(bareinterval(0x5.9C4642ED78BC8P-340, 0x4.631BD2232F0C0P+588)), bareinterval(0x9.797C4D6802170P-172, 0x8.60D1F01F1A8D8P+292)) - @test isequal_interval(sqrt(interval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), interval(0xF.E00F72E6C82F8P-92, 0x3.2A6AD8ACFCBB0P-76)) + @test isequal_interval(sqrt(bareinterval(0xF.C05EA810DFE88P-180, 0xA.05884FBED5F48P-152)), bareinterval(0xF.E00F72E6C82F8P-92, 0x3.2A6AD8ACFCBB0P-76)) - @test isequal_interval(interval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944)^2, interval(0x0.0000000000000P+0, 0x6.BFD4840B33478P-300)) + @test isequal_interval(nthpow(bareinterval(-0xA.644C9D88EA8C8P-152, -0xD.8EC7927926F18P-944), 2), bareinterval(0x0.0000000000000P+0, 0x6.BFD4840B33478P-300)) - @test isequal_interval(interval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624)^2, interval(0x0.0000000000000P+0, 0x2.A05EA84E4893CP-872)) + @test isequal_interval(nthpow(bareinterval(-0x1.9EE1A9DB994F5P-436, -0x6.D914701C82FECP-624), 2), bareinterval(0x0.0000000000000P+0, 0x2.A05EA84E4893CP-872)) - @test isequal_interval(interval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960)^2, interval(0x0.0000000000000P+0, 0x1.D1A144EFBEB44P+12)) + @test isequal_interval(nthpow(bareinterval(-0x5.65057F3EFFC60P+4, -0x2.3617CF5815ECAP-960), 2), bareinterval(0x0.0000000000000P+0, 0x1.D1A144EFBEB44P+12)) - @test isequal_interval(interval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588)^2, interval(0x0.0000000000000P+0, 0x2.8817BFAFBDF18P-744)) + @test isequal_interval(nthpow(bareinterval(-0x1.975299CCB0E08P-372, +0xB.BEC7D35B45B00P-588), 2), bareinterval(0x0.0000000000000P+0, 0x2.8817BFAFBDF18P-744)) - @test isequal_interval(interval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564)^2, interval(0x0.0000000000000P+0, 0xB.051CC05C2EBE0P-712)) + @test isequal_interval(nthpow(bareinterval(-0x3.51D388D47AED2P-356, -0x1.C3A9CD7025105P-564), 2), bareinterval(0x0.0000000000000P+0, 0xB.051CC05C2EBE0P-712)) - @test isequal_interval(interval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412)^2, interval(0x4.5E83E96FF693CP-824, 0xA.548CA7F8C13A0P-660)) + @test isequal_interval(nthpow(bareinterval(-0xC.DB363268CF708P-332, -0x2.171B7D7BFE4E0P-412), 2), bareinterval(0x4.5E83E96FF693CP-824, 0xA.548CA7F8C13A0P-660)) - @test isequal_interval(interval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792)^2, interval(0x0.0000000000000P+0, 0x1.6EBF489D48CA5P-80)) + @test isequal_interval(nthpow(bareinterval(-0x1.32690AAC2472DP-40, -0x8.706EBDCF39C88P-792), 2), bareinterval(0x0.0000000000000P+0, 0x1.6EBF489D48CA5P-80)) - @test isequal_interval(interval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204)^2, interval(0x8.C23056BA480A8P-408, 0x1.90CBA74D12CF4P-396)) + @test isequal_interval(nthpow(bareinterval(-0x5.0145AF0C53324P-200, -0x2.F5A0CB3301856P-204), 2), bareinterval(0x8.C23056BA480A8P-408, 0x1.90CBA74D12CF4P-396)) - @test isequal_interval(interval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80)^2, interval(0xE.89E458947EFA8P-532, 0xB.F4E1999D73020P-160)) + @test isequal_interval(nthpow(bareinterval(0xF.4077C7E8CD6A0P-268, 0x3.753426098AC5AP-80), 2), bareinterval(0xE.89E458947EFA8P-532, 0xB.F4E1999D73020P-160)) - @test isequal_interval(interval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916)^2, interval(0x0.0000000000000P+0, 0x8.8D07F2E827770P-748)) + @test isequal_interval(nthpow(bareinterval(-0xB.B25F8D8BB7FB8P-376, -0x2.017A332F9B05CP-916), 2), bareinterval(0x0.0000000000000P+0, 0x8.8D07F2E827770P-748)) - @test isequal_interval(interval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16)^2, interval(0x0.0000000000000P+0, 0xC.A9B03500DD578P-28)) + @test isequal_interval(nthpow(bareinterval(-0xD.947CA427FDFE0P-592, +0xE.3BE493B5BC8E8P-16), 2), bareinterval(0x0.0000000000000P+0, 0xC.A9B03500DD578P-28)) - @test isequal_interval(interval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576)^2, interval(0x0.0000000000000P+0, 0x5.F6582538F0F44P-668)) + @test isequal_interval(nthpow(bareinterval(-0x9.C46198B2471F0P-336, -0x1.65ED85DF2D4B7P-576), 2), bareinterval(0x0.0000000000000P+0, 0x5.F6582538F0F44P-668)) - @test isequal_interval(interval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388)^2, interval(0x0.0000000000000P+0, 0x2.52887FE100FF0P-772)) + @test isequal_interval(nthpow(bareinterval(-0x3.2C867C027DB44P-936, +0x6.1883EA827AB6CP-388), 2), bareinterval(0x0.0000000000000P+0, 0x2.52887FE100FF0P-772)) - @test isequal_interval(interval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20)^2, interval(0x0.0000000000000P+0, 0x1.B9CBC9B69E7BFP-36)) + @test isequal_interval(nthpow(bareinterval(-0x3.560EF91C47DEAP-492, +0x5.413664DD17ABCP-20), 2), bareinterval(0x0.0000000000000P+0, 0x1.B9CBC9B69E7BFP-36)) - @test isequal_interval(interval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836)^2, interval(0x0.0000000000000P+0, 0x4.377B251ABDCC0P-604)) + @test isequal_interval(nthpow(bareinterval(-0x8.36BFCD74A6D68P-304, -0x3.2C20EB130D510P-836), 2), bareinterval(0x0.0000000000000P+0, 0x4.377B251ABDCC0P-604)) - @test isequal_interval(interval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760)^2, interval(0x0.0000000000000P+0, 0x2.D668271745A42P-996)) + @test isequal_interval(nthpow(bareinterval(-0x6.BCEC84603958CP-500, -0x1.068B13DA99666P-760), 2), bareinterval(0x0.0000000000000P+0, 0x2.D668271745A42P-996)) - @test isequal_interval(interval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780)^2, interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(nthpow(bareinterval(-0x1.2789C2D583BCDP-568, -0x1.F2BD89DAD0665P-780), 2), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(interval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780)^2, interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(nthpow(bareinterval(-0xC.FE4E8D857E3E0P-548, +0x1.580844B9DC45CP-780), 2), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(interval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664)^2, interval(0x0.0000000000000P+0, 0x9.7A69470135FA8P-100)) + @test isequal_interval(nthpow(bareinterval(-0xC.508D29ACB01B8P-52, +0x1.B1E6B793078DDP-664), 2), bareinterval(0x0.0000000000000P+0, 0x9.7A69470135FA8P-100)) - @test isequal_interval(interval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548)^2, interval(0x0.0000000000000P+0, 0x6.57CBD208B34ACP-244)) + @test isequal_interval(nthpow(bareinterval(-0xA.12F7783880A78P-124, -0x3.765DF69EE106EP-548), 2), bareinterval(0x0.0000000000000P+0, 0x6.57CBD208B34ACP-244)) - @test isequal_interval(interval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008)^2, interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(nthpow(bareinterval(-0x6.3A58D52FDF844P-896, -0x1.039E2518CF503P-1008), 2), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(interval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740)^2, interval(0x0.0000000000000P+0, 0x8.CC15E342FC8D8P-332)) + @test isequal_interval(nthpow(bareinterval(-0xB.DD3171FDEEC18P-168, +0x1.069E434EE9E0FP-740), 2), bareinterval(0x0.0000000000000P+0, 0x8.CC15E342FC8D8P-332)) - @test isequal_interval(interval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928)^2, interval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) + @test isequal_interval(nthpow(bareinterval(-0x3.CF0053257533AP-776, -0x1.7883A587654E5P-928), 2), bareinterval(0x0.0000000000000P+0, 0x4.0000000000000P-1076)) - @test isequal_interval(interval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28)^2, interval(0x0.0000000000000P+0, 0xD.46C8C24634FC8P-56)) + @test isequal_interval(nthpow(bareinterval(0x1.455801D3D2B63P-704, 0x3.A4C915783D07AP-28), 2), bareinterval(0x0.0000000000000P+0, 0xD.46C8C24634FC8P-56)) - @test isequal_interval(interval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772)^2, interval(0x0.0000000000000P+0, 0x4.264E23607BEA8P-752)) + @test isequal_interval(nthpow(bareinterval(-0x2.097D06F4DE3E2P-376, +0x2.2E7561FD9255EP-772), 2), bareinterval(0x0.0000000000000P+0, 0x4.264E23607BEA8P-752)) - @test isequal_interval(interval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540)^2, interval(0x0.0000000000000P+0, 0x2.3A3F453ECAFB4P-168)) + @test isequal_interval(nthpow(bareinterval(-0x1.7E13DBB66E5A3P-84, -0x6.BC8F45D6A8F48P-540), 2), bareinterval(0x0.0000000000000P+0, 0x2.3A3F453ECAFB4P-168)) - @test isequal_interval(interval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496)^2, interval(0xE.FCF2D2F52B4C0P-992, 0x1.0FE5AD9038BC9P-548)) + @test isequal_interval(nthpow(bareinterval(-0x4.1F50C5F2CDA54P-276, -0x3.DF16F79756422P-496), 2), bareinterval(0xE.FCF2D2F52B4C0P-992, 0x1.0FE5AD9038BC9P-548)) - @test isequal_interval(interval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876)^2, interval(0x0.0000000000000P+0, 0x3.ECDBE373EAC94P-652)) + @test isequal_interval(nthpow(bareinterval(-0x7.ECC4C5EEC4CACP-328, -0x2.E02E1DB7A08F6P-876), 2), bareinterval(0x0.0000000000000P+0, 0x3.ECDBE373EAC94P-652)) - @test isequal_interval(interval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608)^2, interval(0x0.0000000000000P+0, 0x9.29DBB2B42A988P-508)) + @test isequal_interval(nthpow(bareinterval(-0xC.1BC7A4C89D440P-256, +0x2.A7F56252D1D34P-608), 2), bareinterval(0x0.0000000000000P+0, 0x9.29DBB2B42A988P-508)) - @test isequal_interval(interval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432)^2, interval(0xC.FE1B0DE21E568P-860, 0x8.B6138BE0C5B78P-468)) + @test isequal_interval(nthpow(bareinterval(-0xB.CE50D7B2F2868P-236, -0xE.6B08988339B80P-432), 2), bareinterval(0xC.FE1B0DE21E568P-860, 0x8.B6138BE0C5B78P-468)) end diff --git a/test/test_ITF1788/ieee1788-constructors.jl b/test/test_ITF1788/ieee1788-constructors.jl index b94d06473..ca46f98ca 100755 --- a/test/test_ITF1788/ieee1788-constructors.jl +++ b/test/test_ITF1788/ieee1788-constructors.jl @@ -1,113 +1,113 @@ @testset "IEEE1788.a" begin - @test isequal_interval(interval(-Inf, Inf), entireinterval()) + @test isequal_interval(bareinterval(-Inf, Inf), entireinterval(BareInterval{Float64})) end @testset "IEEE1788.b" begin - @test isequal_interval(parse(Interval{Float64}, "[1.2345]"), interval(0x1.3C083126E978DP+0, 0x1.3C083126E978EP+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.2345]"), bareinterval(0x1.3C083126E978DP+0, 0x1.3C083126E978EP+0)) - @test isequal_interval(parse(Interval{Float64}, "[1,+infinity]"), interval(1.0, Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[1,+infinity]"), bareinterval(1.0, Inf)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[1,1e3]_com"), DecoratedInterval(interval(1.0, 1000.0), com)) + @test isequal_interval(parse(Interval{Float64}, "[1,1e3]_com"), Interval(bareinterval(1.0, 1000.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[1,1E3]_COM"), DecoratedInterval(interval(1.0, 1000.0), com)) + @test isequal_interval(parse(Interval{Float64}, "[1,1E3]_COM"), Interval(bareinterval(1.0, 1000.0), IntervalArithmetic.com)) end @testset "IEEE1788.c" begin - @test isequal_interval(parse(Interval{Float64}, "[1.e-3, 1.1e-3]"), interval(0x4.189374BC6A7ECP-12, 0x4.816F0068DB8BCP-12)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.e-3, 1.1e-3]"), bareinterval(0x4.189374BC6A7ECP-12, 0x4.816F0068DB8BCP-12)) - @test isequal_interval(parse(Interval{Float64}, "[-0x1.3p-1, 2/3]"), interval(-0x9.8000000000000P-4, +0xA.AAAAAAAAAAAB0P-4)) + @test isequal_interval(parse(BareInterval{Float64}, "[-0x1.3p-1, 2/3]"), bareinterval(-0x9.8000000000000P-4, +0xA.AAAAAAAAAAAB0P-4)) - @test isequal_interval(parse(Interval{Float64}, "[3.56]"), interval(0x3.8F5C28F5C28F4P+0, 0x3.8F5C28F5C28F6P+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[3.56]"), bareinterval(0x3.8F5C28F5C28F4P+0, 0x3.8F5C28F5C28F6P+0)) - @test isequal_interval(parse(Interval{Float64}, "3.56?1"), interval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.56?1"), bareinterval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0)) - @test isequal_interval(parse(Interval{Float64}, "3.56?1e2"), interval(355.0, 357.0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.56?1e2"), bareinterval(355.0, 357.0)) - @test isequal_interval(parse(Interval{Float64}, "3.560?2"), interval(0x3.8ED916872B020P+0, 0x3.8FDF3B645A1CCP+0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.560?2"), bareinterval(0x3.8ED916872B020P+0, 0x3.8FDF3B645A1CCP+0)) - @test isequal_interval(parse(Interval{Float64}, "3.56?"), interval(0x3.8E147AE147AE0P+0, 0x3.90A3D70A3D70CP+0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.56?"), bareinterval(0x3.8E147AE147AE0P+0, 0x3.90A3D70A3D70CP+0)) - @test isequal_interval(parse(Interval{Float64}, "3.560?2u"), interval(0x3.8F5C28F5C28F4P+0, 0x3.8FDF3B645A1CCP+0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.560?2u"), bareinterval(0x3.8F5C28F5C28F4P+0, 0x3.8FDF3B645A1CCP+0)) - @test isequal_interval(parse(Interval{Float64}, "-10?"), interval(-10.5, -9.5)) + @test isequal_interval(parse(BareInterval{Float64}, "-10?"), bareinterval(-10.5, -9.5)) - @test isequal_interval(parse(Interval{Float64}, "-10?u"), interval(-10.0, -9.5)) + @test isequal_interval(parse(BareInterval{Float64}, "-10?u"), bareinterval(-10.0, -9.5)) - @test isequal_interval(parse(Interval{Float64}, "-10?12"), interval(-22.0, 2.0)) + @test isequal_interval(parse(BareInterval{Float64}, "-10?12"), bareinterval(-22.0, 2.0)) end @testset "IEEE1788.d" begin - @test isequal_interval(parse(Interval{Float64}, "[1.234e5,Inf]"), interval(123400.0, Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.234e5,Inf]"), bareinterval(123400.0, Inf)) - @test isequal_interval(parse(Interval{Float64}, "3.1416?1"), interval(0x3.24395810624DCP+0, 0x3.24467381D7DC0P+0)) + @test isequal_interval(parse(BareInterval{Float64}, "3.1416?1"), bareinterval(0x3.24395810624DCP+0, 0x3.24467381D7DC0P+0)) - @test isequal_interval(parse(Interval{Float64}, "[Empty]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[Empty]"), emptyinterval(BareInterval{Float64})) end @testset "IEEE1788.e" begin - @test isnai(DecoratedInterval(2,1)) + @test isnai(interval(2,1)) end @testset "IEEE1788.e" begin - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ ]"), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ ]"), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[entire]"), DecoratedInterval(interval(-Inf, +Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "[entire]"), Interval(bareinterval(-Inf, +Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[1.e-3, 1.1e-3]"), DecoratedInterval(interval(0x4.189374BC6A7ECP-12, 0x4.816F0068DB8BCP-12), com)) + @test isequal_interval(parse(Interval{Float64}, "[1.e-3, 1.1e-3]"), Interval(bareinterval(0x4.189374BC6A7ECP-12, 0x4.816F0068DB8BCP-12), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-Inf, 2/3]"), DecoratedInterval(interval(-Inf, +0xA.AAAAAAAAAAAB0P-4), dac)) + @test isequal_interval(parse(Interval{Float64}, "[-Inf, 2/3]"), Interval(bareinterval(-Inf, +0xA.AAAAAAAAAAAB0P-4), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[0x1.3p-1,]"), DecoratedInterval(interval(0x1.3p-1, Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "[0x1.3p-1,]"), Interval(bareinterval(0x1.3p-1, Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[,]"), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(parse(Interval{Float64}, "[,]"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.56?1"), DecoratedInterval(interval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0), com)) + @test isequal_interval(parse(Interval{Float64}, "3.56?1"), Interval(bareinterval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.56?1e2"), DecoratedInterval(interval(355.0, 357.0), com)) + @test isequal_interval(parse(Interval{Float64}, "3.56?1e2"), Interval(bareinterval(355.0, 357.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.560?2"), DecoratedInterval(interval(0x3.8ED916872B020P+0, 0x3.8FDF3B645A1CCP+0), com)) + @test isequal_interval(parse(Interval{Float64}, "3.560?2"), Interval(bareinterval(0x3.8ED916872B020P+0, 0x3.8FDF3B645A1CCP+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.56?"), DecoratedInterval(interval(0x3.8E147AE147AE0P+0, 0x3.90A3D70A3D70CP+0), com)) + @test isequal_interval(parse(Interval{Float64}, "3.56?"), Interval(bareinterval(0x3.8E147AE147AE0P+0, 0x3.90A3D70A3D70CP+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.560?2u"), DecoratedInterval(interval(0x3.8F5C28F5C28F4P+0, 0x3.8FDF3B645A1CCP+0), com)) + @test isequal_interval(parse(Interval{Float64}, "3.560?2u"), Interval(bareinterval(0x3.8F5C28F5C28F4P+0, 0x3.8FDF3B645A1CCP+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "-10?"), DecoratedInterval(interval(-10.5, -9.5), com)) + @test isequal_interval(parse(Interval{Float64}, "-10?"), Interval(bareinterval(-10.5, -9.5), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "-10?u"), DecoratedInterval(interval(-10.0, -9.5), com)) + @test isequal_interval(parse(Interval{Float64}, "-10?u"), Interval(bareinterval(-10.0, -9.5), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "-10?12"), DecoratedInterval(interval(-22.0, 2.0), com)) + @test isequal_interval(parse(Interval{Float64}, "-10?12"), Interval(bareinterval(-22.0, 2.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "-10??u"), DecoratedInterval(interval(-10.0, Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "-10??u"), Interval(bareinterval(-10.0, Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "-10??"), DecoratedInterval(interval(-Inf, Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "-10??"), Interval(bareinterval(-Inf, Inf), IntervalArithmetic.dac)) - @test isnai(parse(DecoratedInterval{Float64}, "[nai]")) + @test isnai(parse(Interval{Float64}, "[nai]")) - @test isequal_interval(parse(DecoratedInterval{Float64}, "3.56?1_def"), DecoratedInterval(interval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0), def)) + @test isequal_interval(parse(Interval{Float64}, "3.56?1_def"), Interval(bareinterval(0x3.8CCCCCCCCCCCCP+0, 0x3.91EB851EB8520P+0), IntervalArithmetic.def)) end @testset "IEEE1788.f" begin - @test isequal_interval(parse(Interval{Float64}, "[]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[empty]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[empty]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ empty ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ empty ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[,]"), entireinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[,]"), entireinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ entire ]"), entireinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ entire ]"), entireinterval(BareInterval{Float64})) end diff --git a/test/test_ITF1788/ieee1788-exceptions.jl b/test/test_ITF1788/ieee1788-exceptions.jl index 70af86c65..b4c7c5486 100755 --- a/test/test_ITF1788/ieee1788-exceptions.jl +++ b/test/test_ITF1788/ieee1788-exceptions.jl @@ -1,11 +1,11 @@ @testset "exceptions" begin - @test isequal_interval(I"[+infinity]", emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[+infinity]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(interval(+Inf, -Inf), emptyinterval()) + @test isequal_interval(bareinterval(+Inf, -Inf), emptyinterval(BareInterval{Float64})) - @test_broken isequal_interval(interval(nai()), emptyinterval()) + @test isequal_interval(bareinterval(nai()), emptyinterval(BareInterval{Float64})) - @test isequal_interval(I"[1.0000000000000001, 1.0000000000000002]", interval(1.0, 0x1.0000000000001p+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.0000000000000001, 1.0000000000000002]"), bareinterval(1.0, 0x1.0000000000001p+0)) end diff --git a/test/test_ITF1788/libieeep1788_bool.jl b/test/test_ITF1788/libieeep1788_bool.jl index 0a1b5c464..42c71d030 100644 --- a/test/test_ITF1788/libieeep1788_bool.jl +++ b/test/test_ITF1788/libieeep1788_bool.jl @@ -1,32 +1,32 @@ @testset "minimal_is_empty_test" begin - @test isempty_interval(emptyinterval()) == true + @test isempty_interval(emptyinterval(BareInterval{Float64})) == true - @test isempty_interval(interval(-Inf,+Inf)) == false + @test isempty_interval(bareinterval(-Inf,+Inf)) == false - @test isempty_interval(interval(1.0,2.0)) == false + @test isempty_interval(bareinterval(1.0,2.0)) == false - @test isempty_interval(interval(-1.0,2.0)) == false + @test isempty_interval(bareinterval(-1.0,2.0)) == false - @test isempty_interval(interval(-3.0,-2.0)) == false + @test isempty_interval(bareinterval(-3.0,-2.0)) == false - @test isempty_interval(interval(-Inf,2.0)) == false + @test isempty_interval(bareinterval(-Inf,2.0)) == false - @test isempty_interval(interval(-Inf,0.0)) == false + @test isempty_interval(bareinterval(-Inf,0.0)) == false - @test isempty_interval(interval(-Inf,-0.0)) == false + @test isempty_interval(bareinterval(-Inf,-0.0)) == false - @test isempty_interval(interval(0.0,Inf)) == false + @test isempty_interval(bareinterval(0.0,Inf)) == false - @test isempty_interval(interval(-0.0,Inf)) == false + @test isempty_interval(bareinterval(-0.0,Inf)) == false - @test isempty_interval(interval(-0.0,0.0)) == false + @test isempty_interval(bareinterval(-0.0,0.0)) == false - @test isempty_interval(interval(0.0,-0.0)) == false + @test isempty_interval(bareinterval(0.0,-0.0)) == false - @test isempty_interval(interval(0.0,0.0)) == false + @test isempty_interval(bareinterval(0.0,0.0)) == false - @test isempty_interval(interval(-0.0,-0.0)) == false + @test isempty_interval(bareinterval(-0.0,-0.0)) == false end @@ -34,65 +34,65 @@ end @test isempty_interval(nai()) == false - @test isempty_interval(DecoratedInterval(emptyinterval(), trv)) == true + @test isempty_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isempty_interval(DecoratedInterval(interval(-Inf,+Inf), def)) == false + @test isempty_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.def)) == false - @test isempty_interval(DecoratedInterval(interval(1.0,2.0), com)) == false + @test isempty_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) == false - @test isempty_interval(DecoratedInterval(interval(-1.0,2.0), trv)) == false + @test isempty_interval(Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(-3.0,-2.0), dac)) == false + @test isempty_interval(Interval(bareinterval(-3.0,-2.0), IntervalArithmetic.dac)) == false - @test isempty_interval(DecoratedInterval(interval(-Inf,2.0), trv)) == false + @test isempty_interval(Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(-Inf,0.0), trv)) == false + @test isempty_interval(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(-Inf,-0.0), trv)) == false + @test isempty_interval(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(0.0,Inf), def)) == false + @test isempty_interval(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def)) == false - @test isempty_interval(DecoratedInterval(interval(-0.0,Inf), trv)) == false + @test isempty_interval(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(-0.0,0.0), com)) == false + @test isempty_interval(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.com)) == false - @test isempty_interval(DecoratedInterval(interval(0.0,-0.0), trv)) == false + @test isempty_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(0.0,0.0), trv)) == false + @test isempty_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == false - @test isempty_interval(DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test isempty_interval(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == false end @testset "minimal_is_entire_test" begin - @test isentire_interval(emptyinterval()) == false + @test isentire_interval(emptyinterval(BareInterval{Float64})) == false - @test isentire_interval(interval(-Inf,+Inf)) == true + @test isentire_interval(bareinterval(-Inf,+Inf)) == true - @test isentire_interval(interval(1.0,2.0)) == false + @test isentire_interval(bareinterval(1.0,2.0)) == false - @test isentire_interval(interval(-1.0,2.0)) == false + @test isentire_interval(bareinterval(-1.0,2.0)) == false - @test isentire_interval(interval(-3.0,-2.0)) == false + @test isentire_interval(bareinterval(-3.0,-2.0)) == false - @test isentire_interval(interval(-Inf,2.0)) == false + @test isentire_interval(bareinterval(-Inf,2.0)) == false - @test isentire_interval(interval(-Inf,0.0)) == false + @test isentire_interval(bareinterval(-Inf,0.0)) == false - @test isentire_interval(interval(-Inf,-0.0)) == false + @test isentire_interval(bareinterval(-Inf,-0.0)) == false - @test isentire_interval(interval(0.0,Inf)) == false + @test isentire_interval(bareinterval(0.0,Inf)) == false - @test isentire_interval(interval(-0.0,Inf)) == false + @test isentire_interval(bareinterval(-0.0,Inf)) == false - @test isentire_interval(interval(-0.0,0.0)) == false + @test isentire_interval(bareinterval(-0.0,0.0)) == false - @test isentire_interval(interval(0.0,-0.0)) == false + @test isentire_interval(bareinterval(0.0,-0.0)) == false - @test isentire_interval(interval(0.0,0.0)) == false + @test isentire_interval(bareinterval(0.0,0.0)) == false - @test isentire_interval(interval(-0.0,-0.0)) == false + @test isentire_interval(bareinterval(-0.0,-0.0)) == false end @@ -100,37 +100,37 @@ end @test isentire_interval(nai()) == false - @test isentire_interval(DecoratedInterval(emptyinterval(), trv)) == false + @test isentire_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isentire_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isentire_interval(DecoratedInterval(interval(-Inf,+Inf), def)) == true + @test isentire_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.def)) == true - @test isentire_interval(DecoratedInterval(interval(-Inf,+Inf), dac)) == true + @test isentire_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.dac)) == true - @test isentire_interval(DecoratedInterval(interval(1.0,2.0), com)) == false + @test isentire_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) == false - @test isentire_interval(DecoratedInterval(interval(-1.0,2.0), trv)) == false + @test isentire_interval(Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-3.0,-2.0), dac)) == false + @test isentire_interval(Interval(bareinterval(-3.0,-2.0), IntervalArithmetic.dac)) == false - @test isentire_interval(DecoratedInterval(interval(-Inf,2.0), trv)) == false + @test isentire_interval(Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-Inf,0.0), trv)) == false + @test isentire_interval(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-Inf,-0.0), trv)) == false + @test isentire_interval(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(0.0,Inf), def)) == false + @test isentire_interval(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def)) == false - @test isentire_interval(DecoratedInterval(interval(-0.0,Inf), trv)) == false + @test isentire_interval(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-0.0,0.0), com)) == false + @test isentire_interval(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.com)) == false - @test isentire_interval(DecoratedInterval(interval(0.0,-0.0), trv)) == false + @test isentire_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(0.0,0.0), trv)) == false + @test isentire_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == false - @test isentire_interval(DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test isentire_interval(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == false end @@ -138,169 +138,169 @@ end @test isnai(nai()) == true - @test isnai(DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isnai(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-Inf,+Inf), def)) == false + @test isnai(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.def)) == false - @test isnai(DecoratedInterval(interval(-Inf,+Inf), dac)) == false + @test isnai(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.dac)) == false - @test isnai(DecoratedInterval(interval(1.0,2.0), com)) == false + @test isnai(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) == false - @test isnai(DecoratedInterval(interval(-1.0,2.0), trv)) == false + @test isnai(Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-3.0,-2.0), dac)) == false + @test isnai(Interval(bareinterval(-3.0,-2.0), IntervalArithmetic.dac)) == false - @test isnai(DecoratedInterval(interval(-Inf,2.0), trv)) == false + @test isnai(Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-Inf,0.0), trv)) == false + @test isnai(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-Inf,-0.0), trv)) == false + @test isnai(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(0.0,Inf), def)) == false + @test isnai(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def)) == false - @test isnai(DecoratedInterval(interval(-0.0,Inf), trv)) == false + @test isnai(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-0.0,0.0), com)) == false + @test isnai(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.com)) == false - @test isnai(DecoratedInterval(interval(0.0,-0.0), trv)) == false + @test isnai(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(0.0,0.0), trv)) == false + @test isnai(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == false - @test isnai(DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test isnai(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == false end @testset "minimal_equal_test" begin - @test isequal_interval(interval(1.0,2.0), interval(1.0,2.0)) == true + @test isequal_interval(bareinterval(1.0,2.0), bareinterval(1.0,2.0)) == true - @test isequal_interval(interval(1.0,2.1), interval(1.0,2.0)) == false + @test isequal_interval(bareinterval(1.0,2.1), bareinterval(1.0,2.0)) == false - @test isequal_interval(emptyinterval(), emptyinterval()) == true + @test isequal_interval(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test isequal_interval(emptyinterval(), interval(1.0,2.0)) == false + @test isequal_interval(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)) == false - @test isequal_interval(interval(-Inf,+Inf), interval(-Inf,+Inf)) == true + @test isequal_interval(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == true - @test isequal_interval(interval(1.0,2.4), interval(-Inf,+Inf)) == false + @test isequal_interval(bareinterval(1.0,2.4), bareinterval(-Inf,+Inf)) == false - @test isequal_interval(interval(1.0,Inf), interval(1.0,Inf)) == true + @test isequal_interval(bareinterval(1.0,Inf), bareinterval(1.0,Inf)) == true - @test isequal_interval(interval(1.0,2.4), interval(1.0,Inf)) == false + @test isequal_interval(bareinterval(1.0,2.4), bareinterval(1.0,Inf)) == false - @test isequal_interval(interval(-Inf,2.0), interval(-Inf,2.0)) == true + @test isequal_interval(bareinterval(-Inf,2.0), bareinterval(-Inf,2.0)) == true - @test isequal_interval(interval(-Inf,2.4), interval(-Inf,2.0)) == false + @test isequal_interval(bareinterval(-Inf,2.4), bareinterval(-Inf,2.0)) == false - @test isequal_interval(interval(-2.0,0.0), interval(-2.0,0.0)) == true + @test isequal_interval(bareinterval(-2.0,0.0), bareinterval(-2.0,0.0)) == true - @test isequal_interval(interval(-0.0,2.0), interval(0.0,2.0)) == true + @test isequal_interval(bareinterval(-0.0,2.0), bareinterval(0.0,2.0)) == true - @test isequal_interval(interval(-0.0,-0.0), interval(0.0,0.0)) == true + @test isequal_interval(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)) == true - @test isequal_interval(interval(-0.0,0.0), interval(0.0,0.0)) == true + @test isequal_interval(bareinterval(-0.0,0.0), bareinterval(0.0,0.0)) == true - @test isequal_interval(interval(0.0,-0.0), interval(0.0,0.0)) == true + @test isequal_interval(bareinterval(0.0,-0.0), bareinterval(0.0,0.0)) == true end @testset "minimal_equal_dec_test" begin - @test isequal_interval(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(1.0,2.0), trv)) == true + @test isequal_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(1.0,2.1), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isequal_interval(Interval(bareinterval(1.0,2.1), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isequal_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(emptyinterval(), trv), nai()) == false + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), nai()) == false - @test isequal_interval(nai(), DecoratedInterval(emptyinterval(), trv)) == false + @test isequal_interval(nai(), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test isequal_interval(nai(), nai()) == false - @test isequal_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isequal_interval(nai(), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isequal_interval(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isequal_interval(DecoratedInterval(interval(-Inf,+Inf), def), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isequal_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.def), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(1.0,2.4), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isequal_interval(Interval(bareinterval(1.0,2.4), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isequal_interval(DecoratedInterval(interval(1.0,Inf), trv), DecoratedInterval(interval(1.0,Inf), trv)) == true + @test isequal_interval(Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(1.0,2.4), def), DecoratedInterval(interval(1.0,Inf), trv)) == false + @test isequal_interval(Interval(bareinterval(1.0,2.4), IntervalArithmetic.def), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) == false - @test isequal_interval(DecoratedInterval(interval(-Inf,2.0), trv), DecoratedInterval(interval(-Inf,2.0), trv)) == true + @test isequal_interval(Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(-Inf,2.4), def), DecoratedInterval(interval(-Inf,2.0), trv)) == false + @test isequal_interval(Interval(bareinterval(-Inf,2.4), IntervalArithmetic.def), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) == false - @test isequal_interval(DecoratedInterval(interval(-2.0,0.0), trv), DecoratedInterval(interval(-2.0,0.0), trv)) == true + @test isequal_interval(Interval(bareinterval(-2.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0,0.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(-0.0,2.0), def), DecoratedInterval(interval(0.0,2.0), trv)) == true + @test isequal_interval(Interval(bareinterval(-0.0,2.0), IntervalArithmetic.def), Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(-0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test isequal_interval(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(-0.0,0.0), def), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test isequal_interval(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.def), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test isequal_interval(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test isequal_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true end @testset "minimal_subset_test" begin - @test issubset_interval(emptyinterval(), emptyinterval()) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test issubset_interval(emptyinterval(), interval(0.0,4.0)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(0.0,4.0)) == true - @test issubset_interval(emptyinterval(), interval(-0.0,4.0)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,4.0)) == true - @test issubset_interval(emptyinterval(), interval(-0.1,1.0)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-0.1,1.0)) == true - @test issubset_interval(emptyinterval(), interval(-0.1,0.0)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-0.1,0.0)) == true - @test issubset_interval(emptyinterval(), interval(-0.1,-0.0)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-0.1,-0.0)) == true - @test issubset_interval(emptyinterval(), interval(-Inf,+Inf)) == true + @test issubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,+Inf)) == true - @test issubset_interval(interval(0.0,4.0), emptyinterval()) == false + @test issubset_interval(bareinterval(0.0,4.0), emptyinterval(BareInterval{Float64})) == false - @test issubset_interval(interval(-0.0,4.0), emptyinterval()) == false + @test issubset_interval(bareinterval(-0.0,4.0), emptyinterval(BareInterval{Float64})) == false - @test issubset_interval(interval(-0.1,1.0), emptyinterval()) == false + @test issubset_interval(bareinterval(-0.1,1.0), emptyinterval(BareInterval{Float64})) == false - @test issubset_interval(interval(-Inf,+Inf), emptyinterval()) == false + @test issubset_interval(bareinterval(-Inf,+Inf), emptyinterval(BareInterval{Float64})) == false - @test issubset_interval(interval(0.0,4.0), interval(-Inf,+Inf)) == true + @test issubset_interval(bareinterval(0.0,4.0), bareinterval(-Inf,+Inf)) == true - @test issubset_interval(interval(-0.0,4.0), interval(-Inf,+Inf)) == true + @test issubset_interval(bareinterval(-0.0,4.0), bareinterval(-Inf,+Inf)) == true - @test issubset_interval(interval(-0.1,1.0), interval(-Inf,+Inf)) == true + @test issubset_interval(bareinterval(-0.1,1.0), bareinterval(-Inf,+Inf)) == true - @test issubset_interval(interval(-Inf,+Inf), interval(-Inf,+Inf)) == true + @test issubset_interval(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == true - @test issubset_interval(interval(1.0,2.0), interval(1.0,2.0)) == true + @test issubset_interval(bareinterval(1.0,2.0), bareinterval(1.0,2.0)) == true - @test issubset_interval(interval(1.0,2.0), interval(0.0,4.0)) == true + @test issubset_interval(bareinterval(1.0,2.0), bareinterval(0.0,4.0)) == true - @test issubset_interval(interval(1.0,2.0), interval(-0.0,4.0)) == true + @test issubset_interval(bareinterval(1.0,2.0), bareinterval(-0.0,4.0)) == true - @test issubset_interval(interval(0.1,0.2), interval(0.0,4.0)) == true + @test issubset_interval(bareinterval(0.1,0.2), bareinterval(0.0,4.0)) == true - @test issubset_interval(interval(0.1,0.2), interval(-0.0,4.0)) == true + @test issubset_interval(bareinterval(0.1,0.2), bareinterval(-0.0,4.0)) == true - @test issubset_interval(interval(-0.1,-0.1), interval(-4.0, 3.4)) == true + @test issubset_interval(bareinterval(-0.1,-0.1), bareinterval(-4.0, 3.4)) == true - @test issubset_interval(interval(0.0,0.0), interval(-0.0,-0.0)) == true + @test issubset_interval(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)) == true - @test issubset_interval(interval(-0.0,-0.0), interval(0.0,0.0)) == true + @test issubset_interval(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)) == true - @test issubset_interval(interval(-0.0,0.0), interval(0.0,0.0)) == true + @test issubset_interval(bareinterval(-0.0,0.0), bareinterval(0.0,0.0)) == true - @test issubset_interval(interval(-0.0,0.0), interval(0.0,-0.0)) == true + @test issubset_interval(bareinterval(-0.0,0.0), bareinterval(0.0,-0.0)) == true - @test issubset_interval(interval(0.0,-0.0), interval(0.0,0.0)) == true + @test issubset_interval(bareinterval(0.0,-0.0), bareinterval(0.0,0.0)) == true - @test issubset_interval(interval(0.0,-0.0), interval(-0.0,0.0)) == true + @test issubset_interval(bareinterval(0.0,-0.0), bareinterval(-0.0,0.0)) == true end @@ -308,117 +308,117 @@ end @test issubset_interval(nai(), nai()) == false - @test issubset_interval(nai(), DecoratedInterval(emptyinterval(), trv)) == false + @test issubset_interval(nai(), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test issubset_interval(nai(), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test issubset_interval(nai(), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0,4.0), trv)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.0,4.0), def)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.0,4.0), IntervalArithmetic.def)) == true - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.1,1.0), trv)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.1,0.0), trv)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.1,0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.1,-0.0), trv)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.1,-0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test issubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(0.0,4.0), trv), DecoratedInterval(emptyinterval(), trv)) == false + @test issubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test issubset_interval(DecoratedInterval(interval(-0.0,4.0), def), DecoratedInterval(emptyinterval(), trv)) == false + @test issubset_interval(Interval(bareinterval(-0.0,4.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test issubset_interval(DecoratedInterval(interval(-0.1,1.0), trv), DecoratedInterval(emptyinterval(), trv)) == false + @test issubset_interval(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test issubset_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(emptyinterval(), trv)) == false + @test issubset_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test issubset_interval(DecoratedInterval(interval(0.0,4.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test issubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(-0.0,4.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test issubset_interval(Interval(bareinterval(-0.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(-0.1,1.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test issubset_interval(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test issubset_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(1.0,2.0), trv)) == true + @test issubset_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(0.0,4.0), trv)) == true + @test issubset_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(-0.0,4.0), def)) == true + @test issubset_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(-0.0,4.0), IntervalArithmetic.def)) == true - @test issubset_interval(DecoratedInterval(interval(0.1,0.2), trv), DecoratedInterval(interval(0.0,4.0), trv)) == true + @test issubset_interval(Interval(bareinterval(0.1,0.2), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(0.1,0.2), trv), DecoratedInterval(interval(-0.0,4.0), def)) == true + @test issubset_interval(Interval(bareinterval(0.1,0.2), IntervalArithmetic.trv), Interval(bareinterval(-0.0,4.0), IntervalArithmetic.def)) == true - @test issubset_interval(DecoratedInterval(interval(-0.1,-0.1), trv), DecoratedInterval(interval(-4.0, 3.4), trv)) == true + @test issubset_interval(Interval(bareinterval(-0.1,-0.1), IntervalArithmetic.trv), Interval(bareinterval(-4.0, 3.4), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(0.0,0.0), trv), DecoratedInterval(interval(-0.0,-0.0), trv)) == true + @test issubset_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(-0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), def)) == true + @test issubset_interval(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.def)) == true - @test issubset_interval(DecoratedInterval(interval(-0.0,0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test issubset_interval(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(-0.0,0.0), trv), DecoratedInterval(interval(0.0,-0.0), trv)) == true + @test issubset_interval(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(0.0,-0.0), def), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test issubset_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.def), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test issubset_interval(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(-0.0,0.0), trv)) == true + @test issubset_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv)) == true end @testset "minimal_less_test" begin - @test isweakless(emptyinterval(), emptyinterval()) == true + @test isweakless(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test isweakless(interval(1.0,2.0), emptyinterval()) == false + @test isweakless(bareinterval(1.0,2.0), emptyinterval(BareInterval{Float64})) == false - @test isweakless(emptyinterval(), interval(1.0,2.0)) == false + @test isweakless(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)) == false - @test isweakless(interval(-Inf,+Inf), interval(-Inf,+Inf)) == true + @test isweakless(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == true - @test isweakless(interval(1.0,2.0), interval(-Inf,+Inf)) == false + @test isweakless(bareinterval(1.0,2.0), bareinterval(-Inf,+Inf)) == false - @test isweakless(interval(0.0,2.0), interval(-Inf,+Inf)) == false + @test isweakless(bareinterval(0.0,2.0), bareinterval(-Inf,+Inf)) == false - @test isweakless(interval(-0.0,2.0), interval(-Inf,+Inf)) == false + @test isweakless(bareinterval(-0.0,2.0), bareinterval(-Inf,+Inf)) == false - @test isweakless(interval(-Inf,+Inf), interval(1.0,2.0)) == false + @test isweakless(bareinterval(-Inf,+Inf), bareinterval(1.0,2.0)) == false - @test isweakless(interval(-Inf,+Inf), interval(0.0,2.0)) == false + @test isweakless(bareinterval(-Inf,+Inf), bareinterval(0.0,2.0)) == false - @test isweakless(interval(-Inf,+Inf), interval(-0.0,2.0)) == false + @test isweakless(bareinterval(-Inf,+Inf), bareinterval(-0.0,2.0)) == false - @test isweakless(interval(0.0,2.0), interval(0.0,2.0)) == true + @test isweakless(bareinterval(0.0,2.0), bareinterval(0.0,2.0)) == true - @test isweakless(interval(0.0,2.0), interval(-0.0,2.0)) == true + @test isweakless(bareinterval(0.0,2.0), bareinterval(-0.0,2.0)) == true - @test isweakless(interval(0.0,2.0), interval(1.0,2.0)) == true + @test isweakless(bareinterval(0.0,2.0), bareinterval(1.0,2.0)) == true - @test isweakless(interval(-0.0,2.0), interval(1.0,2.0)) == true + @test isweakless(bareinterval(-0.0,2.0), bareinterval(1.0,2.0)) == true - @test isweakless(interval(1.0,2.0), interval(1.0,2.0)) == true + @test isweakless(bareinterval(1.0,2.0), bareinterval(1.0,2.0)) == true - @test isweakless(interval(1.0,2.0), interval(3.0,4.0)) == true + @test isweakless(bareinterval(1.0,2.0), bareinterval(3.0,4.0)) == true - @test isweakless(interval(1.0,3.5), interval(3.0,4.0)) == true + @test isweakless(bareinterval(1.0,3.5), bareinterval(3.0,4.0)) == true - @test isweakless(interval(1.0,4.0), interval(3.0,4.0)) == true + @test isweakless(bareinterval(1.0,4.0), bareinterval(3.0,4.0)) == true - @test isweakless(interval(-2.0,-1.0), interval(-2.0,-1.0)) == true + @test isweakless(bareinterval(-2.0,-1.0), bareinterval(-2.0,-1.0)) == true - @test isweakless(interval(-3.0,-1.5), interval(-2.0,-1.0)) == true + @test isweakless(bareinterval(-3.0,-1.5), bareinterval(-2.0,-1.0)) == true - @test isweakless(interval(0.0,0.0), interval(-0.0,-0.0)) == true + @test isweakless(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)) == true - @test isweakless(interval(-0.0,-0.0), interval(0.0,0.0)) == true + @test isweakless(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)) == true - @test isweakless(interval(-0.0,0.0), interval(0.0,0.0)) == true + @test isweakless(bareinterval(-0.0,0.0), bareinterval(0.0,0.0)) == true - @test isweakless(interval(-0.0,0.0), interval(0.0,-0.0)) == true + @test isweakless(bareinterval(-0.0,0.0), bareinterval(0.0,-0.0)) == true - @test isweakless(interval(0.0,-0.0), interval(0.0,0.0)) == true + @test isweakless(bareinterval(0.0,-0.0), bareinterval(0.0,0.0)) == true - @test isweakless(interval(0.0,-0.0), interval(-0.0,0.0)) == true + @test isweakless(bareinterval(0.0,-0.0), bareinterval(-0.0,0.0)) == true end @@ -426,199 +426,199 @@ end @test isweakless(nai(), nai()) == false - @test isweakless(DecoratedInterval(emptyinterval(), trv), nai()) == false + @test isweakless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), nai()) == false - @test isweakless(DecoratedInterval(interval(1.0,2.0), trv), nai()) == false + @test isweakless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), nai()) == false - @test isweakless(nai(), DecoratedInterval(interval(1.0,2.0), def)) == false + @test isweakless(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) == false - @test isweakless(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isweakless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)) == false + @test isweakless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isweakless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isweakless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isweakless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(0.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isweakless(Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(-0.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isweakless(Interval(bareinterval(-0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isweakless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(0.0,2.0), def)) == false + @test isweakless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(0.0,2.0), IntervalArithmetic.def)) == false - @test isweakless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-0.0,2.0), trv)) == false + @test isweakless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-0.0,2.0), IntervalArithmetic.trv)) == false - @test isweakless(DecoratedInterval(interval(0.0,2.0), trv), DecoratedInterval(interval(0.0,2.0), trv)) == true + @test isweakless(Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(0.0,2.0), trv), DecoratedInterval(interval(-0.0,2.0), trv)) == true + @test isweakless(Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,2.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(0.0,2.0), def), DecoratedInterval(interval(1.0,2.0), def)) == true + @test isweakless(Interval(bareinterval(0.0,2.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) == true - @test isweakless(DecoratedInterval(interval(-0.0,2.0), trv), DecoratedInterval(interval(1.0,2.0), trv)) == true + @test isweakless(Interval(bareinterval(-0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(1.0,2.0), trv)) == true + @test isweakless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(3.0,4.0), def)) == true + @test isweakless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == true - @test isweakless(DecoratedInterval(interval(1.0,3.5), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test isweakless(Interval(bareinterval(1.0,3.5), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(1.0,4.0), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test isweakless(Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(-2.0,-1.0), trv), DecoratedInterval(interval(-2.0,-1.0), trv)) == true + @test isweakless(Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(-3.0,-1.5), trv), DecoratedInterval(interval(-2.0,-1.0), trv)) == true + @test isweakless(Interval(bareinterval(-3.0,-1.5), IntervalArithmetic.trv), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(0.0,0.0), trv), DecoratedInterval(interval(-0.0,-0.0), trv)) == true + @test isweakless(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(-0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), def)) == true + @test isweakless(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.def)) == true - @test isweakless(DecoratedInterval(interval(-0.0,0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test isweakless(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(-0.0,0.0), trv), DecoratedInterval(interval(0.0,-0.0), trv)) == true + @test isweakless(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(0.0,-0.0), def), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test isweakless(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.def), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test isweakless(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(-0.0,0.0), trv)) == true + @test isweakless(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv)) == true end @testset "minimal_precedes_test" begin - @test precedes(emptyinterval(), interval(3.0,4.0)) == true + @test precedes(emptyinterval(BareInterval{Float64}), bareinterval(3.0,4.0)) == true - @test precedes(interval(3.0,4.0), emptyinterval()) == true + @test precedes(bareinterval(3.0,4.0), emptyinterval(BareInterval{Float64})) == true - @test precedes(emptyinterval(), emptyinterval()) == true + @test precedes(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test precedes(interval(1.0,2.0), interval(-Inf,+Inf)) == false + @test precedes(bareinterval(1.0,2.0), bareinterval(-Inf,+Inf)) == false - @test precedes(interval(0.0,2.0), interval(-Inf,+Inf)) == false + @test precedes(bareinterval(0.0,2.0), bareinterval(-Inf,+Inf)) == false - @test precedes(interval(-0.0,2.0), interval(-Inf,+Inf)) == false + @test precedes(bareinterval(-0.0,2.0), bareinterval(-Inf,+Inf)) == false - @test precedes(interval(-Inf,+Inf), interval(1.0,2.0)) == false + @test precedes(bareinterval(-Inf,+Inf), bareinterval(1.0,2.0)) == false - @test precedes(interval(-Inf,+Inf), interval(-Inf,+Inf)) == false + @test precedes(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == false - @test precedes(interval(1.0,2.0), interval(3.0,4.0)) == true + @test precedes(bareinterval(1.0,2.0), bareinterval(3.0,4.0)) == true - @test precedes(interval(1.0,3.0), interval(3.0,4.0)) == true + @test precedes(bareinterval(1.0,3.0), bareinterval(3.0,4.0)) == true - @test precedes(interval(-3.0, -1.0), interval(-1.0,0.0)) == true + @test precedes(bareinterval(-3.0, -1.0), bareinterval(-1.0,0.0)) == true - @test precedes(interval(-3.0, -1.0), interval(-1.0,-0.0)) == true + @test precedes(bareinterval(-3.0, -1.0), bareinterval(-1.0,-0.0)) == true - @test precedes(interval(1.0,3.5), interval(3.0,4.0)) == false + @test precedes(bareinterval(1.0,3.5), bareinterval(3.0,4.0)) == false - @test precedes(interval(1.0,4.0), interval(3.0,4.0)) == false + @test precedes(bareinterval(1.0,4.0), bareinterval(3.0,4.0)) == false - @test precedes(interval(-3.0, -0.1), interval(-1.0,0.0)) == false + @test precedes(bareinterval(-3.0, -0.1), bareinterval(-1.0,0.0)) == false - @test precedes(interval(0.0,0.0), interval(-0.0,-0.0)) == true + @test precedes(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)) == true - @test precedes(interval(-0.0,-0.0), interval(0.0,0.0)) == true + @test precedes(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)) == true - @test precedes(interval(-0.0,0.0), interval(0.0,0.0)) == true + @test precedes(bareinterval(-0.0,0.0), bareinterval(0.0,0.0)) == true - @test precedes(interval(-0.0,0.0), interval(0.0,-0.0)) == true + @test precedes(bareinterval(-0.0,0.0), bareinterval(0.0,-0.0)) == true - @test precedes(interval(0.0,-0.0), interval(0.0,0.0)) == true + @test precedes(bareinterval(0.0,-0.0), bareinterval(0.0,0.0)) == true - @test precedes(interval(0.0,-0.0), interval(-0.0,0.0)) == true + @test precedes(bareinterval(0.0,-0.0), bareinterval(-0.0,0.0)) == true end @testset "minimal_precedes_dec_test" begin - @test precedes(nai(), DecoratedInterval(interval(3.0,4.0), def)) == false + @test precedes(nai(), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == false - @test precedes(DecoratedInterval(interval(3.0,4.0), trv), nai()) == false + @test precedes(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), nai()) == false - @test precedes(nai(), DecoratedInterval(emptyinterval(), trv)) == false + @test precedes(nai(), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test precedes(nai(), nai()) == false - @test precedes(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(3.0,4.0), def)) == true + @test precedes(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == true - @test precedes(DecoratedInterval(interval(3.0,4.0), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test precedes(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test precedes(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test precedes(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(0.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test precedes(Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(-0.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test precedes(Interval(bareinterval(-0.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test precedes(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test precedes(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test precedes(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(1.0,3.0), trv), DecoratedInterval(interval(3.0,4.0), def)) == true + @test precedes(Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == true - @test precedes(DecoratedInterval(interval(-3.0, -1.0), def), DecoratedInterval(interval(-1.0,0.0), trv)) == true + @test precedes(Interval(bareinterval(-3.0, -1.0), IntervalArithmetic.def), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(-3.0, -1.0), trv), DecoratedInterval(interval(-1.0,-0.0), trv)) == true + @test precedes(Interval(bareinterval(-3.0, -1.0), IntervalArithmetic.trv), Interval(bareinterval(-1.0,-0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(1.0,3.5), trv), DecoratedInterval(interval(3.0,4.0), trv)) == false + @test precedes(Interval(bareinterval(1.0,3.5), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(1.0,4.0), trv), DecoratedInterval(interval(3.0,4.0), trv)) == false + @test precedes(Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(-3.0, -0.1), trv), DecoratedInterval(interval(-1.0,0.0), trv)) == false + @test precedes(Interval(bareinterval(-3.0, -0.1), IntervalArithmetic.trv), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)) == false - @test precedes(DecoratedInterval(interval(0.0,0.0), trv), DecoratedInterval(interval(-0.0,-0.0), trv)) == true + @test precedes(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(-0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), def)) == true + @test precedes(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.def)) == true - @test precedes(DecoratedInterval(interval(-0.0,0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test precedes(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(-0.0,0.0), def), DecoratedInterval(interval(0.0,-0.0), trv)) == true + @test precedes(Interval(bareinterval(-0.0,0.0), IntervalArithmetic.def), Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(0.0,0.0), trv)) == true + @test precedes(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) == true - @test precedes(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(-0.0,0.0), trv)) == true + @test precedes(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv)) == true end @testset "minimal_interior_test" begin - @test isstrictsubset_interval(emptyinterval(), emptyinterval()) == true + @test isstrictsubset_interval(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test isstrictsubset_interval(emptyinterval(), interval(0.0,4.0)) == true + @test isstrictsubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(0.0,4.0)) == true - @test isstrictsubset_interval(interval(0.0,4.0), emptyinterval()) == false + @test isstrictsubset_interval(bareinterval(0.0,4.0), emptyinterval(BareInterval{Float64})) == false - @test isstrictsubset_interval(interval(-Inf,+Inf), interval(-Inf,+Inf)) == true + @test isstrictsubset_interval(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == true - @test isstrictsubset_interval(interval(0.0,4.0), interval(-Inf,+Inf)) == true + @test isstrictsubset_interval(bareinterval(0.0,4.0), bareinterval(-Inf,+Inf)) == true - @test isstrictsubset_interval(emptyinterval(), interval(-Inf,+Inf)) == true + @test isstrictsubset_interval(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,+Inf)) == true - @test isstrictsubset_interval(interval(-Inf,+Inf), interval(0.0,4.0)) == false + @test isstrictsubset_interval(bareinterval(-Inf,+Inf), bareinterval(0.0,4.0)) == false - @test isstrictsubset_interval(interval(0.0,4.0), interval(0.0,4.0)) == false + @test isstrictsubset_interval(bareinterval(0.0,4.0), bareinterval(0.0,4.0)) == false - @test isstrictsubset_interval(interval(1.0,2.0), interval(0.0,4.0)) == true + @test isstrictsubset_interval(bareinterval(1.0,2.0), bareinterval(0.0,4.0)) == true - @test isstrictsubset_interval(interval(-2.0,2.0), interval(-2.0,4.0)) == false + @test isstrictsubset_interval(bareinterval(-2.0,2.0), bareinterval(-2.0,4.0)) == false - @test isstrictsubset_interval(interval(-0.0,-0.0), interval(-2.0,4.0)) == true + @test isstrictsubset_interval(bareinterval(-0.0,-0.0), bareinterval(-2.0,4.0)) == true - @test isstrictsubset_interval(interval(0.0,0.0), interval(-2.0,4.0)) == true + @test isstrictsubset_interval(bareinterval(0.0,0.0), bareinterval(-2.0,4.0)) == true - @test isstrictsubset_interval(interval(0.0,0.0), interval(-0.0,-0.0)) == false + @test isstrictsubset_interval(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)) == false - @test isstrictsubset_interval(interval(0.0,4.4), interval(0.0,4.0)) == false + @test isstrictsubset_interval(bareinterval(0.0,4.4), bareinterval(0.0,4.0)) == false - @test isstrictsubset_interval(interval(-1.0,-1.0), interval(0.0,4.0)) == false + @test isstrictsubset_interval(bareinterval(-1.0,-1.0), bareinterval(0.0,4.0)) == false - @test isstrictsubset_interval(interval(2.0,2.0), interval(-2.0,-1.0)) == false + @test isstrictsubset_interval(bareinterval(2.0,2.0), bareinterval(-2.0,-1.0)) == false end @@ -626,75 +626,75 @@ end @test isstrictsubset_interval(nai(), nai()) == false - @test isstrictsubset_interval(nai(), DecoratedInterval(emptyinterval(), trv)) == false + @test isstrictsubset_interval(nai(), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(nai(), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test isstrictsubset_interval(nai(), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,4.0), def), nai()) == false + @test isstrictsubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.def), nai()) == false - @test isstrictsubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isstrictsubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0,4.0), trv)) == true + @test isstrictsubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,4.0), def), DecoratedInterval(emptyinterval(), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isstrictsubset_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,4.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isstrictsubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isstrictsubset_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,4.0), trv), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(0.0,4.0), trv)) == true + @test isstrictsubset_interval(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(-2.0,2.0), trv), DecoratedInterval(interval(-2.0,4.0), def)) == false + @test isstrictsubset_interval(Interval(bareinterval(-2.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0,4.0), IntervalArithmetic.def)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(-0.0,-0.0), trv), DecoratedInterval(interval(-2.0,4.0), trv)) == true + @test isstrictsubset_interval(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,0.0), def), DecoratedInterval(interval(-2.0,4.0), trv)) == true + @test isstrictsubset_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,0.0), trv), DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(0.0,4.4), trv), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(0.0,4.4), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(-1.0,-1.0), trv), DecoratedInterval(interval(0.0,4.0), def)) == false + @test isstrictsubset_interval(Interval(bareinterval(-1.0,-1.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.def)) == false - @test isstrictsubset_interval(DecoratedInterval(interval(2.0,2.0), def), DecoratedInterval(interval(-2.0,-1.0), trv)) == false + @test isstrictsubset_interval(Interval(bareinterval(2.0,2.0), IntervalArithmetic.def), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.trv)) == false end @testset "minimal_strictly_less_test" begin - @test isstrictless(emptyinterval(), emptyinterval()) == true + @test isstrictless(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test isstrictless(interval(1.0,2.0), emptyinterval()) == false + @test isstrictless(bareinterval(1.0,2.0), emptyinterval(BareInterval{Float64})) == false - @test isstrictless(emptyinterval(), interval(1.0,2.0)) == false + @test isstrictless(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)) == false - @test isstrictless(interval(-Inf,+Inf), interval(-Inf,+Inf)) == true + @test isstrictless(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == true - @test isstrictless(interval(1.0,2.0), interval(-Inf,+Inf)) == false + @test isstrictless(bareinterval(1.0,2.0), bareinterval(-Inf,+Inf)) == false - @test isstrictless(interval(-Inf,+Inf), interval(1.0,2.0)) == false + @test isstrictless(bareinterval(-Inf,+Inf), bareinterval(1.0,2.0)) == false - @test isstrictless(interval(1.0,2.0), interval(1.0,2.0)) == false + @test isstrictless(bareinterval(1.0,2.0), bareinterval(1.0,2.0)) == false - @test isstrictless(interval(1.0,2.0), interval(3.0,4.0)) == true + @test isstrictless(bareinterval(1.0,2.0), bareinterval(3.0,4.0)) == true - @test isstrictless(interval(1.0,3.5), interval(3.0,4.0)) == true + @test isstrictless(bareinterval(1.0,3.5), bareinterval(3.0,4.0)) == true - @test isstrictless(interval(1.0,4.0), interval(3.0,4.0)) == false + @test isstrictless(bareinterval(1.0,4.0), bareinterval(3.0,4.0)) == false - @test isstrictless(interval(0.0,4.0), interval(0.0,4.0)) == false + @test isstrictless(bareinterval(0.0,4.0), bareinterval(0.0,4.0)) == false - @test isstrictless(interval(-0.0,4.0), interval(0.0,4.0)) == false + @test isstrictless(bareinterval(-0.0,4.0), bareinterval(0.0,4.0)) == false - @test isstrictless(interval(-2.0,-1.0), interval(-2.0,-1.0)) == false + @test isstrictless(bareinterval(-2.0,-1.0), bareinterval(-2.0,-1.0)) == false - @test isstrictless(interval(-3.0,-1.5), interval(-2.0,-1.0)) == true + @test isstrictless(bareinterval(-3.0,-1.5), bareinterval(-2.0,-1.0)) == true end @@ -702,166 +702,166 @@ end @test isstrictless(nai(), nai()) == false - @test isstrictless(DecoratedInterval(emptyinterval(), trv), nai()) == false + @test isstrictless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), nai()) == false - @test isstrictless(DecoratedInterval(interval(1.0,2.0), trv), nai()) == false + @test isstrictless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), nai()) == false - @test isstrictless(nai(), DecoratedInterval(interval(1.0,2.0), def)) == false + @test isstrictless(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) == false - @test isstrictless(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isstrictless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isstrictless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)) == false + @test isstrictless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test isstrictless(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,2.0), def)) == false + @test isstrictless(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) == false - @test isstrictless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == true + @test isstrictless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == true - @test isstrictless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isstrictless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isstrictless(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isstrictless(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isstrictless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test isstrictless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test isstrictless(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test isstrictless(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictless(DecoratedInterval(interval(1.0,3.5), def), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test isstrictless(Interval(bareinterval(1.0,3.5), IntervalArithmetic.def), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test isstrictless(DecoratedInterval(interval(1.0,4.0), trv), DecoratedInterval(interval(3.0,4.0), def)) == false + @test isstrictless(Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == false - @test isstrictless(DecoratedInterval(interval(0.0,4.0), trv), DecoratedInterval(interval(0.0,4.0), def)) == false + @test isstrictless(Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,4.0), IntervalArithmetic.def)) == false - @test isstrictless(DecoratedInterval(interval(-0.0,4.0), def), DecoratedInterval(interval(0.0,4.0), trv)) == false + @test isstrictless(Interval(bareinterval(-0.0,4.0), IntervalArithmetic.def), Interval(bareinterval(0.0,4.0), IntervalArithmetic.trv)) == false - @test isstrictless(DecoratedInterval(interval(-2.0,-1.0), def), DecoratedInterval(interval(-2.0,-1.0), def)) == false + @test isstrictless(Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.def)) == false - @test isstrictless(DecoratedInterval(interval(-3.0,-1.5), trv), DecoratedInterval(interval(-2.0,-1.0), trv)) == true + @test isstrictless(Interval(bareinterval(-3.0,-1.5), IntervalArithmetic.trv), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.trv)) == true end @testset "minimal_strictly_precedes_test" begin - @test strictprecedes(emptyinterval(), interval(3.0,4.0)) == true + @test strictprecedes(emptyinterval(BareInterval{Float64}), bareinterval(3.0,4.0)) == true - @test strictprecedes(interval(3.0,4.0), emptyinterval()) == true + @test strictprecedes(bareinterval(3.0,4.0), emptyinterval(BareInterval{Float64})) == true - @test strictprecedes(emptyinterval(), emptyinterval()) == true + @test strictprecedes(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test strictprecedes(interval(1.0,2.0), interval(-Inf,+Inf)) == false + @test strictprecedes(bareinterval(1.0,2.0), bareinterval(-Inf,+Inf)) == false - @test strictprecedes(interval(-Inf,+Inf), interval(1.0,2.0)) == false + @test strictprecedes(bareinterval(-Inf,+Inf), bareinterval(1.0,2.0)) == false - @test strictprecedes(interval(-Inf,+Inf), interval(-Inf,+Inf)) == false + @test strictprecedes(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == false - @test strictprecedes(interval(1.0,2.0), interval(3.0,4.0)) == true + @test strictprecedes(bareinterval(1.0,2.0), bareinterval(3.0,4.0)) == true - @test strictprecedes(interval(1.0,3.0), interval(3.0,4.0)) == false + @test strictprecedes(bareinterval(1.0,3.0), bareinterval(3.0,4.0)) == false - @test strictprecedes(interval(-3.0,-1.0), interval(-1.0,0.0)) == false + @test strictprecedes(bareinterval(-3.0,-1.0), bareinterval(-1.0,0.0)) == false - @test strictprecedes(interval(-3.0,-0.0), interval(0.0,1.0)) == false + @test strictprecedes(bareinterval(-3.0,-0.0), bareinterval(0.0,1.0)) == false - @test strictprecedes(interval(-3.0,0.0), interval(-0.0,1.0)) == false + @test strictprecedes(bareinterval(-3.0,0.0), bareinterval(-0.0,1.0)) == false - @test strictprecedes(interval(1.0,3.5), interval(3.0,4.0)) == false + @test strictprecedes(bareinterval(1.0,3.5), bareinterval(3.0,4.0)) == false - @test strictprecedes(interval(1.0,4.0), interval(3.0,4.0)) == false + @test strictprecedes(bareinterval(1.0,4.0), bareinterval(3.0,4.0)) == false - @test strictprecedes(interval(-3.0,-0.1), interval(-1.0,0.0)) == false + @test strictprecedes(bareinterval(-3.0,-0.1), bareinterval(-1.0,0.0)) == false end @testset "minimal_strictly_precedes_dec_test" begin - @test strictprecedes(nai(), DecoratedInterval(interval(3.0,4.0), trv)) == false + @test strictprecedes(nai(), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(3.0,4.0), def), nai()) == false + @test strictprecedes(Interval(bareinterval(3.0,4.0), IntervalArithmetic.def), nai()) == false - @test strictprecedes(nai(), DecoratedInterval(emptyinterval(), trv)) == false + @test strictprecedes(nai(), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test strictprecedes(nai(), nai()) == false - @test strictprecedes(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test strictprecedes(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test strictprecedes(DecoratedInterval(interval(3.0,4.0), def), DecoratedInterval(emptyinterval(), trv)) == true + @test strictprecedes(Interval(bareinterval(3.0,4.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test strictprecedes(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test strictprecedes(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test strictprecedes(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test strictprecedes(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(1.0,2.0), trv)) == false + @test strictprecedes(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test strictprecedes(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(3.0,4.0), trv)) == true + @test strictprecedes(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == true - @test strictprecedes(DecoratedInterval(interval(1.0,3.0), def), DecoratedInterval(interval(3.0,4.0), trv)) == false + @test strictprecedes(Interval(bareinterval(1.0,3.0), IntervalArithmetic.def), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(-3.0,-1.0), trv), DecoratedInterval(interval(-1.0,0.0), def)) == false + @test strictprecedes(Interval(bareinterval(-3.0,-1.0), IntervalArithmetic.trv), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) == false - @test strictprecedes(DecoratedInterval(interval(-3.0,-0.0), def), DecoratedInterval(interval(0.0,1.0), trv)) == false + @test strictprecedes(Interval(bareinterval(-3.0,-0.0), IntervalArithmetic.def), Interval(bareinterval(0.0,1.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(-3.0,0.0), trv), DecoratedInterval(interval(-0.0,1.0), trv)) == false + @test strictprecedes(Interval(bareinterval(-3.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,1.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(1.0,3.5), trv), DecoratedInterval(interval(3.0,4.0), trv)) == false + @test strictprecedes(Interval(bareinterval(1.0,3.5), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv)) == false - @test strictprecedes(DecoratedInterval(interval(1.0,4.0), trv), DecoratedInterval(interval(3.0,4.0), def)) == false + @test strictprecedes(Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == false - @test strictprecedes(DecoratedInterval(interval(-3.0,-0.1), trv), DecoratedInterval(interval(-1.0,0.0), trv)) == false + @test strictprecedes(Interval(bareinterval(-3.0,-0.1), IntervalArithmetic.trv), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)) == false end @testset "minimal_disjoint_test" begin - @test isdisjoint_interval(emptyinterval(), interval(3.0,4.0)) == true + @test isdisjoint_interval(emptyinterval(BareInterval{Float64}), bareinterval(3.0,4.0)) == true - @test isdisjoint_interval(interval(3.0,4.0), emptyinterval()) == true + @test isdisjoint_interval(bareinterval(3.0,4.0), emptyinterval(BareInterval{Float64})) == true - @test isdisjoint_interval(emptyinterval(), emptyinterval()) == true + @test isdisjoint_interval(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) == true - @test isdisjoint_interval(interval(3.0,4.0), interval(1.0,2.0)) == true + @test isdisjoint_interval(bareinterval(3.0,4.0), bareinterval(1.0,2.0)) == true - @test isdisjoint_interval(interval(0.0,0.0), interval(-0.0,-0.0)) == false + @test isdisjoint_interval(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)) == false - @test isdisjoint_interval(interval(0.0,-0.0), interval(-0.0,0.0)) == false + @test isdisjoint_interval(bareinterval(0.0,-0.0), bareinterval(-0.0,0.0)) == false - @test isdisjoint_interval(interval(3.0,4.0), interval(1.0,7.0)) == false + @test isdisjoint_interval(bareinterval(3.0,4.0), bareinterval(1.0,7.0)) == false - @test isdisjoint_interval(interval(3.0,4.0), interval(-Inf,+Inf)) == false + @test isdisjoint_interval(bareinterval(3.0,4.0), bareinterval(-Inf,+Inf)) == false - @test isdisjoint_interval(interval(-Inf,+Inf), interval(1.0,7.0)) == false + @test isdisjoint_interval(bareinterval(-Inf,+Inf), bareinterval(1.0,7.0)) == false - @test isdisjoint_interval(interval(-Inf,+Inf), interval(-Inf,+Inf)) == false + @test isdisjoint_interval(bareinterval(-Inf,+Inf), bareinterval(-Inf,+Inf)) == false end @testset "minimal_disjoint_dec_test" begin - @test isdisjoint_interval(nai(), DecoratedInterval(interval(3.0,4.0), def)) == false + @test isdisjoint_interval(nai(), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == false - @test isdisjoint_interval(DecoratedInterval(interval(3.0,4.0), trv), nai()) == false + @test isdisjoint_interval(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), nai()) == false - @test isdisjoint_interval(DecoratedInterval(emptyinterval(), trv), nai()) == false + @test isdisjoint_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), nai()) == false @test isdisjoint_interval(nai(), nai()) == false - @test isdisjoint_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(3.0,4.0), def)) == true + @test isdisjoint_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) == true - @test isdisjoint_interval(DecoratedInterval(interval(3.0,4.0), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isdisjoint_interval(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isdisjoint_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) == true + @test isdisjoint_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test isdisjoint_interval(DecoratedInterval(interval(3.0,4.0), trv), DecoratedInterval(interval(1.0,2.0), def)) == true + @test isdisjoint_interval(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) == true - @test isdisjoint_interval(DecoratedInterval(interval(0.0,0.0), trv), DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test isdisjoint_interval(Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.trv)) == false - @test isdisjoint_interval(DecoratedInterval(interval(0.0,-0.0), trv), DecoratedInterval(interval(-0.0,0.0), trv)) == false + @test isdisjoint_interval(Interval(bareinterval(0.0,-0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0,0.0), IntervalArithmetic.trv)) == false - @test isdisjoint_interval(DecoratedInterval(interval(3.0,4.0), def), DecoratedInterval(interval(1.0,7.0), def)) == false + @test isdisjoint_interval(Interval(bareinterval(3.0,4.0), IntervalArithmetic.def), Interval(bareinterval(1.0,7.0), IntervalArithmetic.def)) == false - @test isdisjoint_interval(DecoratedInterval(interval(3.0,4.0), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isdisjoint_interval(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false - @test isdisjoint_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(1.0,7.0), trv)) == false + @test isdisjoint_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(1.0,7.0), IntervalArithmetic.trv)) == false - @test isdisjoint_interval(DecoratedInterval(interval(-Inf,+Inf), trv), DecoratedInterval(interval(-Inf,+Inf), trv)) == false + @test isdisjoint_interval(Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,+Inf), IntervalArithmetic.trv)) == false end diff --git a/test/test_ITF1788/libieeep1788_cancel.jl b/test/test_ITF1788/libieeep1788_cancel.jl index 843b50937..04968e1ff 100644 --- a/test/test_ITF1788/libieeep1788_cancel.jl +++ b/test/test_ITF1788/libieeep1788_cancel.jl @@ -1,499 +1,499 @@ @testset "minimal_cancel_plus_test" begin - @test isequal_interval(cancelplus(interval(-Inf, -1.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0, Inf), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0, Inf), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(entireinterval(), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-Inf, -1.0), interval(-5.0,1.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-Inf, -1.0), bareinterval(-5.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0, Inf), interval(-5.0,1.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0, Inf), bareinterval(-5.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(entireinterval(), interval(-5.0,1.0)), entireinterval()) + @test isequal_interval(cancelplus(entireinterval(BareInterval{Float64}), bareinterval(-5.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), interval(1.0, Inf)), entireinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), bareinterval(1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), interval(-Inf,1.0)), entireinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), entireinterval()), entireinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0,5.0), interval(1.0,Inf)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0,5.0), bareinterval(1.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0,5.0), interval(-Inf,1.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0,5.0), bareinterval(-Inf,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-1.0,5.0), entireinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(entireinterval(), interval(1.0,Inf)), entireinterval()) + @test isequal_interval(cancelplus(entireinterval(BareInterval{Float64}), bareinterval(1.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(entireinterval(), interval(-Inf,1.0)), entireinterval()) + @test isequal_interval(cancelplus(entireinterval(BareInterval{Float64}), bareinterval(-Inf,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(cancelplus(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-5.0, -1.0), interval(1.0,5.1)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-5.0, -1.0), bareinterval(1.0,5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-5.0, -1.0), interval(0.9,5.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-5.0, -1.0), bareinterval(0.9,5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-5.0, -1.0), interval(0.9,5.1)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-5.0, -1.0), bareinterval(0.9,5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-10.0, 5.0), interval(-5.0,10.1)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.0), bareinterval(-5.0,10.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-10.0, 5.0), interval(-5.1,10.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.0), bareinterval(-5.1,10.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-10.0, 5.0), interval(-5.1,10.1)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.0), bareinterval(-5.1,10.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(1.0, 5.0), interval(-5.0,-0.9)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.0), bareinterval(-5.0,-0.9)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(1.0, 5.0), interval(-5.1,-1.0)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.0), bareinterval(-5.1,-1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(1.0, 5.0), interval(-5.1,-0.9)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.0), bareinterval(-5.1,-0.9)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-10.0, -1.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-10.0, -1.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-10.0, 5.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(1.0, 5.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), interval(1.0,10.0)), emptyinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), bareinterval(1.0,10.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), interval(-5.0,10.0)), emptyinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), bareinterval(-5.0,10.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(emptyinterval(), interval(-5.0,-1.0)), emptyinterval()) + @test isequal_interval(cancelplus(emptyinterval(BareInterval{Float64}), bareinterval(-5.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-5.1,-0.0), interval(0.0,5.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelplus(bareinterval(-5.1,-0.0), bareinterval(0.0,5.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelplus(interval(-5.1,-1.0), interval(1.0,5.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelplus(bareinterval(-5.1,-1.0), bareinterval(1.0,5.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelplus(interval(-5.0,-0.9), interval(1.0,5.0)), interval(0.0, 0x1.9999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(-5.0,-0.9), bareinterval(1.0,5.0)), bareinterval(0.0, 0x1.9999999999998P-4)) - @test isequal_interval(cancelplus(interval(-5.1,-0.9), interval(1.0,5.0)), interval(-0x1.999999999998P-4,0x1.9999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(-5.1,-0.9), bareinterval(1.0,5.0)), bareinterval(-0x1.999999999998P-4,0x1.9999999999998P-4)) - @test isequal_interval(cancelplus(interval(-5.0,-1.0), interval(1.0,5.0)), interval(0.0,0.0)) + @test isequal_interval(cancelplus(bareinterval(-5.0,-1.0), bareinterval(1.0,5.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelplus(interval(-10.1, 5.0), interval(-5.0,10.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelplus(bareinterval(-10.1, 5.0), bareinterval(-5.0,10.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelplus(interval(-10.0, 5.1), interval(-5.0,10.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.1), bareinterval(-5.0,10.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelplus(interval(-10.1, 5.1), interval(-5.0,10.0)), interval(-0x1.999999999998P-4,0x1.999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(-10.1, 5.1), bareinterval(-5.0,10.0)), bareinterval(-0x1.999999999998P-4,0x1.999999999998P-4)) - @test isequal_interval(cancelplus(interval(-10.0, 5.0), interval(-5.0,10.0)), interval(0.0,0.0)) + @test isequal_interval(cancelplus(bareinterval(-10.0, 5.0), bareinterval(-5.0,10.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelplus(interval(0.9, 5.0), interval(-5.0,-1.0)), interval(-0x1.9999999999998P-4,0.0)) + @test isequal_interval(cancelplus(bareinterval(0.9, 5.0), bareinterval(-5.0,-1.0)), bareinterval(-0x1.9999999999998P-4,0.0)) - @test isequal_interval(cancelplus(interval(1.0, 5.1), interval(-5.0,-1.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.1), bareinterval(-5.0,-1.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelplus(interval(0.0, 5.1), interval(-5.0,-0.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(0.0, 5.1), bareinterval(-5.0,-0.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelplus(interval(0.9, 5.1), interval(-5.0,-1.0)), interval(-0x1.9999999999998P-4,0x1.999999999998P-4)) + @test isequal_interval(cancelplus(bareinterval(0.9, 5.1), bareinterval(-5.0,-1.0)), bareinterval(-0x1.9999999999998P-4,0x1.999999999998P-4)) - @test isequal_interval(cancelplus(interval(1.0, 5.0), interval(-5.0,-1.0)), interval(0.0,0.0)) + @test isequal_interval(cancelplus(bareinterval(1.0, 5.0), bareinterval(-5.0,-1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelplus(interval(0.0, 5.0), interval(-5.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(cancelplus(bareinterval(0.0, 5.0), bareinterval(-5.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelplus(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), interval(0x1.E666666666656P+0,0x1.E666666666657P+0)) + @test isequal_interval(cancelplus(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0)) - @test isequal_interval(cancelplus(interval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), interval(-0x1.999999999999AP-4,0.01)), interval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0)) + @test isequal_interval(cancelplus(bareinterval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.999999999999AP-4,0.01)), bareinterval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0)) - @test isequal_interval(cancelplus(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(cancelplus(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(cancelplus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,0.0)) + @test isequal_interval(cancelplus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelplus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,0x1P+971)) + @test isequal_interval(cancelplus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,0x1P+971)) - @test isequal_interval(cancelplus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023)), interval(-0x1P+971,0.0)) + @test isequal_interval(cancelplus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023)), bareinterval(-0x1P+971,0.0)) - @test isequal_interval(cancelplus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelplus(interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53)), interval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1)) + @test isequal_interval(cancelplus(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53)), bareinterval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1)) - @test isequal_interval(cancelplus(interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53)), entireinterval()) + @test isequal_interval(cancelplus(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53)), entireinterval(BareInterval{Float64})) end @testset "minimal_cancel_plus_dec_test" begin - @test isequal_interval(cancelplus(DecoratedInterval(interval(-Inf, -1.0), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0, Inf), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(entireinterval(), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-Inf, -1.0), dac), DecoratedInterval(interval(-5.0,1.0), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0, Inf), trv), DecoratedInterval(interval(-5.0,1.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.trv), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-5.0,1.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-Inf, -1.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0, Inf), def), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0, Inf), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0, Inf), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-Inf,1.0), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0,5.0), dac), DecoratedInterval(interval(1.0,Inf), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.dac), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0,5.0), def), DecoratedInterval(interval(-Inf,1.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.def), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-1.0,5.0), com), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.com), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(1.0,Inf), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf,1.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.0, -1.0), com), DecoratedInterval(interval(1.0,5.1), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.com), Interval(bareinterval(1.0,5.1), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.0, -1.0), dac), DecoratedInterval(interval(0.9,5.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.dac), Interval(bareinterval(0.9,5.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.0, -1.0), def), DecoratedInterval(interval(0.9,5.1), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.def), Interval(bareinterval(0.9,5.1), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.0), trv), DecoratedInterval(interval(-5.0,10.1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.trv), Interval(bareinterval(-5.0,10.1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.0), com), DecoratedInterval(interval(-5.1,10.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.com), Interval(bareinterval(-5.1,10.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.0), dac), DecoratedInterval(interval(-5.1,10.1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-5.1,10.1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.0), def), DecoratedInterval(interval(-5.0,-0.9), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.def), Interval(bareinterval(-5.0,-0.9), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.0), trv), DecoratedInterval(interval(-5.1,-1.0), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.trv), Interval(bareinterval(-5.1,-1.0), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.0), dac), DecoratedInterval(interval(-5.1,-0.9), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-5.1,-0.9), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, -1.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, -1.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,10.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0,10.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-5.0,10.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-5.0,10.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-5.0,-1.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelplus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.1,-0.0), com), DecoratedInterval(interval(0.0,5.0), com)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.1,-0.0), IntervalArithmetic.com), Interval(bareinterval(0.0,5.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.1,-1.0), com), DecoratedInterval(interval(1.0,5.0), dac)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.1,-1.0), IntervalArithmetic.com), Interval(bareinterval(1.0,5.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.0,-0.9), com), DecoratedInterval(interval(1.0,5.0), def)), DecoratedInterval(interval(0.0, 0x1.9999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.0,-0.9), IntervalArithmetic.com), Interval(bareinterval(1.0,5.0), IntervalArithmetic.def)), Interval(bareinterval(0.0, 0x1.9999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.1,-0.9), dac), DecoratedInterval(interval(1.0,5.0), trv)), DecoratedInterval(interval(-0x1.999999999998P-4,0x1.9999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.1,-0.9), IntervalArithmetic.dac), Interval(bareinterval(1.0,5.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.999999999998P-4,0x1.9999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-5.0,-1.0), dac), DecoratedInterval(interval(1.0,5.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.dac), Interval(bareinterval(1.0,5.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.1, 5.0), dac), DecoratedInterval(interval(-5.0,10.0), dac)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.1, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-5.0,10.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.1), def), DecoratedInterval(interval(-5.0,10.0), def)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.1), IntervalArithmetic.def), Interval(bareinterval(-5.0,10.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.1, 5.1), def), DecoratedInterval(interval(-5.0,10.0), trv)), DecoratedInterval(interval(-0x1.999999999998P-4,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.1, 5.1), IntervalArithmetic.def), Interval(bareinterval(-5.0,10.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.999999999998P-4,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-10.0, 5.0), def), DecoratedInterval(interval(-5.0,10.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.def), Interval(bareinterval(-5.0,10.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0.9, 5.0), trv), DecoratedInterval(interval(-5.0,-1.0), dac)), DecoratedInterval(interval(-0x1.9999999999998P-4,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0.9, 5.0), IntervalArithmetic.trv), Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.9999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.1), trv), DecoratedInterval(interval(-5.0,-1.0), def)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.1), IntervalArithmetic.trv), Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0.0, 5.1), trv), DecoratedInterval(interval(-5.0,-0.0), trv)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0.0, 5.1), IntervalArithmetic.trv), Interval(bareinterval(-5.0,-0.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0.9, 5.1), com), DecoratedInterval(interval(-5.0,-1.0), com)), DecoratedInterval(interval(-0x1.9999999999998P-4,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0.9, 5.1), IntervalArithmetic.com), Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.9999999999998P-4,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(1.0, 5.0), dac), DecoratedInterval(interval(-5.0,-1.0), dac)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0.0, 5.0), def), DecoratedInterval(interval(-5.0,-0.0), trv)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0.0, 5.0), IntervalArithmetic.def), Interval(bareinterval(-5.0,-0.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), com), DecoratedInterval(interval(-0x1.999999999999AP-4,-0x1.999999999999AP-4), com)), DecoratedInterval(interval(0x1.E666666666656P+0,0x1.E666666666657P+0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), IntervalArithmetic.com), Interval(bareinterval(-0x1.999999999999AP-4,-0x1.999999999999AP-4), IntervalArithmetic.com)), Interval(bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), dac), DecoratedInterval(interval(-0x1.999999999999AP-4,0.01), com)), DecoratedInterval(interval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), IntervalArithmetic.dac), Interval(bareinterval(-0x1.999999999999AP-4,0.01), IntervalArithmetic.com)), Interval(bareinterval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0.0,0x1P+971), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac), Interval(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1P+971), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), com)), DecoratedInterval(interval(-0x1P+971,0.0), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), IntervalArithmetic.com)), Interval(bareinterval(-0x1P+971,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), dac), DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), com)), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), IntervalArithmetic.dac), Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), IntervalArithmetic.com)), Interval(bareinterval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1), IntervalArithmetic.trv)) - @test isequal_interval(cancelplus(DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), def), DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelplus(Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), IntervalArithmetic.def), Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_cancel_minus_test" begin - @test isequal_interval(cancelminus(interval(-Inf, -1.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0, Inf), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0, Inf), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(entireinterval(), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-Inf, -1.0), interval(-1.0,5.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-Inf, -1.0), bareinterval(-1.0,5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0, Inf), interval(-1.0,5.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0, Inf), bareinterval(-1.0,5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(entireinterval(), interval(-1.0,5.0)), entireinterval()) + @test isequal_interval(cancelminus(entireinterval(BareInterval{Float64}), bareinterval(-1.0,5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), interval(-1.0, Inf)), entireinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), bareinterval(-1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), entireinterval()), entireinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0,5.0), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0,5.0), interval(-1.0, Inf)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0,5.0), bareinterval(-1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-1.0,5.0), entireinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(entireinterval(), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(cancelminus(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(entireinterval(), interval(-1.0, Inf)), entireinterval()) + @test isequal_interval(cancelminus(entireinterval(BareInterval{Float64}), bareinterval(-1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(cancelminus(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-5.0, -1.0), interval(-5.1,-1.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-5.0, -1.0), bareinterval(-5.1,-1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-5.0, -1.0), interval(-5.0,-0.9)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-5.0, -1.0), bareinterval(-5.0,-0.9)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-5.0, -1.0), interval(-5.1,-0.9)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-5.0, -1.0), bareinterval(-5.1,-0.9)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-10.0, 5.0), interval(-10.1, 5.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.0), bareinterval(-10.1, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-10.0, 5.0), interval(-10.0, 5.1)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.0), bareinterval(-10.0, 5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-10.0, 5.0), interval(-10.1, 5.1)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.0), bareinterval(-10.1, 5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(1.0, 5.0), interval(0.9, 5.0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.0), bareinterval(0.9, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(1.0, 5.0), interval(1.0, 5.1)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.0), bareinterval(1.0, 5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(1.0, 5.0), interval(0.9, 5.1)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.0), bareinterval(0.9, 5.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-10.0, -1.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-10.0, -1.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-10.0, 5.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(1.0, 5.0), emptyinterval()), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.0), emptyinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), interval(-10.0, -1.0)), emptyinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), bareinterval(-10.0, -1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), interval(-10.0, 5.0)), emptyinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), bareinterval(-10.0, 5.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(emptyinterval(), interval(1.0, 5.0)), emptyinterval()) + @test isequal_interval(cancelminus(emptyinterval(BareInterval{Float64}), bareinterval(1.0, 5.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-5.1,-0.0), interval(-5.0, 0.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelminus(bareinterval(-5.1,-0.0), bareinterval(-5.0, 0.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelminus(interval(-5.1,-1.0), interval(-5.0, -1.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelminus(bareinterval(-5.1,-1.0), bareinterval(-5.0, -1.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelminus(interval(-5.0,-0.9), interval(-5.0, -1.0)), interval(0.0, 0x1.9999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(-5.0,-0.9), bareinterval(-5.0, -1.0)), bareinterval(0.0, 0x1.9999999999998P-4)) - @test isequal_interval(cancelminus(interval(-5.1,-0.9), interval(-5.0, -1.0)), interval(-0x1.999999999998P-4,0x1.9999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(-5.1,-0.9), bareinterval(-5.0, -1.0)), bareinterval(-0x1.999999999998P-4,0x1.9999999999998P-4)) - @test isequal_interval(cancelminus(interval(-5.0,-1.0), interval(-5.0, -1.0)), interval(0.0,0.0)) + @test isequal_interval(cancelminus(bareinterval(-5.0,-1.0), bareinterval(-5.0, -1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelminus(interval(-10.1, 5.0), interval(-10.0, 5.0)), interval(-0x1.999999999998P-4,0.0)) + @test isequal_interval(cancelminus(bareinterval(-10.1, 5.0), bareinterval(-10.0, 5.0)), bareinterval(-0x1.999999999998P-4,0.0)) - @test isequal_interval(cancelminus(interval(-10.0, 5.1), interval(-10.0, 5.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.1), bareinterval(-10.0, 5.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelminus(interval(-10.1, 5.1), interval(-10.0, 5.0)), interval(-0x1.999999999998P-4,0x1.999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(-10.1, 5.1), bareinterval(-10.0, 5.0)), bareinterval(-0x1.999999999998P-4,0x1.999999999998P-4)) - @test isequal_interval(cancelminus(interval(-10.0, 5.0), interval(-10.0, 5.0)), interval(0.0,0.0)) + @test isequal_interval(cancelminus(bareinterval(-10.0, 5.0), bareinterval(-10.0, 5.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelminus(interval(0.9, 5.0), interval(1.0, 5.0)), interval(-0x1.9999999999998P-4,0.0)) + @test isequal_interval(cancelminus(bareinterval(0.9, 5.0), bareinterval(1.0, 5.0)), bareinterval(-0x1.9999999999998P-4,0.0)) - @test isequal_interval(cancelminus(interval(-0.0, 5.1), interval(0.0, 5.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(-0.0, 5.1), bareinterval(0.0, 5.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelminus(interval(1.0, 5.1), interval(1.0, 5.0)), interval(0.0,0x1.999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.1), bareinterval(1.0, 5.0)), bareinterval(0.0,0x1.999999999998P-4)) - @test isequal_interval(cancelminus(interval(0.9, 5.1), interval(1.0, 5.0)), interval(-0x1.9999999999998P-4,0x1.999999999998P-4)) + @test isequal_interval(cancelminus(bareinterval(0.9, 5.1), bareinterval(1.0, 5.0)), bareinterval(-0x1.9999999999998P-4,0x1.999999999998P-4)) - @test isequal_interval(cancelminus(interval(1.0, 5.0), interval(1.0, 5.0)), interval(0.0,0.0)) + @test isequal_interval(cancelminus(bareinterval(1.0, 5.0), bareinterval(1.0, 5.0)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelminus(interval(-5.0, 1.0), interval(-1.0, 5.0)), interval(-4.0,-4.0)) + @test isequal_interval(cancelminus(bareinterval(-5.0, 1.0), bareinterval(-1.0, 5.0)), bareinterval(-4.0,-4.0)) - @test isequal_interval(cancelminus(interval(-5.0, 0.0), interval(-0.0, 5.0)), interval(-5.0,-5.0)) + @test isequal_interval(cancelminus(bareinterval(-5.0, 0.0), bareinterval(-0.0, 5.0)), bareinterval(-5.0,-5.0)) - @test isequal_interval(cancelminus(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(0x1.E666666666656P+0,0x1.E666666666657P+0)) + @test isequal_interval(cancelminus(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0)) - @test isequal_interval(cancelminus(interval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), interval(-0.01,0x1.999999999999AP-4)), interval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0)) + @test isequal_interval(cancelminus(bareinterval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), bareinterval(-0.01,0x1.999999999999AP-4)), bareinterval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0)) - @test isequal_interval(cancelminus(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(cancelminus(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(cancelminus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,0.0)) + @test isequal_interval(cancelminus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelminus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023)), interval(0.0,0x1P+971)) + @test isequal_interval(cancelminus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023)), bareinterval(0.0,0x1P+971)) - @test isequal_interval(cancelminus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023)), interval(-0x1P+971,0.0)) + @test isequal_interval(cancelminus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-0x1P+971,0.0)) - @test isequal_interval(cancelminus(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)), interval(0.0,0.0)) + @test isequal_interval(cancelminus(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)), bareinterval(0.0,0.0)) - @test isequal_interval(cancelminus(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)), interval(0x0.0000000000002p-1022,0x0.0000000000002p-1022)) + @test isequal_interval(cancelminus(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)), bareinterval(0x0.0000000000002p-1022,0x0.0000000000002p-1022)) - @test isequal_interval(cancelminus(interval(0x1P-1022,0x1.0000000000002P-1022), interval(0x1P-1022,0x1.0000000000001P-1022)), interval(0.0,0x0.0000000000001P-1022)) + @test isequal_interval(cancelminus(bareinterval(0x1P-1022,0x1.0000000000002P-1022), bareinterval(0x1P-1022,0x1.0000000000001P-1022)), bareinterval(0.0,0x0.0000000000001P-1022)) - @test isequal_interval(cancelminus(interval(0x1P-1022,0x1.0000000000001P-1022), interval(0x1P-1022,0x1.0000000000002P-1022)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(0x1P-1022,0x1.0000000000001P-1022), bareinterval(0x1P-1022,0x1.0000000000002P-1022)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cancelminus(interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), interval(-0x1.FFFFFFFFFFFFEP-53,0x1P+0)), interval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1)) + @test isequal_interval(cancelminus(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), bareinterval(-0x1.FFFFFFFFFFFFEP-53,0x1P+0)), bareinterval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1)) - @test isequal_interval(cancelminus(interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), interval(-0x1.FFFFFFFFFFFFFP-53,0x1P+0)), entireinterval()) + @test isequal_interval(cancelminus(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), bareinterval(-0x1.FFFFFFFFFFFFFP-53,0x1P+0)), entireinterval(BareInterval{Float64})) end @testset "minimal_cancel_minus_dec_test" begin - @test isequal_interval(cancelminus(DecoratedInterval(interval(-Inf, -1.0), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0, Inf), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-Inf, -1.0), trv), DecoratedInterval(interval(-1.0,5.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.trv), Interval(bareinterval(-1.0,5.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0, Inf), dac), DecoratedInterval(interval(-1.0,5.0), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-1.0,5.0), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-1.0,5.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-1.0,5.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-Inf, -1.0), def), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0, Inf), trv), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0, Inf), IntervalArithmetic.trv), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-Inf, -1.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-1.0, Inf), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-1.0, Inf), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(entireinterval(), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0,5.0), dac), DecoratedInterval(interval(-Inf, -1.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0,5.0), def), DecoratedInterval(interval(-1.0, Inf), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.def), Interval(bareinterval(-1.0, Inf), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-1.0,5.0), com), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.com), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, -1.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -1.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-1.0, Inf), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-1.0, Inf), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(entireinterval(), dac), DecoratedInterval(entireinterval(), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0, -1.0), com), DecoratedInterval(interval(-5.1,-1.0), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.com), Interval(bareinterval(-5.1,-1.0), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0, -1.0), dac), DecoratedInterval(interval(-5.0,-0.9), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.dac), Interval(bareinterval(-5.0,-0.9), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0, -1.0), def), DecoratedInterval(interval(-5.1,-0.9), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.def), Interval(bareinterval(-5.1,-0.9), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.0), trv), DecoratedInterval(interval(-10.1, 5.0), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.trv), Interval(bareinterval(-10.1, 5.0), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.0), com), DecoratedInterval(interval(-10.0, 5.1), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.com), Interval(bareinterval(-10.0, 5.1), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.0), dac), DecoratedInterval(interval(-10.1, 5.1), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-10.1, 5.1), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.0), def), DecoratedInterval(interval(0.9, 5.0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.def), Interval(bareinterval(0.9, 5.0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.0), trv), DecoratedInterval(interval(1.0, 5.1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.trv), Interval(bareinterval(1.0, 5.1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.0), com), DecoratedInterval(interval(0.9, 5.1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.com), Interval(bareinterval(0.9, 5.1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, -1.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, -1.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.0), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-10.0, -1.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-10.0, -1.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-10.0, 5.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0, 5.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cancelminus(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0, 5.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.1,-0.0), com), DecoratedInterval(interval(-5.0, 0.0), com)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.1,-0.0), IntervalArithmetic.com), Interval(bareinterval(-5.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.1,-1.0), dac), DecoratedInterval(interval(-5.0, -1.0), com)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.1,-1.0), IntervalArithmetic.dac), Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0,-0.9), def), DecoratedInterval(interval(-5.0, -1.0), com)), DecoratedInterval(interval(0.0, 0x1.9999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0,-0.9), IntervalArithmetic.def), Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0, 0x1.9999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.1,-0.9), trv), DecoratedInterval(interval(-5.0, -1.0), com)), DecoratedInterval(interval(-0x1.999999999998P-4,0x1.9999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.1,-0.9), IntervalArithmetic.trv), Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.999999999998P-4,0x1.9999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0,-1.0), com), DecoratedInterval(interval(-5.0, -1.0), dac)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0,-1.0), IntervalArithmetic.com), Interval(bareinterval(-5.0, -1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.1, 5.0), dac), DecoratedInterval(interval(-10.0, 5.0), dac)), DecoratedInterval(interval(-0x1.999999999998P-4,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.1, 5.0), IntervalArithmetic.dac), Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.1), def), DecoratedInterval(interval(-10.0, 5.0), dac)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.1), IntervalArithmetic.def), Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.1, 5.1), trv), DecoratedInterval(interval(-10.0, 5.0), def)), DecoratedInterval(interval(-0x1.999999999998P-4,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.1, 5.1), IntervalArithmetic.trv), Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.999999999998P-4,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-10.0, 5.0), com), DecoratedInterval(interval(-10.0, 5.0), def)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.com), Interval(bareinterval(-10.0, 5.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0.9, 5.0), dac), DecoratedInterval(interval(1.0, 5.0), def)), DecoratedInterval(interval(-0x1.9999999999998P-4,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0.9, 5.0), IntervalArithmetic.dac), Interval(bareinterval(1.0, 5.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.9999999999998P-4,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0.0, 5.1), def), DecoratedInterval(interval(0.0, 5.0), def)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0.0, 5.1), IntervalArithmetic.def), Interval(bareinterval(0.0, 5.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.1), trv), DecoratedInterval(interval(1.0, 5.0), trv)), DecoratedInterval(interval(0.0,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.1), IntervalArithmetic.trv), Interval(bareinterval(1.0, 5.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0.9, 5.1), com), DecoratedInterval(interval(1.0, 5.0), trv)), DecoratedInterval(interval(-0x1.9999999999998P-4,0x1.999999999998P-4), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0.9, 5.1), IntervalArithmetic.com), Interval(bareinterval(1.0, 5.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.9999999999998P-4,0x1.999999999998P-4), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(1.0, 5.0), dac), DecoratedInterval(interval(1.0, 5.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(1.0, 5.0), IntervalArithmetic.dac), Interval(bareinterval(1.0, 5.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0, 1.0), def), DecoratedInterval(interval(-1.0, 5.0), def)), DecoratedInterval(interval(-4.0,-4.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-1.0, 5.0), IntervalArithmetic.def)), Interval(bareinterval(-4.0,-4.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-5.0, 0.0), trv), DecoratedInterval(interval(-0.0, 5.0), trv)), DecoratedInterval(interval(-5.0,-5.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-5.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 5.0), IntervalArithmetic.trv)), Interval(bareinterval(-5.0,-5.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), com), DecoratedInterval(interval(0x1.999999999999AP-4,0x1.999999999999AP-4), com)), DecoratedInterval(interval(0x1.E666666666656P+0,0x1.E666666666657P+0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), IntervalArithmetic.com), Interval(bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4), IntervalArithmetic.com)), Interval(bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), def), DecoratedInterval(interval(-0.01,0x1.999999999999AP-4), dac)), DecoratedInterval(interval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), IntervalArithmetic.def), Interval(bareinterval(-0.01,0x1.999999999999AP-4), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.70A3D70A3D70BP-4,0x1.E666666666657P+0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), com)), DecoratedInterval(interval(0.0,0x1P+971), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1P+971), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-0x1P+971,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-0x1P+971,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFEP+1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), com), DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.com), Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), com), DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), dac)), DecoratedInterval(interval(0x0.0000000000002p-1022,0x0.0000000000002p-1022), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.com), Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), IntervalArithmetic.dac)), Interval(bareinterval(0x0.0000000000002p-1022,0x0.0000000000002p-1022), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x1P-1022,0x1.0000000000002P-1022), dac), DecoratedInterval(interval(0x1P-1022,0x1.0000000000001P-1022), dac)), DecoratedInterval(interval(0.0,0x0.0000000000001P-1022), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x1P-1022,0x1.0000000000002P-1022), IntervalArithmetic.dac), Interval(bareinterval(0x1P-1022,0x1.0000000000001P-1022), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x0.0000000000001P-1022), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(0x1P-1022,0x1.0000000000001P-1022), def), DecoratedInterval(interval(0x1P-1022,0x1.0000000000002P-1022), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(0x1P-1022,0x1.0000000000001P-1022), IntervalArithmetic.def), Interval(bareinterval(0x1P-1022,0x1.0000000000002P-1022), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), com), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFEP-53,0x1P+0), dac)), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFFP-53), IntervalArithmetic.com), Interval(bareinterval(-0x1.FFFFFFFFFFFFEP-53,0x1P+0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.FFFFFFFFFFFFFP-1,-0x1.FFFFFFFFFFFFEP-1), IntervalArithmetic.trv)) - @test isequal_interval(cancelminus(DecoratedInterval(interval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), def), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFP-53,0x1P+0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cancelminus(Interval(bareinterval(-0x1P+0,0x1.FFFFFFFFFFFFEP-53), IntervalArithmetic.def), Interval(bareinterval(-0x1.FFFFFFFFFFFFFP-53,0x1P+0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end diff --git a/test/test_ITF1788/libieeep1788_class.jl b/test/test_ITF1788/libieeep1788_class.jl index 32078e41d..04a8821c0 100755 --- a/test/test_ITF1788/libieeep1788_class.jl +++ b/test/test_ITF1788/libieeep1788_class.jl @@ -1,451 +1,451 @@ @testset "minimal_nums_to_interval_test" begin - @test isequal_interval(interval(-1.0,1.0), interval(-1.0,1.0)) + @test isequal_interval(bareinterval(-1.0,1.0), bareinterval(-1.0,1.0)) - @test isequal_interval(interval(-Inf,1.0), interval(-Inf,1.0)) + @test isequal_interval(bareinterval(-Inf,1.0), bareinterval(-Inf,1.0)) - @test isequal_interval(interval(-1.0,Inf), interval(-1.0,Inf)) + @test isequal_interval(bareinterval(-1.0,Inf), bareinterval(-1.0,Inf)) - @test isequal_interval(interval(-Inf,Inf), interval(-Inf,Inf)) + @test isequal_interval(bareinterval(-Inf,Inf), bareinterval(-Inf,Inf)) - @test isequal_interval(interval(NaN,NaN), emptyinterval()) + @test isequal_interval(bareinterval(NaN,NaN), emptyinterval(BareInterval{Float64})) - @test isequal_interval(interval(1.0,-1.0), emptyinterval()) + @test isequal_interval(bareinterval(1.0,-1.0), emptyinterval(BareInterval{Float64})) - @test isequal_interval(interval(-Inf,-Inf), emptyinterval()) + @test isequal_interval(bareinterval(-Inf,-Inf), emptyinterval(BareInterval{Float64})) - @test isequal_interval(interval(Inf,Inf), emptyinterval()) + @test isequal_interval(bareinterval(Inf,Inf), emptyinterval(BareInterval{Float64})) end @testset "minimal_nums_to_decorated_interval_test" begin - @test isequal_interval(DecoratedInterval(-1.0,1.0), DecoratedInterval(interval(-1.0,1.0), com)) + @test isequal_interval(interval(-1.0,1.0), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(-Inf,1.0), DecoratedInterval(interval(-Inf,1.0), dac)) + @test isequal_interval(interval(-Inf,1.0), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(-1.0,Inf), DecoratedInterval(interval(-1.0,Inf), dac)) + @test isequal_interval(interval(-1.0,Inf), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(-Inf,Inf), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(interval(-Inf,Inf), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isnai(DecoratedInterval(NaN,NaN)) + @test isnai(interval(NaN,NaN)) - @test isnai(DecoratedInterval(1.0,-1.0)) + @test isnai(interval(1.0,-1.0)) - @test isnai(DecoratedInterval(-Inf,-Inf)) + @test isnai(interval(-Inf,-Inf)) - @test isnai(DecoratedInterval(Inf,Inf)) + @test isnai(interval(Inf,Inf)) end @testset "minimal_text_to_interval_test" begin - @test isequal_interval(parse(Interval{Float64}, "[ Empty ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Empty ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ Empty ]_trv"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Empty ]_trv"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ ]_trv"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ ]_trv"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[,]"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[,]"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[,]_trv"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[,]_trv"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ entire ]"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[ entire ]"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[ ENTIRE ]_dac"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ ENTIRE ]_dac"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ ENTIRE ]"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[ ENTIRE ]"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[ -inf , INF ]"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[ -inf , INF ]"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[ -inf, INF ]_def"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ -inf, INF ]_def"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-1.0,1.0]"), interval(-1.0,1.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[-1.0,1.0]"), bareinterval(-1.0,1.0)) - @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0 ]"), interval(-1.0,1.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1.0 , 1.0 ]"), bareinterval(-1.0,1.0)) - @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0]"), interval(-1.0,1.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1.0 , 1.0]"), bareinterval(-1.0,1.0)) - @test isequal_interval(parse(Interval{Float64}, "[-1,]"), interval(-1.0,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[-1,]"), bareinterval(-1.0,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[-1.0, +inf]"), interval(-1.0,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[-1.0, +inf]"), bareinterval(-1.0,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[-1.0, +infinity]"), interval(-1.0,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[-1.0, +infinity]"), bareinterval(-1.0,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[-Inf, 1.000 ]"), interval(-Inf,1.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[-Inf, 1.000 ]"), bareinterval(-Inf,1.0)) - @test isequal_interval(parse(Interval{Float64}, "[-Infinity, 1.000 ]"), interval(-Inf,1.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[-Infinity, 1.000 ]"), bareinterval(-Inf,1.0)) - @test isequal_interval(parse(Interval{Float64}, "[1.0E+400 ]"), interval(0x1.fffffffffffffp+1023,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.0E+400 ]"), bareinterval(0x1.fffffffffffffp+1023,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[ -4/2, 10/5 ]"), interval(-2.0,2.0)) + @test isequal_interval(parse(BareInterval{Float64}, "[ -4/2, 10/5 ]"), bareinterval(-2.0,2.0)) - @test isequal_interval(parse(Interval{Float64}, "[ -1/10, 1/10 ]"), interval(-0.1,0.1)) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1/10, 1/10 ]"), bareinterval(-0.1,0.1)) - @test isequal_interval(parse(Interval{Float64}, "0.0?"), interval(-0.05,0.05)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0?"), bareinterval(-0.05,0.05)) - @test isequal_interval(parse(Interval{Float64}, "0.0?u"), interval(0.0,0.05)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0?u"), bareinterval(0.0,0.05)) - @test isequal_interval(parse(Interval{Float64}, "0.0?d"), interval(-0.05,0.0)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0?d"), bareinterval(-0.05,0.0)) - @test isequal_interval(parse(Interval{Float64}, "2.5?"), interval(0x1.3999999999999p+1,0x1.4666666666667p+1)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5?"), bareinterval(0x1.3999999999999p+1,0x1.4666666666667p+1)) - @test isequal_interval(parse(Interval{Float64}, "2.5?u"), interval(2.5,0x1.4666666666667p+1)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5?u"), bareinterval(2.5,0x1.4666666666667p+1)) - @test isequal_interval(parse(Interval{Float64}, "2.5?d"), interval(0x1.3999999999999p+1,2.5)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5?d"), bareinterval(0x1.3999999999999p+1,2.5)) - @test isequal_interval(parse(Interval{Float64}, "0.000?5"), interval(-0.005,0.005)) + @test isequal_interval(parse(BareInterval{Float64}, "0.000?5"), bareinterval(-0.005,0.005)) - @test isequal_interval(parse(Interval{Float64}, "0.000?5u"), interval(0.0,0.005)) + @test isequal_interval(parse(BareInterval{Float64}, "0.000?5u"), bareinterval(0.0,0.005)) - @test isequal_interval(parse(Interval{Float64}, "0.000?5d"), interval(-0.005,0.0)) + @test isequal_interval(parse(BareInterval{Float64}, "0.000?5d"), bareinterval(-0.005,0.0)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5"), interval(0x1.3f5c28f5c28f5p+1,0x1.40a3d70a3d70bp+1)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5"), bareinterval(0x1.3f5c28f5c28f5p+1,0x1.40a3d70a3d70bp+1)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5u"), interval(2.5,0x1.40a3d70a3d70bp+1)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5u"), bareinterval(2.5,0x1.40a3d70a3d70bp+1)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5d"), interval(0x1.3f5c28f5c28f5p+1,2.5)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5d"), bareinterval(0x1.3f5c28f5c28f5p+1,2.5)) - @test isequal_interval(parse(Interval{Float64}, "0.0??"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0??"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "0.0??u"), interval(0.0,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0??u"), bareinterval(0.0,Inf)) - @test isequal_interval(parse(Interval{Float64}, "0.0??d"), interval(-Inf,0.0)) + @test isequal_interval(parse(BareInterval{Float64}, "0.0??d"), bareinterval(-Inf,0.0)) - @test isequal_interval(parse(Interval{Float64}, "2.5??"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5??"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "2.5??u"), interval(2.5,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5??u"), bareinterval(2.5,Inf)) - @test isequal_interval(parse(Interval{Float64}, "2.5??d"), interval(-Inf,2.5)) + @test isequal_interval(parse(BareInterval{Float64}, "2.5??d"), bareinterval(-Inf,2.5)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5e+27"), interval(0x1.01fa19a08fe7fp+91,0x1.0302cc4352683p+91)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5e+27"), bareinterval(0x1.01fa19a08fe7fp+91,0x1.0302cc4352683p+91)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5ue4"), interval(0x1.86ap+14,0x1.8768p+14)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5ue4"), bareinterval(0x1.86ap+14,0x1.8768p+14)) - @test isequal_interval(parse(Interval{Float64}, "2.500?5de-5"), interval(0x1.a2976f1cee4d5p-16,0x1.a36e2eb1c432dp-16)) + @test isequal_interval(parse(BareInterval{Float64}, "2.500?5de-5"), bareinterval(0x1.a2976f1cee4d5p-16,0x1.a36e2eb1c432dp-16)) - @test isequal_interval(parse(Interval{Float64}, "10?3"), interval(7.0,13.0)) + @test isequal_interval(parse(BareInterval{Float64}, "10?3"), bareinterval(7.0,13.0)) - @test isequal_interval(parse(Interval{Float64}, "10?3e380"), interval(0x1.fffffffffffffp+1023,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "10?3e380"), bareinterval(0x1.fffffffffffffp+1023,Inf)) - @test isequal_interval(parse(Interval{Float64}, "1.0000000000000001?1"), interval(1.0,0x1.0000000000001p+0)) + @test isequal_interval(parse(BareInterval{Float64}, "1.0000000000000001?1"), bareinterval(1.0,0x1.0000000000001p+0)) - @test isequal_interval(parse(Interval{Float64}, "10?1800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), interval(-Inf,Inf)) + @test isequal_interval(parse(BareInterval{Float64}, "10?1800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), bareinterval(-Inf,Inf)) - @test isequal_interval(parse(Interval{Float64}, "[ Nai ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Nai ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ Nai ]_ill"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Nai ]_ill"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ Nai ]_trv"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Nai ]_trv"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ Empty ]_ill"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Empty ]_ill"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ ]_com"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ ]_com"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[,]_com"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[,]_com"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ Entire ]_com"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ Entire ]_com"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ -inf , INF ]_com"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ -inf , INF ]_com"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0]_ill"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1.0 , 1.0]_ill"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0]_fooo"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1.0 , 1.0]_fooo"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0]_da"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ -1.0 , 1.0]_da"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-1.0,]_com"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[-1.0,]_com"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-Inf, 1.000 ]_ill"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[-Inf, 1.000 ]_ill"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-I nf, 1.000 ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[-I nf, 1.000 ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-Inf, 1.0 00 ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[-Inf, 1.0 00 ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[-Inf ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[-Inf ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[Inf , INF]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[Inf , INF]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[ foo ]"), emptyinterval()) + @test isequal_interval(parse(BareInterval{Float64}, "[ foo ]"), emptyinterval(BareInterval{Float64})) - @test isequal_interval(parse(Interval{Float64}, "[1.0000000000000002,1.0000000000000001]"), interval(1.0,0x1.0000000000001p+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[1.0000000000000002,1.0000000000000001]"), bareinterval(1.0,0x1.0000000000001p+0)) - @test isequal_interval(parse(Interval{Float64}, "[10000000000000001/10000000000000000,10000000000000002/10000000000000001]"), interval(1.0,0x1.0000000000001p+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[10000000000000001/10000000000000000,10000000000000002/10000000000000001]"), bareinterval(1.0,0x1.0000000000001p+0)) - @test isequal_interval(parse(Interval{Float64}, "[0x1.00000000000002p0,0x1.00000000000001p0]"), interval(1.0,0x1.0000000000001p+0)) + @test isequal_interval(parse(BareInterval{Float64}, "[0x1.00000000000002p0,0x1.00000000000001p0]"), bareinterval(1.0,0x1.0000000000001p+0)) end @testset "minimal_text_to_decorated_interval_test" begin - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ Empty ]"), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ Empty ]"), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ Empty ]_trv"), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ Empty ]_trv"), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ ]"), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ ]"), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ ]_trv"), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ ]_trv"), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[,]"), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(parse(Interval{Float64}, "[,]"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[,]_trv"), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(parse(Interval{Float64}, "[,]_trv"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ entire ]"), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(parse(Interval{Float64}, "[ entire ]"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ ENTIRE ]_dac"), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(parse(Interval{Float64}, "[ ENTIRE ]_dac"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -inf , INF ]"), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(parse(Interval{Float64}, "[ -inf , INF ]"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -inf, INF ]_def"), DecoratedInterval(entireinterval(), def)) + @test isequal_interval(parse(Interval{Float64}, "[ -inf, INF ]_def"), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-1.0,1.0]"), DecoratedInterval(interval(-1.0,1.0), com)) + @test isequal_interval(parse(Interval{Float64}, "[-1.0,1.0]"), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -1.0 , 1.0 ]_com"), DecoratedInterval(interval(-1.0,1.0), com)) + @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0 ]_com"), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -1.0 , 1.0]_trv"), DecoratedInterval(interval(-1.0,1.0), trv)) + @test isequal_interval(parse(Interval{Float64}, "[ -1.0 , 1.0]_trv"), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-1,]"), DecoratedInterval(interval(-1.0,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "[-1,]"), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-1.0, +inf]_def"), DecoratedInterval(interval(-1.0,Inf), def)) + @test isequal_interval(parse(Interval{Float64}, "[-1.0, +inf]_def"), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-1.0, +infinity]_def"), DecoratedInterval(interval(-1.0,Inf), def)) + @test isequal_interval(parse(Interval{Float64}, "[-1.0, +infinity]_def"), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-Inf, 1.000 ]"), DecoratedInterval(interval(-Inf,1.0), dac)) + @test isequal_interval(parse(Interval{Float64}, "[-Inf, 1.000 ]"), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[-Infinity, 1.000 ]_trv"), DecoratedInterval(interval(-Inf,1.0), trv)) + @test isequal_interval(parse(Interval{Float64}, "[-Infinity, 1.000 ]_trv"), Interval(bareinterval(-Inf,1.0), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[1.0E+400 ]_com"), DecoratedInterval(interval(0x1.fffffffffffffp+1023,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "[1.0E+400 ]_com"), Interval(bareinterval(0x1.fffffffffffffp+1023,Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -4/2, 10/5 ]_com"), DecoratedInterval(interval(-2.0,2.0), com)) + @test isequal_interval(parse(Interval{Float64}, "[ -4/2, 10/5 ]_com"), Interval(bareinterval(-2.0,2.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[ -1/10, 1/10 ]_com"), DecoratedInterval(interval(-0.1,0.1), com)) + @test isequal_interval(parse(Interval{Float64}, "[ -1/10, 1/10 ]_com"), Interval(bareinterval(-0.1,0.1), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0?"), DecoratedInterval(interval(-0.05,0.05), com)) + @test isequal_interval(parse(Interval{Float64}, "0.0?"), Interval(bareinterval(-0.05,0.05), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0?u_trv"), DecoratedInterval(interval(0.0,0.05), trv)) + @test isequal_interval(parse(Interval{Float64}, "0.0?u_trv"), Interval(bareinterval(0.0,0.05), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0?d_dac"), DecoratedInterval(interval(-0.05,0.0), dac)) + @test isequal_interval(parse(Interval{Float64}, "0.0?d_dac"), Interval(bareinterval(-0.05,0.0), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5?"), DecoratedInterval(interval(0x1.3999999999999p+1,0x1.4666666666667p+1), com)) + @test isequal_interval(parse(Interval{Float64}, "2.5?"), Interval(bareinterval(0x1.3999999999999p+1,0x1.4666666666667p+1), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5?u"), DecoratedInterval(interval(2.5,0x1.4666666666667p+1), com)) + @test isequal_interval(parse(Interval{Float64}, "2.5?u"), Interval(bareinterval(2.5,0x1.4666666666667p+1), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5?d_trv"), DecoratedInterval(interval(0x1.3999999999999p+1,2.5), trv)) + @test isequal_interval(parse(Interval{Float64}, "2.5?d_trv"), Interval(bareinterval(0x1.3999999999999p+1,2.5), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.000?5"), DecoratedInterval(interval(-0.005,0.005), com)) + @test isequal_interval(parse(Interval{Float64}, "0.000?5"), Interval(bareinterval(-0.005,0.005), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.000?5u_def"), DecoratedInterval(interval(0.0,0.005), def)) + @test isequal_interval(parse(Interval{Float64}, "0.000?5u_def"), Interval(bareinterval(0.0,0.005), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.000?5d"), DecoratedInterval(interval(-0.005,0.0), com)) + @test isequal_interval(parse(Interval{Float64}, "0.000?5d"), Interval(bareinterval(-0.005,0.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5"), DecoratedInterval(interval(0x1.3f5c28f5c28f5p+1,0x1.40a3d70a3d70bp+1), com)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5"), Interval(bareinterval(0x1.3f5c28f5c28f5p+1,0x1.40a3d70a3d70bp+1), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5u"), DecoratedInterval(interval(2.5,0x1.40a3d70a3d70bp+1), com)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5u"), Interval(bareinterval(2.5,0x1.40a3d70a3d70bp+1), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5d"), DecoratedInterval(interval(0x1.3f5c28f5c28f5p+1,2.5), com)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5d"), Interval(bareinterval(0x1.3f5c28f5c28f5p+1,2.5), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0??_dac"), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "0.0??_dac"), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0??u_trv"), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(parse(Interval{Float64}, "0.0??u_trv"), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "0.0??d"), DecoratedInterval(interval(-Inf,0.0), dac)) + @test isequal_interval(parse(Interval{Float64}, "0.0??d"), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5??"), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "2.5??"), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5??u_def"), DecoratedInterval(interval(2.5,Inf), def)) + @test isequal_interval(parse(Interval{Float64}, "2.5??u_def"), Interval(bareinterval(2.5,Inf), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.5??d_dac"), DecoratedInterval(interval(-Inf,2.5), dac)) + @test isequal_interval(parse(Interval{Float64}, "2.5??d_dac"), Interval(bareinterval(-Inf,2.5), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5e+27"), DecoratedInterval(interval(0x1.01fa19a08fe7fp+91,0x1.0302cc4352683p+91), com)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5e+27"), Interval(bareinterval(0x1.01fa19a08fe7fp+91,0x1.0302cc4352683p+91), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5ue4_def"), DecoratedInterval(interval(0x1.86ap+14,0x1.8768p+14), def)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5ue4_def"), Interval(bareinterval(0x1.86ap+14,0x1.8768p+14), IntervalArithmetic.def)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "2.500?5de-5"), DecoratedInterval(interval(0x1.a2976f1cee4d5p-16,0x1.a36e2eb1c432dp-16), com)) + @test isequal_interval(parse(Interval{Float64}, "2.500?5de-5"), Interval(bareinterval(0x1.a2976f1cee4d5p-16,0x1.a36e2eb1c432dp-16), IntervalArithmetic.com)) - @test isnai(parse(DecoratedInterval{Float64}, "[ Nai ]")) + @test isnai(parse(Interval{Float64}, "[ Nai ]")) - @test isequal_interval(parse(DecoratedInterval{Float64}, "10?1800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_com"), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "10?1800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_com"), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "10?3_com"), DecoratedInterval(interval(7.0,13.0), com)) + @test isequal_interval(parse(Interval{Float64}, "10?3_com"), Interval(bareinterval(7.0,13.0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "10?3e380_com"), DecoratedInterval(interval(0x1.fffffffffffffp+1023,Inf), dac)) + @test isequal_interval(parse(Interval{Float64}, "10?3e380_com"), Interval(bareinterval(0x1.fffffffffffffp+1023,Inf), IntervalArithmetic.dac)) - @test isnai(parse(DecoratedInterval{Float64}, "[ Nai ]_ill")) + @test isnai(parse(Interval{Float64}, "[ Nai ]_ill")) - @test isnai(parse(DecoratedInterval{Float64}, "[ Nai ]_trv")) + @test isnai(parse(Interval{Float64}, "[ Nai ]_trv")) - @test isnai(parse(DecoratedInterval{Float64}, "[ Empty ]_ill")) + @test isnai(parse(Interval{Float64}, "[ Empty ]_ill")) - @test isnai(parse(DecoratedInterval{Float64}, "[ ]_com")) + @test isnai(parse(Interval{Float64}, "[ ]_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[,]_com")) + @test isnai(parse(Interval{Float64}, "[,]_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[ Entire ]_com")) + @test isnai(parse(Interval{Float64}, "[ Entire ]_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[ -inf , INF ]_com")) + @test isnai(parse(Interval{Float64}, "[ -inf , INF ]_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[ -1.0 , 1.0]_ill")) + @test isnai(parse(Interval{Float64}, "[ -1.0 , 1.0]_ill")) - @test isnai(parse(DecoratedInterval{Float64}, "[ -1.0 , 1.0]_fooo")) + @test isnai(parse(Interval{Float64}, "[ -1.0 , 1.0]_fooo")) - @test isnai(parse(DecoratedInterval{Float64}, "[ -1.0 , 1.0]_da")) + @test isnai(parse(Interval{Float64}, "[ -1.0 , 1.0]_da")) - @test isnai(parse(DecoratedInterval{Float64}, "[-1.0,]_com")) + @test isnai(parse(Interval{Float64}, "[-1.0,]_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[-Inf, 1.000 ]_ill")) + @test isnai(parse(Interval{Float64}, "[-Inf, 1.000 ]_ill")) - @test isnai(parse(DecoratedInterval{Float64}, "[-I nf, 1.000 ]")) + @test isnai(parse(Interval{Float64}, "[-I nf, 1.000 ]")) - @test isnai(parse(DecoratedInterval{Float64}, "[-Inf, 1.0 00 ]")) + @test isnai(parse(Interval{Float64}, "[-Inf, 1.0 00 ]")) - @test isnai(parse(DecoratedInterval{Float64}, "[-Inf ]")) + @test isnai(parse(Interval{Float64}, "[-Inf ]")) - @test isnai(parse(DecoratedInterval{Float64}, "[Inf , INF]")) + @test isnai(parse(Interval{Float64}, "[Inf , INF]")) - @test isnai(parse(DecoratedInterval{Float64}, "[ foo ]")) + @test isnai(parse(Interval{Float64}, "[ foo ]")) - @test isnai(parse(DecoratedInterval{Float64}, "0.0??_com")) + @test isnai(parse(Interval{Float64}, "0.0??_com")) - @test isnai(parse(DecoratedInterval{Float64}, "0.0??u_ill")) + @test isnai(parse(Interval{Float64}, "0.0??u_ill")) - @test isnai(parse(DecoratedInterval{Float64}, "0.0??d_com")) + @test isnai(parse(Interval{Float64}, "0.0??d_com")) - @test isnai(parse(DecoratedInterval{Float64}, "0.0??_com")) + @test isnai(parse(Interval{Float64}, "0.0??_com")) - @test isnai(parse(DecoratedInterval{Float64}, "[1.0,2.0")) + @test isnai(parse(Interval{Float64}, "[1.0,2.0")) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[1.0000000000000002,1.0000000000000001]"), DecoratedInterval(interval(1.0,0x1.0000000000001p+0), com)) + @test isequal_interval(parse(Interval{Float64}, "[1.0000000000000002,1.0000000000000001]"), Interval(bareinterval(1.0,0x1.0000000000001p+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[10000000000000001/10000000000000000,10000000000000002/10000000000000001]"), DecoratedInterval(interval(1.0,0x1.0000000000001p+0), com)) + @test isequal_interval(parse(Interval{Float64}, "[10000000000000001/10000000000000000,10000000000000002/10000000000000001]"), Interval(bareinterval(1.0,0x1.0000000000001p+0), IntervalArithmetic.com)) - @test isequal_interval(parse(DecoratedInterval{Float64}, "[0x1.00000000000002p0,0x1.00000000000001p0]"), DecoratedInterval(interval(1.0,0x1.0000000000001p+0), com)) + @test isequal_interval(parse(Interval{Float64}, "[0x1.00000000000002p0,0x1.00000000000001p0]"), Interval(bareinterval(1.0,0x1.0000000000001p+0), IntervalArithmetic.com)) end @testset "minimal_interval_part_test" begin - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), trv)), interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), IntervalArithmetic.trv)), bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)), interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)), bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), dac)), interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), IntervalArithmetic.dac)), bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), def)), interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), IntervalArithmetic.def)), bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), trv)), interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), IntervalArithmetic.trv)), bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), trv)), interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.trv)), bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022)) - @test isequal_interval(interval(DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), trv)), interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)) + @test isequal_interval(bareinterval(Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.trv)), bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), trv)), interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), IntervalArithmetic.trv)), bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023)) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), trv)), interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.trv)), bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)) - @test isequal_interval(interval(DecoratedInterval(interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), trv)), interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)) + @test isequal_interval(bareinterval(Interval(bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.trv)), bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)) - @test isequal_interval(interval(DecoratedInterval(interval(-Inf,Inf), trv)), interval(-Inf,Inf)) + @test isequal_interval(bareinterval(Interval(bareinterval(-Inf,Inf), IntervalArithmetic.trv)), bareinterval(-Inf,Inf)) - @test isequal_interval(interval(DecoratedInterval(emptyinterval(), trv)), emptyinterval()) + @test isequal_interval(bareinterval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)), interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)) + @test isequal_interval(bareinterval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)), bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)) - @test_broken isequal_interval(interval(nai()), emptyinterval()) + @test isequal_interval(bareinterval(nai()), emptyinterval(BareInterval{Float64})) end @testset "minimal_new_dec_test" begin - @test isequal_interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4)), DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4)), Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4)), DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4)), Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4)), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4)), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)), DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), com)) + @test isequal_interval(Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022)), Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022)), DecoratedInterval(interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), com)) + @test isequal_interval(Interval(bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022)), Interval(bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)), DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), com)) + @test isequal_interval(Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022)), Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023)), DecoratedInterval(interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), com)) + @test isequal_interval(Interval(bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023)), Interval(bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)), DecoratedInterval(interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), com)) + @test isequal_interval(Interval(bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)), Interval(bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)), DecoratedInterval(interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), com)) + @test isequal_interval(Interval(bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023)), Interval(bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-Inf,Inf)), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(Interval(bareinterval(-Inf,Inf)), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(emptyinterval()), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64})), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4)), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)) end @testset "minimal_set_dec_test" begin - @test isequal_interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), trv), DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), trv)) + @test isequal_interval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), IntervalArithmetic.trv), Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.9999999999999P-4), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), dac), DecoratedInterval(interval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), dac)) + @test isequal_interval(Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), IntervalArithmetic.dac), Interval(bareinterval(-0x1.99999A842549Ap+4,0x1.99999A0000000p-4), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), def), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), def)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), IntervalArithmetic.def), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.99999A0000000p-4), IntervalArithmetic.def)) - @test isequal_interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), trv), DecoratedInterval(interval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), trv)) + @test isequal_interval(Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), IntervalArithmetic.trv), Interval(bareinterval(-0x0.0000000000001p-1022,-0x0.0000000000001p-1022), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), def), DecoratedInterval(interval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), def)) + @test isequal_interval(Interval(bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.def), Interval(bareinterval(-0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.def)) - @test isequal_interval(DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), dac), DecoratedInterval(interval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), dac)) + @test isequal_interval(Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.dac), Interval(bareinterval(0x0.0000000000001p-1022,0x0.0000000000001p-1022), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), com), DecoratedInterval(interval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), com)) + @test isequal_interval(Interval(bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), IntervalArithmetic.com), Interval(bareinterval(-0x1.fffffffffffffp+1023,-0x1.fffffffffffffp+1023), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), def), DecoratedInterval(interval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), def)) + @test isequal_interval(Interval(bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.def), Interval(bareinterval(-0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.def)) - @test isequal_interval(DecoratedInterval(interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), trv), DecoratedInterval(interval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), trv)) + @test isequal_interval(Interval(bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.trv), Interval(bareinterval(0x1.fffffffffffffp+1023,0x1.fffffffffffffp+1023), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(-Inf,Inf), dac), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com), DecoratedInterval(interval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), com)) + @test isequal_interval(Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com), Interval(bareinterval(-0x1.99999C0000000p+4,0x1.9999999999999P-4), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(emptyinterval(), def), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(emptyinterval(), dac), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(emptyinterval(), com), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(DecoratedInterval(interval(1.0,Inf), com), DecoratedInterval(interval(1.0,Inf), dac)) + @test isequal_interval(Interval(bareinterval(1.0,Inf), IntervalArithmetic.com), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(interval(-Inf,3.0), com), DecoratedInterval(interval(-Inf,3.0), dac)) + @test isequal_interval(Interval(bareinterval(-Inf,3.0), IntervalArithmetic.com), Interval(bareinterval(-Inf,3.0), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(interval(-Inf,Inf), com), DecoratedInterval(interval(-Inf,Inf), dac)) + @test isequal_interval(Interval(bareinterval(-Inf,Inf), IntervalArithmetic.com), Interval(bareinterval(-Inf,Inf), IntervalArithmetic.dac)) - @test isnai(DecoratedInterval(emptyinterval(), ill)) + @test isnai(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.ill)) - @test isnai(DecoratedInterval(interval(-Inf,3.0), ill)) + @test isnai(Interval(bareinterval(-Inf,3.0), IntervalArithmetic.ill)) - @test isnai(DecoratedInterval(interval(-1.0,3.0), ill)) + @test isnai(Interval(bareinterval(-1.0,3.0), IntervalArithmetic.ill)) end @testset "minimal_decoration_part_test" begin - @test decoration(nai()) == ill + @test decoration(nai()) == IntervalArithmetic.ill - @test decoration(DecoratedInterval(emptyinterval(), trv)) == trv + @test decoration(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == IntervalArithmetic.trv - @test decoration(DecoratedInterval(interval(-1.0,3.0), trv)) == trv + @test decoration(Interval(bareinterval(-1.0,3.0), IntervalArithmetic.trv)) == IntervalArithmetic.trv - @test decoration(DecoratedInterval(interval(-1.0,3.0), def)) == def + @test decoration(Interval(bareinterval(-1.0,3.0), IntervalArithmetic.def)) == IntervalArithmetic.def - @test decoration(DecoratedInterval(interval(-1.0,3.0), dac)) == dac + @test decoration(Interval(bareinterval(-1.0,3.0), IntervalArithmetic.dac)) == IntervalArithmetic.dac - @test decoration(DecoratedInterval(interval(-1.0,3.0), com)) == com + @test decoration(Interval(bareinterval(-1.0,3.0), IntervalArithmetic.com)) == IntervalArithmetic.com end diff --git a/test/test_ITF1788/libieeep1788_elem.jl b/test/test_ITF1788/libieeep1788_elem.jl index ba58444e3..df1914b1f 100644 --- a/test/test_ITF1788/libieeep1788_elem.jl +++ b/test/test_ITF1788/libieeep1788_elem.jl @@ -1,26 +1,26 @@ @testset "minimal_pos_test" begin - @test isequal_interval(+(interval(1.0,2.0)), interval(1.0,2.0)) + @test isequal_interval(+(bareinterval(1.0,2.0)), bareinterval(1.0,2.0)) - @test isequal_interval(+(emptyinterval()), emptyinterval()) + @test isequal_interval(+(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval()), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(1.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(+(bareinterval(1.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(+(interval(-Inf,-1.0)), interval(-Inf,-1.0)) + @test isequal_interval(+(bareinterval(-Inf,-1.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(+(interval(0.0,2.0)), interval(0.0,2.0)) + @test isequal_interval(+(bareinterval(0.0,2.0)), bareinterval(0.0,2.0)) - @test isequal_interval(+(interval(-0.0,2.0)), interval(0.0,2.0)) + @test isequal_interval(+(bareinterval(-0.0,2.0)), bareinterval(0.0,2.0)) - @test isequal_interval(+(interval(-2.5,-0.0)), interval(-2.5,0.0)) + @test isequal_interval(+(bareinterval(-2.5,-0.0)), bareinterval(-2.5,0.0)) - @test isequal_interval(+(interval(-2.5,0.0)), interval(-2.5,0.0)) + @test isequal_interval(+(bareinterval(-2.5,0.0)), bareinterval(-2.5,0.0)) - @test isequal_interval(+(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(+(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(+(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(+(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) end @@ -28,37 +28,37 @@ end @test isnai(+(nai())) - @test isequal_interval(+(DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(+(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(+(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(+(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(+(DecoratedInterval(interval(1.0, 2.0), com)), DecoratedInterval(interval(1.0, 2.0), com)) + @test isequal_interval(+(Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com)), Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com)) end @testset "minimal_neg_test" begin - @test isequal_interval(-(interval(1.0,2.0)), interval(-2.0,-1.0)) + @test isequal_interval(-(bareinterval(1.0,2.0)), bareinterval(-2.0,-1.0)) - @test isequal_interval(-(emptyinterval()), emptyinterval()) + @test isequal_interval(-(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval()), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(1.0,Inf)), interval(-Inf,-1.0)) + @test isequal_interval(-(bareinterval(1.0,Inf)), bareinterval(-Inf,-1.0)) - @test isequal_interval(-(interval(-Inf,1.0)), interval(-1.0,Inf)) + @test isequal_interval(-(bareinterval(-Inf,1.0)), bareinterval(-1.0,Inf)) - @test isequal_interval(-(interval(0.0,2.0)), interval(-2.0,0.0)) + @test isequal_interval(-(bareinterval(0.0,2.0)), bareinterval(-2.0,0.0)) - @test isequal_interval(-(interval(-0.0,2.0)), interval(-2.0,0.0)) + @test isequal_interval(-(bareinterval(-0.0,2.0)), bareinterval(-2.0,0.0)) - @test isequal_interval(-(interval(-2.0,0.0)), interval(0.0,2.0)) + @test isequal_interval(-(bareinterval(-2.0,0.0)), bareinterval(0.0,2.0)) - @test isequal_interval(-(interval(-2.0,-0.0)), interval(0.0,2.0)) + @test isequal_interval(-(bareinterval(-2.0,-0.0)), bareinterval(0.0,2.0)) - @test isequal_interval(-(interval(0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(-(bareinterval(0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(-(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(-(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) end @@ -66,7890 +66,7890 @@ end @test isnai(-(nai())) - @test isequal_interval(-(DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(-(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(-(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(-(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(-(DecoratedInterval(interval(1.0, 2.0), com)), DecoratedInterval(interval(-2.0, -1.0), com)) + @test isequal_interval(-(Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com)), Interval(bareinterval(-2.0, -1.0), IntervalArithmetic.com)) end @testset "minimal_add_test" begin - @test isequal_interval(+(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(+(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-1.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(+(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(emptyinterval(), interval(-1.0,1.0)), emptyinterval()) + @test isequal_interval(+(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(+(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), interval(-Inf,1.0)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(-Inf,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), interval(-1.0,1.0)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), interval(-1.0,Inf)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(-1.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-Inf,1.0), entireinterval()), entireinterval()) + @test isequal_interval(+(bareinterval(-Inf,1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-1.0,1.0), entireinterval()), entireinterval()) + @test isequal_interval(+(bareinterval(-1.0,1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-1.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(+(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-Inf,2.0), interval(-Inf,4.0)), interval(-Inf,6.0)) + @test isequal_interval(+(bareinterval(-Inf,2.0), bareinterval(-Inf,4.0)), bareinterval(-Inf,6.0)) - @test isequal_interval(+(interval(-Inf,2.0), interval(3.0,4.0)), interval(-Inf,6.0)) + @test isequal_interval(+(bareinterval(-Inf,2.0), bareinterval(3.0,4.0)), bareinterval(-Inf,6.0)) - @test isequal_interval(+(interval(-Inf,2.0), interval(3.0,Inf)), entireinterval()) + @test isequal_interval(+(bareinterval(-Inf,2.0), bareinterval(3.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(1.0,2.0), interval(-Inf,4.0)), interval(-Inf,6.0)) + @test isequal_interval(+(bareinterval(1.0,2.0), bareinterval(-Inf,4.0)), bareinterval(-Inf,6.0)) - @test isequal_interval(+(interval(1.0,2.0), interval(3.0,4.0)), interval(4.0,6.0)) + @test isequal_interval(+(bareinterval(1.0,2.0), bareinterval(3.0,4.0)), bareinterval(4.0,6.0)) - @test isequal_interval(+(interval(1.0,2.0), interval(3.0,Inf)), interval(4.0,Inf)) + @test isequal_interval(+(bareinterval(1.0,2.0), bareinterval(3.0,Inf)), bareinterval(4.0,Inf)) - @test isequal_interval(+(interval(1.0,Inf), interval(-Inf,4.0)), entireinterval()) + @test isequal_interval(+(bareinterval(1.0,Inf), bareinterval(-Inf,4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(1.0,Inf), interval(3.0,4.0)), interval(4.0,Inf)) + @test isequal_interval(+(bareinterval(1.0,Inf), bareinterval(3.0,4.0)), bareinterval(4.0,Inf)) - @test isequal_interval(+(interval(1.0,Inf), interval(3.0,Inf)), interval(4.0,Inf)) + @test isequal_interval(+(bareinterval(1.0,Inf), bareinterval(3.0,Inf)), bareinterval(4.0,Inf)) - @test isequal_interval(+(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(3.0,4.0)), interval(4.0,Inf)) + @test isequal_interval(+(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(3.0,4.0)), bareinterval(4.0,Inf)) - @test isequal_interval(+(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), interval(-3.0,4.0)), interval(-Inf,6.0)) + @test isequal_interval(+(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), bareinterval(-3.0,4.0)), bareinterval(-Inf,6.0)) - @test isequal_interval(+(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), interval(-3.0,0x1.FFFFFFFFFFFFFp1023)), entireinterval()) + @test isequal_interval(+(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), bareinterval(-3.0,0x1.FFFFFFFFFFFFFp1023)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(0.0,0.0)), interval(1.0,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(+(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(0.0,0.0)), bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(+(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(-0.0,-0.0)), interval(1.0,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(+(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0.0,-0.0)), bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(+(interval(0.0,0.0), interval(-3.0,4.0)), interval(-3.0,4.0)) + @test isequal_interval(+(bareinterval(0.0,0.0), bareinterval(-3.0,4.0)), bareinterval(-3.0,4.0)) - @test isequal_interval(+(interval(-0.0,-0.0), interval(-3.0,0x1.FFFFFFFFFFFFFp1023)), interval(-3.0,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(+(bareinterval(-0.0,-0.0), bareinterval(-3.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-3.0,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(+(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(0x1.0CCCCCCCCCCC4P+1,0x1.0CCCCCCCCCCC5P+1)) + @test isequal_interval(+(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(0x1.0CCCCCCCCCCC4P+1,0x1.0CCCCCCCCCCC5P+1)) - @test isequal_interval(+(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), interval(0x1.E666666666656P+0,0x1.E666666666657P+0)) + @test isequal_interval(+(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0)) - @test isequal_interval(+(interval(-0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(-0x1.E666666666657P+0,0x1.0CCCCCCCCCCC5P+1)) + @test isequal_interval(+(bareinterval(-0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(-0x1.E666666666657P+0,0x1.0CCCCCCCCCCC5P+1)) end @testset "minimal_add_dec_test" begin - @test isequal_interval(+(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), com)), DecoratedInterval(interval(6.0,9.0), com)) + @test isequal_interval(+(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.com)), Interval(bareinterval(6.0,9.0), IntervalArithmetic.com)) - @test isequal_interval(+(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), def)), DecoratedInterval(interval(6.0,9.0), def)) + @test isequal_interval(+(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.def)), Interval(bareinterval(6.0,9.0), IntervalArithmetic.def)) - @test isequal_interval(+(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(6.0,Inf), dac)) + @test isequal_interval(+(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(6.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(+(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), com), DecoratedInterval(interval(-0.1, 5.0), com)), DecoratedInterval(interval(-Inf,7.0), dac)) + @test isequal_interval(+(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), IntervalArithmetic.com), Interval(bareinterval(-0.1, 5.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,7.0), IntervalArithmetic.dac)) - @test isequal_interval(+(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(+(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isnai(+(nai(), DecoratedInterval(interval(1.0,2.0), trv))) + @test isnai(+(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv))) end @testset "minimal_sub_test" begin - @test isequal_interval(-(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(-(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-1.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(-(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(emptyinterval(), interval(-1.0,1.0)), emptyinterval()) + @test isequal_interval(-(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(-(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), interval(-Inf,1.0)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(-Inf,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), interval(-1.0,1.0)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), interval(-1.0,Inf)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(-1.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-Inf,1.0), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(-Inf,1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-1.0,1.0), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(-1.0,1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-1.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-Inf,2.0), interval(-Inf,4.0)), entireinterval()) + @test isequal_interval(-(bareinterval(-Inf,2.0), bareinterval(-Inf,4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-Inf,2.0), interval(3.0,4.0)), interval(-Inf,-1.0)) + @test isequal_interval(-(bareinterval(-Inf,2.0), bareinterval(3.0,4.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(-(interval(-Inf,2.0), interval(3.0,Inf)), interval(-Inf,-1.0)) + @test isequal_interval(-(bareinterval(-Inf,2.0), bareinterval(3.0,Inf)), bareinterval(-Inf,-1.0)) - @test isequal_interval(-(interval(1.0,2.0), interval(-Inf,4.0)), interval(-3.0,Inf)) + @test isequal_interval(-(bareinterval(1.0,2.0), bareinterval(-Inf,4.0)), bareinterval(-3.0,Inf)) - @test isequal_interval(-(interval(1.0,2.0), interval(3.0,4.0)), interval(-3.0,-1.0)) + @test isequal_interval(-(bareinterval(1.0,2.0), bareinterval(3.0,4.0)), bareinterval(-3.0,-1.0)) - @test isequal_interval(-(interval(1.0,2.0), interval(3.0,Inf)), interval(-Inf,-1.0)) + @test isequal_interval(-(bareinterval(1.0,2.0), bareinterval(3.0,Inf)), bareinterval(-Inf,-1.0)) - @test isequal_interval(-(interval(1.0,Inf), interval(-Inf,4.0)), interval(-3.0,Inf)) + @test isequal_interval(-(bareinterval(1.0,Inf), bareinterval(-Inf,4.0)), bareinterval(-3.0,Inf)) - @test isequal_interval(-(interval(1.0,Inf), interval(3.0,4.0)), interval(-3.0,Inf)) + @test isequal_interval(-(bareinterval(1.0,Inf), bareinterval(3.0,4.0)), bareinterval(-3.0,Inf)) - @test isequal_interval(-(interval(1.0,Inf), interval(3.0,Inf)), entireinterval()) + @test isequal_interval(-(bareinterval(1.0,Inf), bareinterval(3.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(-3.0,4.0)), interval(-3.0,Inf)) + @test isequal_interval(-(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(-3.0,4.0)), bareinterval(-3.0,Inf)) - @test isequal_interval(-(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), interval(3.0,4.0)), interval(-Inf,-1.0)) + @test isequal_interval(-(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), bareinterval(3.0,4.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(-(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), interval(-0x1.FFFFFFFFFFFFFp1023,4.0)), entireinterval()) + @test isequal_interval(-(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), bareinterval(-0x1.FFFFFFFFFFFFFp1023,4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(0.0,0.0)), interval(1.0,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(-(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(0.0,0.0)), bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(-(interval(1.0,0x1.FFFFFFFFFFFFFp1023), interval(-0.0,-0.0)), interval(1.0,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(-(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023), bareinterval(-0.0,-0.0)), bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(-(interval(0.0,0.0), interval(-3.0,4.0)), interval(-4.0,3.0)) + @test isequal_interval(-(bareinterval(0.0,0.0), bareinterval(-3.0,4.0)), bareinterval(-4.0,3.0)) - @test isequal_interval(-(interval(-0.0,-0.0), interval(-3.0,0x1.FFFFFFFFFFFFFp1023)), interval(-0x1.FFFFFFFFFFFFFp1023,3.0)) + @test isequal_interval(-(bareinterval(-0.0,-0.0), bareinterval(-3.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-0x1.FFFFFFFFFFFFFp1023,3.0)) - @test isequal_interval(-(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(0x1.E666666666656P+0,0x1.E666666666657P+0)) + @test isequal_interval(-(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(0x1.E666666666656P+0,0x1.E666666666657P+0)) - @test isequal_interval(-(interval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), interval(0x1.0CCCCCCCCCCC4P+1,0x1.0CCCCCCCCCCC5P+1)) + @test isequal_interval(-(bareinterval(0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.999999999999AP-4,-0x1.999999999999AP-4)), bareinterval(0x1.0CCCCCCCCCCC4P+1,0x1.0CCCCCCCCCCC5P+1)) - @test isequal_interval(-(interval(-0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(-0x1.0CCCCCCCCCCC5P+1,0x1.E666666666657P+0)) + @test isequal_interval(-(bareinterval(-0x1.FFFFFFFFFFFFP+0,0x1.FFFFFFFFFFFFP+0), bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(-0x1.0CCCCCCCCCCC5P+1,0x1.E666666666657P+0)) end @testset "minimal_sub_dec_test" begin - @test isequal_interval(-(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), com)), DecoratedInterval(interval(-6.0,-3.0), com)) + @test isequal_interval(-(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.com)), Interval(bareinterval(-6.0,-3.0), IntervalArithmetic.com)) - @test isequal_interval(-(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), def)), DecoratedInterval(interval(-6.0,-3.0), def)) + @test isequal_interval(-(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.def)), Interval(bareinterval(-6.0,-3.0), IntervalArithmetic.def)) - @test isequal_interval(-(DecoratedInterval(interval(-1.0,2.0), com), DecoratedInterval(interval(5.0,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-Inf,-3.0), dac)) + @test isequal_interval(-(Interval(bareinterval(-1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-Inf,-3.0), IntervalArithmetic.dac)) - @test isequal_interval(-(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), com), DecoratedInterval(interval(-1.0, 5.0), com)), DecoratedInterval(interval(-Inf,3.0), dac)) + @test isequal_interval(-(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), IntervalArithmetic.com), Interval(bareinterval(-1.0, 5.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,3.0), IntervalArithmetic.dac)) - @test isequal_interval(-(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(-(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isnai(-(nai(), DecoratedInterval(interval(1.0,2.0), trv))) + @test isnai(-(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv))) end @testset "minimal_mul_test" begin - @test isequal_interval(*(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(*(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(*(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(emptyinterval(), interval(-1.0,1.0)), emptyinterval()) + @test isequal_interval(*(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(*(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(*(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(emptyinterval(), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(*(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(*(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(emptyinterval(), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(*(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(entireinterval(), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(entireinterval(), interval(-5.0, -1.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(1.0, 3.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(1.0, Inf)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(1.0,Inf), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(1.0,Inf), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(1.0,Inf), interval(-5.0, -1.0)), interval(-Inf,-1.0)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(*(interval(1.0,Inf), interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(1.0,Inf), interval(1.0, 3.0)), interval(1.0,Inf)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(1.0, 3.0)), bareinterval(1.0,Inf)) - @test isequal_interval(*(interval(1.0,Inf), interval(-Inf, -1.0)), interval(-Inf,-1.0)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(*(interval(1.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(1.0,Inf), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(1.0,Inf), interval(1.0, Inf)), interval(1.0,Inf)) + @test isequal_interval(*(bareinterval(1.0,Inf), bareinterval(1.0, Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(*(interval(1.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-1.0,Inf), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-1.0,Inf), interval(-5.0, -1.0)), interval(-Inf,5.0)) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0)), bareinterval(-Inf,5.0)) - @test isequal_interval(*(interval(-1.0,Inf), interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), interval(1.0, 3.0)), interval(-3.0,Inf)) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0)), bareinterval(-3.0,Inf)) - @test isequal_interval(*(interval(-1.0,Inf), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), interval(1.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), bareinterval(1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-Inf,3.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-Inf,3.0), interval(-5.0, -1.0)), interval(-15.0,Inf)) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0)), bareinterval(-15.0,Inf)) - @test isequal_interval(*(interval(-Inf,3.0), interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), interval(1.0, 3.0)), interval(-Inf,9.0)) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0)), bareinterval(-Inf,9.0)) - @test isequal_interval(*(interval(-Inf,3.0), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), interval(1.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), bareinterval(1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,3.0), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,-3.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-5.0, -1.0)), interval(3.0,Inf)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0)), bareinterval(3.0,Inf)) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,-3.0), interval(1.0, 3.0)), interval(-Inf,-3.0)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-Inf, -1.0)), interval(3.0,Inf)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0)), bareinterval(3.0,Inf)) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,-3.0), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf,-3.0), interval(1.0, Inf)), interval(-Inf,-3.0)) + @test isequal_interval(*(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf)), bareinterval(-Inf,-3.0)) - @test isequal_interval(*(interval(-Inf,-3.0), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(0.0,0.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-5.0, -1.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-5.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(1.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(1.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-Inf, -1.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-Inf, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(-5.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(-5.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), interval(1.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), bareinterval(1.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(0.0,0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-5.0, -1.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-5.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(1.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-Inf, -1.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-Inf, 3.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(-5.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), interval(1.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-0.0,-0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-5.0, -1.0)), interval(-25.0,-1.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0)), bareinterval(-25.0,-1.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-5.0, 3.0)), interval(-25.0,15.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0)), bareinterval(-25.0,15.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(1.0, 3.0)), interval(1.0,15.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(1.0, 3.0)), bareinterval(1.0,15.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-Inf, -1.0)), interval(-Inf,-1.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-Inf, 3.0)), interval(-Inf,15.0)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0)), bareinterval(-Inf,15.0)) - @test isequal_interval(*(interval(1.0,5.0), interval(-5.0, Inf)), interval(-25.0,Inf)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(-5.0, Inf)), bareinterval(-25.0,Inf)) - @test isequal_interval(*(interval(1.0,5.0), interval(1.0, Inf)), interval(1.0,Inf)) + @test isequal_interval(*(bareinterval(1.0,5.0), bareinterval(1.0, Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(*(interval(1.0,5.0), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,5.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(-5.0, -1.0)), interval(-25.0,5.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0)), bareinterval(-25.0,5.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(-5.0, 3.0)), interval(-25.0,15.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0)), bareinterval(-25.0,15.0)) - @test isequal_interval(*(interval(-10.0,2.0), interval(-5.0, 3.0)), interval(-30.0,50.0)) + @test isequal_interval(*(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0)), bareinterval(-30.0,50.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(-1.0, 10.0)), interval(-10.0,50.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0)), bareinterval(-10.0,50.0)) - @test isequal_interval(*(interval(-2.0,2.0), interval(-5.0, 3.0)), interval(-10.0,10.0)) + @test isequal_interval(*(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0)), bareinterval(-10.0,10.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(1.0, 3.0)), interval(-3.0,15.0)) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0)), bareinterval(-3.0,15.0)) - @test isequal_interval(*(interval(-1.0,5.0), interval(-Inf, -1.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,5.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,5.0), interval(-5.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,5.0), interval(1.0, Inf)), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,5.0), bareinterval(1.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-1.0,5.0), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-10.0,-5.0), interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-5.0, -1.0)), interval(5.0,50.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0)), bareinterval(5.0,50.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-5.0, 3.0)), interval(-30.0,50.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0)), bareinterval(-30.0,50.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(1.0, 3.0)), interval(-30.0,-5.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0)), bareinterval(-30.0,-5.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-Inf, -1.0)), interval(5.0,Inf)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0)), bareinterval(5.0,Inf)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-Inf, 3.0)), interval(-30.0,Inf)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0)), bareinterval(-30.0,Inf)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(-5.0, Inf)), interval(-Inf,50.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf)), bareinterval(-Inf,50.0)) - @test isequal_interval(*(interval(-10.0,-5.0), interval(1.0, Inf)), interval(-Inf,-5.0)) + @test isequal_interval(*(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf)), bareinterval(-Inf,-5.0)) - @test isequal_interval(*(interval(-10.0,-5.0), entireinterval()), entireinterval()) + @test isequal_interval(*(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), interval(-0x1.FFFFFFFFFFFFP+0, Inf)), interval(-0x1.FFFFFFFFFFFE1P+1,Inf)) + @test isequal_interval(*(bareinterval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.FFFFFFFFFFFFP+0, Inf)), bareinterval(-0x1.FFFFFFFFFFFE1P+1,Inf)) - @test isequal_interval(*(interval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), interval(-0x1.FFFFFFFFFFFFP+0,-0x1.999999999999AP-4)), interval(-0x1.FFFFFFFFFFFE1P+1,0x1.999999999998EP-3)) + @test isequal_interval(*(bareinterval(-0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0), bareinterval(-0x1.FFFFFFFFFFFFP+0,-0x1.999999999999AP-4)), bareinterval(-0x1.FFFFFFFFFFFE1P+1,0x1.999999999998EP-3)) - @test isequal_interval(*(interval(-0x1.999999999999AP-4,0x1.999999999999AP-4), interval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4)), interval(-0x1.999999999998EP-3,0x1.999999999998EP-3)) + @test isequal_interval(*(bareinterval(-0x1.999999999999AP-4,0x1.999999999999AP-4), bareinterval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4)), bareinterval(-0x1.999999999998EP-3,0x1.999999999998EP-3)) - @test isequal_interval(*(interval(-0x1.FFFFFFFFFFFFP+0,-0x1.999999999999AP-4), interval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0)), interval(-0x1.FFFFFFFFFFFE1P+1,-0x1.47AE147AE147BP-7)) + @test isequal_interval(*(bareinterval(-0x1.FFFFFFFFFFFFP+0,-0x1.999999999999AP-4), bareinterval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0)), bareinterval(-0x1.FFFFFFFFFFFE1P+1,-0x1.47AE147AE147BP-7)) end @testset "minimal_mul_dec_test" begin - @test isequal_interval(*(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), com)), DecoratedInterval(interval(5.0,14.0), com)) + @test isequal_interval(*(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.com)), Interval(bareinterval(5.0,14.0), IntervalArithmetic.com)) - @test isequal_interval(*(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,7.0), def)), DecoratedInterval(interval(5.0,14.0), def)) + @test isequal_interval(*(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,7.0), IntervalArithmetic.def)), Interval(bareinterval(5.0,14.0), IntervalArithmetic.def)) - @test isequal_interval(*(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(5.0,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(5.0,Inf), dac)) + @test isequal_interval(*(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(5.0,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(5.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(*(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), com), DecoratedInterval(interval(-1.0, 5.0), com)), DecoratedInterval(interval(-Inf,0x1.FFFFFFFFFFFFFp1023), dac)) + @test isequal_interval(*(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), IntervalArithmetic.com), Interval(bareinterval(-1.0, 5.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)) - @test isequal_interval(*(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(*(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isnai(*(nai(), DecoratedInterval(interval(1.0,2.0), trv))) + @test isnai(*(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv))) end @testset "minimal_div_test" begin - @test isequal_interval(/(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-1.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(/(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), interval(-1.0,1.0)), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), interval(0.1,1.0)), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), bareinterval(0.1,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(emptyinterval(), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-5.0, -3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(3.0, 5.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-Inf, -3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(3.0,Inf)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(3.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-3.0, -0.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-3.0, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(0.0, 3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-0.0, 3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-Inf, -0.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(-0.0, Inf)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-5.0, -3.0)), interval(3.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-5.0, -3.0)), bareinterval(3.0,10.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(3.0, 5.0)), interval(-10.0,-3.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(3.0, 5.0)), bareinterval(-10.0,-3.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-Inf, -3.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(3.0,Inf)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(3.0,Inf)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-3.0, 0.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-3.0, 0.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-3.0, -0.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-3.0, -0.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(0.0, 3.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-0.0, 3.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-15.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-15.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-15.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-15.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-15.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-5.0, -3.0)), interval(-5.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-5.0, -3.0)), bareinterval(-5.0,10.0)) - @test isequal_interval(/(interval(-30.0,15.0), interval(3.0, 5.0)), interval(-10.0,5.0)) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(3.0, 5.0)), bareinterval(-10.0,5.0)) - @test isequal_interval(/(interval(-30.0,15.0), interval(-Inf, -3.0)), interval(-5.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-Inf, -3.0)), bareinterval(-5.0,10.0)) - @test isequal_interval(/(interval(-30.0,15.0), interval(3.0,Inf)), interval(-10.0,5.0)) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(3.0,Inf)), bareinterval(-10.0,5.0)) - @test isequal_interval(/(interval(-30.0,15.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-3.0, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-3.0, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-Inf, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-Inf, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), interval(-0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), bareinterval(-0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,15.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,15.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(-5.0, -3.0)), interval(-10.0,-3.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-5.0, -3.0)), bareinterval(-10.0,-3.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(3.0, 5.0)), interval(3.0,10.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(3.0, 5.0)), bareinterval(3.0,10.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(-Inf, -3.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-Inf, -3.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(3.0,Inf)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(3.0,Inf)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(-3.0, 0.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-3.0, 0.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(-3.0, -0.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-3.0, -0.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(0.0, 3.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(0.0, 3.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(15.0,30.0), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(-0.0, 3.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-0.0, 3.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(15.0,30.0), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(15.0,30.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,30.0), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(15.0,30.0), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,30.0), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(15.0,30.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,30.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,0.0), interval(-5.0, -3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(3.0, 5.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(3.0, 5.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-Inf, -3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(3.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(3.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,0.0), interval(-3.0, 0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,0.0), interval(-3.0, -0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-3.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-3.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(0.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(0.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-Inf, 0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-0.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-0.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-Inf, -0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-Inf, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-3.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-3.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(0.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(0.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), interval(-0.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), bareinterval(-0.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(0.0,0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-5.0, -3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(3.0, 5.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(3.0, 5.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-Inf, -3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(3.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(3.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-3.0, 0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-3.0, -0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-3.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-3.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(0.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(0.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-Inf, 0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-0.0, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-0.0, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-Inf, -0.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-Inf, 3.0)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-3.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-3.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(0.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(0.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), interval(-0.0, Inf)), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), bareinterval(-0.0, Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-0.0,-0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-5.0, -3.0)), interval(3.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-5.0, -3.0)), bareinterval(3.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(3.0, 5.0)), interval(-Inf,-3.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(3.0, 5.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-Inf, -3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(3.0,Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(3.0,Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-3.0, 0.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-3.0, 0.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-3.0, -0.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-3.0, -0.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-15.0), interval(0.0, 3.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-0.0, 3.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-15.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-15.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-15.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-15.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-15.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-5.0, -3.0)), interval(-5.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-5.0, -3.0)), bareinterval(-5.0,Inf)) - @test isequal_interval(/(interval(-Inf,15.0), interval(3.0, 5.0)), interval(-Inf,5.0)) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(3.0, 5.0)), bareinterval(-Inf,5.0)) - @test isequal_interval(/(interval(-Inf,15.0), interval(-Inf, -3.0)), interval(-5.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-Inf, -3.0)), bareinterval(-5.0,Inf)) - @test isequal_interval(/(interval(-Inf,15.0), interval(3.0,Inf)), interval(-Inf,5.0)) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(3.0,Inf)), bareinterval(-Inf,5.0)) - @test isequal_interval(/(interval(-Inf,15.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-3.0, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-3.0, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-Inf, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-Inf, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), interval(-0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), bareinterval(-0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,15.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,15.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-5.0, -3.0)), interval(-Inf,5.0)) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-5.0, -3.0)), bareinterval(-Inf,5.0)) - @test isequal_interval(/(interval(-15.0,Inf), interval(3.0, 5.0)), interval(-5.0,Inf)) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(3.0, 5.0)), bareinterval(-5.0,Inf)) - @test isequal_interval(/(interval(-15.0,Inf), interval(-Inf, -3.0)), interval(-Inf,5.0)) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-Inf, -3.0)), bareinterval(-Inf,5.0)) - @test isequal_interval(/(interval(-15.0,Inf), interval(3.0,Inf)), interval(-5.0,Inf)) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(3.0,Inf)), bareinterval(-5.0,Inf)) - @test isequal_interval(/(interval(-15.0,Inf), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-3.0, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-3.0, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-0.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-Inf, -0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-Inf, -0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), interval(-0.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), bareinterval(-0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-15.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-15.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(-5.0, -3.0)), interval(-Inf,-3.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-5.0, -3.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(3.0, 5.0)), interval(3.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(3.0, 5.0)), bareinterval(3.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), interval(-Inf, -3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-Inf, -3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(3.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(3.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(-3.0, 0.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-3.0, 0.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(-3.0, -0.0)), interval(-Inf,-5.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-3.0, -0.0)), bareinterval(-Inf,-5.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(0.0, 3.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(0.0, 3.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(-0.0, 3.0)), interval(5.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-0.0, 3.0)), bareinterval(5.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(15.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(15.0,Inf), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(15.0,Inf), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(15.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(15.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(-5.0, -3.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(3.0, 5.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(3.0, 5.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-Inf, -3.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(3.0,Inf)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(3.0,Inf)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(-3.0, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(-3.0, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,0.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,0.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-5.0, -3.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(3.0, 5.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(3.0, 5.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-Inf, -3.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(3.0,Inf)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(3.0,Inf)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-3.0, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-3.0, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-30.0,-0.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-30.0,-0.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-30.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-30.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(-5.0, -3.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-5.0, -3.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(3.0, 5.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(3.0, 5.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(-Inf, -3.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-Inf, -3.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(3.0,Inf)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(3.0,Inf)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(-3.0, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-3.0, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(-3.0, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-3.0, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,30.0), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(-0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,30.0), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,30.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,30.0), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,30.0), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,30.0), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,30.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,30.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(-5.0, -3.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-5.0, -3.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(3.0, 5.0)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(3.0, 5.0)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-Inf, -3.0)), interval(-10.0,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-Inf, -3.0)), bareinterval(-10.0,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(3.0,Inf)), interval(0.0,10.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(3.0,Inf)), bareinterval(0.0,10.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(-3.0, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-3.0, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(-3.0, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-3.0, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,30.0), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,30.0), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,30.0), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,30.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,30.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(-5.0, -3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(3.0, 5.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(3.0, 5.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-Inf, -3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(3.0,Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(3.0,Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(-3.0, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(-3.0, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,0.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,0.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,0.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-5.0, -3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-5.0, -3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(3.0, 5.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(3.0, 5.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-Inf, -3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-Inf, -3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(3.0,Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(3.0,Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-3.0, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-3.0, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-3.0, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-3.0, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-Inf, 0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-0.0, 3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-0.0, 3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-Inf, -0.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-Inf, -0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf,-0.0), interval(0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), interval(-0.0, Inf)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-Inf,-0.0), bareinterval(-0.0, Inf)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-Inf,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(-5.0, -3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-5.0, -3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(3.0, 5.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(3.0, 5.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), interval(-Inf, -3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-Inf, -3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(3.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(3.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(-3.0, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-3.0, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(-3.0, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-3.0, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(-0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(0.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0,Inf), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(0.0,Inf), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(0.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(-5.0, -3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-5.0, -3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(3.0, 5.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(3.0, 5.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-Inf, -3.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-Inf, -3.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(3.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(3.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(-3.0, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-3.0, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(-3.0, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-3.0, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-0.0, 3.0)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-0.0, 3.0)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-Inf, 3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-Inf, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(-3.0, Inf)), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-3.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0.0,Inf), interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(/(bareinterval(-0.0,Inf), bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(/(interval(-0.0,Inf), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-0.0,Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.0,-1.0), interval(-10.0, -3.0)), interval(0x1.9999999999999P-4,0x1.5555555555556P-1)) + @test isequal_interval(/(bareinterval(-2.0,-1.0), bareinterval(-10.0, -3.0)), bareinterval(0x1.9999999999999P-4,0x1.5555555555556P-1)) - @test isequal_interval(/(interval(-2.0,-1.0), interval(0.0, 10.0)), interval(-Inf,-0x1.9999999999999P-4)) + @test isequal_interval(/(bareinterval(-2.0,-1.0), bareinterval(0.0, 10.0)), bareinterval(-Inf,-0x1.9999999999999P-4)) - @test isequal_interval(/(interval(-2.0,-1.0), interval(-0.0, 10.0)), interval(-Inf,-0x1.9999999999999P-4)) + @test isequal_interval(/(bareinterval(-2.0,-1.0), bareinterval(-0.0, 10.0)), bareinterval(-Inf,-0x1.9999999999999P-4)) - @test isequal_interval(/(interval(-1.0,2.0), interval(10.0,Inf)), interval(-0x1.999999999999AP-4,0x1.999999999999AP-3)) + @test isequal_interval(/(bareinterval(-1.0,2.0), bareinterval(10.0,Inf)), bareinterval(-0x1.999999999999AP-4,0x1.999999999999AP-3)) - @test isequal_interval(/(interval(1.0,3.0), interval(-Inf, -10.0)), interval(-0x1.3333333333334P-2,0.0)) + @test isequal_interval(/(bareinterval(1.0,3.0), bareinterval(-Inf, -10.0)), bareinterval(-0x1.3333333333334P-2,0.0)) - @test isequal_interval(/(interval(-Inf,-1.0), interval(1.0, 3.0)), interval(-Inf,-0x1.5555555555555P-2)) + @test isequal_interval(/(bareinterval(-Inf,-1.0), bareinterval(1.0, 3.0)), bareinterval(-Inf,-0x1.5555555555555P-2)) end @testset "minimal_div_dec_test" begin - @test isequal_interval(/(DecoratedInterval(interval(-2.0,-1.0), com), DecoratedInterval(interval(-10.0, -3.0), com)), DecoratedInterval(interval(0x1.9999999999999P-4,0x1.5555555555556P-1), com)) + @test isequal_interval(/(Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.com), Interval(bareinterval(-10.0, -3.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.9999999999999P-4,0x1.5555555555556P-1), IntervalArithmetic.com)) - @test isequal_interval(/(DecoratedInterval(interval(-200.0,-1.0), com), DecoratedInterval(interval(0x0.0000000000001p-1022, 10.0), com)), DecoratedInterval(interval(-Inf,-0x1.9999999999999P-4), dac)) + @test isequal_interval(/(Interval(bareinterval(-200.0,-1.0), IntervalArithmetic.com), Interval(bareinterval(0x0.0000000000001p-1022, 10.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,-0x1.9999999999999P-4), IntervalArithmetic.dac)) - @test isequal_interval(/(DecoratedInterval(interval(-2.0,-1.0), com), DecoratedInterval(interval(0.0, 10.0), com)), DecoratedInterval(interval(-Inf,-0x1.9999999999999P-4), trv)) + @test isequal_interval(/(Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 10.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,-0x1.9999999999999P-4), IntervalArithmetic.trv)) - @test isequal_interval(/(DecoratedInterval(interval(1.0,3.0), def), DecoratedInterval(interval(-Inf, -10.0), dac)), DecoratedInterval(interval(-0x1.3333333333334P-2,0.0), def)) + @test isequal_interval(/(Interval(bareinterval(1.0,3.0), IntervalArithmetic.def), Interval(bareinterval(-Inf, -10.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.3333333333334P-2,0.0), IntervalArithmetic.def)) - @test isequal_interval(/(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(/(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isnai(/(nai(), DecoratedInterval(interval(1.0,2.0), trv))) + @test isnai(/(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv))) end @testset "minimal_recip_test" begin - @test isequal_interval(inv(interval(-50.0, -10.0)), interval(-0x1.999999999999AP-4,-0x1.47AE147AE147AP-6)) + @test isequal_interval(inv(bareinterval(-50.0, -10.0)), bareinterval(-0x1.999999999999AP-4,-0x1.47AE147AE147AP-6)) - @test isequal_interval(inv(interval(10.0, 50.0)), interval(0x1.47AE147AE147AP-6,0x1.999999999999AP-4)) + @test isequal_interval(inv(bareinterval(10.0, 50.0)), bareinterval(0x1.47AE147AE147AP-6,0x1.999999999999AP-4)) - @test isequal_interval(inv(interval(-Inf, -10.0)), interval(-0x1.999999999999AP-4,0.0)) + @test isequal_interval(inv(bareinterval(-Inf, -10.0)), bareinterval(-0x1.999999999999AP-4,0.0)) - @test isequal_interval(inv(interval(10.0,Inf)), interval(0.0,0x1.999999999999AP-4)) + @test isequal_interval(inv(bareinterval(10.0,Inf)), bareinterval(0.0,0x1.999999999999AP-4)) - @test isequal_interval(inv(interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(inv(bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(inv(bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(-10.0, 0.0)), interval(-Inf,-0x1.9999999999999P-4)) + @test isequal_interval(inv(bareinterval(-10.0, 0.0)), bareinterval(-Inf,-0x1.9999999999999P-4)) - @test isequal_interval(inv(interval(-10.0, -0.0)), interval(-Inf,-0x1.9999999999999P-4)) + @test isequal_interval(inv(bareinterval(-10.0, -0.0)), bareinterval(-Inf,-0x1.9999999999999P-4)) - @test isequal_interval(inv(interval(-10.0, 10.0)), entireinterval()) + @test isequal_interval(inv(bareinterval(-10.0, 10.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(0.0, 10.0)), interval(0x1.9999999999999P-4,Inf)) + @test isequal_interval(inv(bareinterval(0.0, 10.0)), bareinterval(0x1.9999999999999P-4,Inf)) - @test isequal_interval(inv(interval(-0.0, 10.0)), interval(0x1.9999999999999P-4,Inf)) + @test isequal_interval(inv(bareinterval(-0.0, 10.0)), bareinterval(0x1.9999999999999P-4,Inf)) - @test isequal_interval(inv(interval(-Inf, 0.0)), interval(-Inf,0.0)) + @test isequal_interval(inv(bareinterval(-Inf, 0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(inv(interval(-Inf, -0.0)), interval(-Inf,0.0)) + @test isequal_interval(inv(bareinterval(-Inf, -0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(inv(interval(-Inf, 10.0)), entireinterval()) + @test isequal_interval(inv(bareinterval(-Inf, 10.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(-10.0, Inf)), entireinterval()) + @test isequal_interval(inv(bareinterval(-10.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(inv(bareinterval(0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(inv(interval(-0.0, Inf)), interval(0.0,Inf)) + @test isequal_interval(inv(bareinterval(-0.0, Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(inv(entireinterval()), entireinterval()) + @test isequal_interval(inv(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) end @testset "minimal_recip_dec_test" begin - @test isequal_interval(inv(DecoratedInterval(interval(10.0, 50.0), com)), DecoratedInterval(interval(0x1.47AE147AE147AP-6,0x1.999999999999AP-4), com)) + @test isequal_interval(inv(Interval(bareinterval(10.0, 50.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.47AE147AE147AP-6,0x1.999999999999AP-4), IntervalArithmetic.com)) - @test isequal_interval(inv(DecoratedInterval(interval(-Inf, -10.0), dac)), DecoratedInterval(interval(-0x1.999999999999AP-4,0.0), dac)) + @test isequal_interval(inv(Interval(bareinterval(-Inf, -10.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.999999999999AP-4,0.0), IntervalArithmetic.dac)) - @test isequal_interval(inv(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023, -0x0.0000000000001p-1022), def)), DecoratedInterval(interval(-Inf,-0x0.4P-1022), def)) + @test isequal_interval(inv(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023, -0x0.0000000000001p-1022), IntervalArithmetic.def)), Interval(bareinterval(-Inf,-0x0.4P-1022), IntervalArithmetic.def)) - @test isequal_interval(inv(DecoratedInterval(interval(0.0,0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(inv(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(inv(DecoratedInterval(interval(-10.0, 0.0), com)), DecoratedInterval(interval(-Inf,-0x1.9999999999999P-4), trv)) + @test isequal_interval(inv(Interval(bareinterval(-10.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,-0x1.9999999999999P-4), IntervalArithmetic.trv)) - @test isequal_interval(inv(DecoratedInterval(interval(-10.0, Inf), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(inv(Interval(bareinterval(-10.0, Inf), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(inv(DecoratedInterval(interval(-0.0, Inf), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(inv(Interval(bareinterval(-0.0, Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(inv(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(inv(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_sqr_test" begin - @test isequal_interval(emptyinterval()^2, emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 2), emptyinterval(BareInterval{Float64})) - @test isequal_interval(entireinterval()^2, interval(0.0,Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 2), bareinterval(0.0,Inf)) - @test isequal_interval(interval(-Inf,-0x0.0000000000001p-1022)^2, interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0x0.0000000000001p-1022), 2), bareinterval(0.0,Inf)) - @test isequal_interval(interval(-1.0,1.0)^2, interval(0.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-1.0,1.0), 2), bareinterval(0.0,1.0)) - @test isequal_interval(interval(0.0,1.0)^2, interval(0.0,1.0)) + @test isequal_interval(nthpow(bareinterval(0.0,1.0), 2), bareinterval(0.0,1.0)) - @test isequal_interval(interval(-0.0,1.0)^2, interval(0.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,1.0), 2), bareinterval(0.0,1.0)) - @test isequal_interval(interval(-5.0,3.0)^2, interval(0.0,25.0)) + @test isequal_interval(nthpow(bareinterval(-5.0,3.0), 2), bareinterval(0.0,25.0)) - @test isequal_interval(interval(-5.0,0.0)^2, interval(0.0,25.0)) + @test isequal_interval(nthpow(bareinterval(-5.0,0.0), 2), bareinterval(0.0,25.0)) - @test isequal_interval(interval(-5.0,-0.0)^2, interval(0.0,25.0)) + @test isequal_interval(nthpow(bareinterval(-5.0,-0.0), 2), bareinterval(0.0,25.0)) - @test isequal_interval(interval(0x1.999999999999AP-4,0x1.999999999999AP-4)^2, interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7)) + @test isequal_interval(nthpow(bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4), 2), bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7)) - @test isequal_interval(interval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4)^2, interval(0.0,0x1.FFFFFFFFFFFE1P+1)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4), 2), bareinterval(0.0,0x1.FFFFFFFFFFFE1P+1)) - @test isequal_interval(interval(-0x1.FFFFFFFFFFFFP+0,-0x1.FFFFFFFFFFFFP+0)^2, interval(0x1.FFFFFFFFFFFEP+1,0x1.FFFFFFFFFFFE1P+1)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFP+0,-0x1.FFFFFFFFFFFFP+0), 2), bareinterval(0x1.FFFFFFFFFFFEP+1,0x1.FFFFFFFFFFFE1P+1)) end @testset "minimal_sqr_dec_test" begin - @test isequal_interval(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x0.0000000000001p-1022), com)^2, DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x0.0000000000001p-1022), IntervalArithmetic.com), 2), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(DecoratedInterval(interval(-1.0,1.0), def)^2, DecoratedInterval(interval(0.0,1.0), def)) + @test isequal_interval(nthpow(Interval(bareinterval(-1.0,1.0), IntervalArithmetic.def), 2), Interval(bareinterval(0.0,1.0), IntervalArithmetic.def)) - @test isequal_interval(DecoratedInterval(interval(-5.0,3.0), com)^2, DecoratedInterval(interval(0.0,25.0), com)) + @test isequal_interval(nthpow(Interval(bareinterval(-5.0,3.0), IntervalArithmetic.com), 2), Interval(bareinterval(0.0,25.0), IntervalArithmetic.com)) - @test isequal_interval(DecoratedInterval(interval(0x1.999999999999AP-4,0x1.999999999999AP-4), com)^2, DecoratedInterval(interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), com)) + @test isequal_interval(nthpow(Interval(bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4), IntervalArithmetic.com), 2), Interval(bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), IntervalArithmetic.com)) end @testset "minimal_sqrt_test" begin - @test isequal_interval(sqrt(emptyinterval()), emptyinterval()) + @test isequal_interval(sqrt(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqrt(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(sqrt(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(sqrt(interval(-Inf,-0x0.0000000000001p-1022)), emptyinterval()) + @test isequal_interval(sqrt(bareinterval(-Inf,-0x0.0000000000001p-1022)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqrt(interval(-1.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(sqrt(bareinterval(-1.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(sqrt(interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(sqrt(bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(sqrt(interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(sqrt(bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(sqrt(interval(-5.0,25.0)), interval(0.0,5.0)) + @test isequal_interval(sqrt(bareinterval(-5.0,25.0)), bareinterval(0.0,5.0)) - @test isequal_interval(sqrt(interval(0.0,25.0)), interval(0.0,5.0)) + @test isequal_interval(sqrt(bareinterval(0.0,25.0)), bareinterval(0.0,5.0)) - @test isequal_interval(sqrt(interval(-0.0,25.0)), interval(0.0,5.0)) + @test isequal_interval(sqrt(bareinterval(-0.0,25.0)), bareinterval(0.0,5.0)) - @test isequal_interval(sqrt(interval(-5.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(sqrt(bareinterval(-5.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(sqrt(interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(0x1.43D136248490FP-2,0x1.43D136248491P-2)) + @test isequal_interval(sqrt(bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(0x1.43D136248490FP-2,0x1.43D136248491P-2)) - @test isequal_interval(sqrt(interval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4)), interval(0.0,0x1.43D136248491P-2)) + @test isequal_interval(sqrt(bareinterval(-0x1.FFFFFFFFFFFFP+0,0x1.999999999999AP-4)), bareinterval(0.0,0x1.43D136248491P-2)) - @test isequal_interval(sqrt(interval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0)), interval(0x1.43D136248490FP-2,0x1.6A09E667F3BC7P+0)) + @test isequal_interval(sqrt(bareinterval(0x1.999999999999AP-4,0x1.FFFFFFFFFFFFP+0)), bareinterval(0x1.43D136248490FP-2,0x1.6A09E667F3BC7P+0)) end @testset "minimal_sqrt_dec_test" begin - @test isequal_interval(sqrt(DecoratedInterval(interval(1.0,4.0), com)), DecoratedInterval(interval(1.0,2.0), com)) + @test isequal_interval(sqrt(Interval(bareinterval(1.0,4.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) - @test isequal_interval(sqrt(DecoratedInterval(interval(-5.0,25.0), com)), DecoratedInterval(interval(0.0,5.0), trv)) + @test isequal_interval(sqrt(Interval(bareinterval(-5.0,25.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqrt(DecoratedInterval(interval(0.0,25.0), def)), DecoratedInterval(interval(0.0,5.0), def)) + @test isequal_interval(sqrt(Interval(bareinterval(0.0,25.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,5.0), IntervalArithmetic.def)) - @test isequal_interval(sqrt(DecoratedInterval(interval(-5.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(sqrt(Interval(bareinterval(-5.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) end @testset "minimal_fma_test" begin - @test isequal_interval(fma(emptyinterval(), emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,1.0), emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-1.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,2.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-1.0, 10.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-2.0,2.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, -1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, 3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), emptyinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,1.0), emptyinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-1.0,1.0), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), entireinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), emptyinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), emptyinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), emptyinterval(), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(0.0,0.0), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-0.0,-0.0), interval(-Inf,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(entireinterval(), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(entireinterval(), interval(-5.0, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, -1.0), interval(-Inf,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,7.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,7.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,11.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,11.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,-1.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, Inf), interval(-Inf,2.0)), interval(-Inf,-1.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, -1.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, Inf), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, Inf), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), entireinterval(), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, -1.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, 3.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, Inf), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, Inf), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), entireinterval(), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, -1.0), interval(-Inf,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, 3.0), interval(-Inf,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,7.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,7.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(-10.0,2.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-1.0, 10.0), interval(-Inf,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-2.0,2.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,12.0)) + @test isequal_interval(fma(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,12.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, Inf), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(0.0,0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-0.0,-0.0), interval(-Inf,2.0)), interval(-Inf,2.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, -1.0), interval(-Inf,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, 3.0), interval(-Inf,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, 3.0), interval(-Inf,2.0)), interval(-Inf,-3.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0), bareinterval(-Inf,2.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, -1.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, 3.0), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, Inf), interval(-Inf,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, Inf), interval(-Inf,2.0)), interval(-Inf,-3.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf), bareinterval(-Inf,2.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), entireinterval(), interval(-Inf,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), emptyinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,1.0), emptyinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-1.0,1.0), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), entireinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), emptyinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), emptyinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), emptyinterval(), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(0.0,0.0), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-0.0,-0.0), interval(-2.0,2.0)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(entireinterval(), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(entireinterval(), interval(-5.0, -1.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, -1.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, Inf), interval(-2.0,2.0)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-Inf,7.0)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,7.0)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-5.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-5.0,Inf)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, -1.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-17.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-17.0,Inf)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-Inf,11.0)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,11.0)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, -1.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(1.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(1.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-Inf,-1.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(1.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(1.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, Inf), interval(-2.0,2.0)), interval(-Inf,-1.0)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-Inf,-1.0)) - @test isequal_interval(fma(interval(-Inf,-3.0), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, Inf), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, Inf), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(0.0,0.0), entireinterval(), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, 3.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, Inf), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, Inf), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-0.0,-0.0), entireinterval(), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-27.0,1.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-27.0,1.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-27.0,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-27.0,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-1.0,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-1.0,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(-Inf,1.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,1.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, 3.0), interval(-2.0,2.0)), interval(-Inf,17.0)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), bareinterval(-Inf,17.0)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, Inf), interval(-2.0,2.0)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, Inf), interval(-2.0,2.0)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(-27.0,7.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(-27.0,7.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-27.0,17.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-27.0,17.0)) - @test isequal_interval(fma(interval(-10.0,2.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-32.0,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-32.0,52.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-1.0, 10.0), interval(-2.0,2.0)), interval(-12.0,52.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0), bareinterval(-2.0,2.0)), bareinterval(-12.0,52.0)) - @test isequal_interval(fma(interval(-2.0,2.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-12.0,12.0)) + @test isequal_interval(fma(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-12.0,12.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-5.0,17.0)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-5.0,17.0)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, -1.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, 3.0), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, Inf), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(0.0,0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-0.0,-0.0), interval(-2.0,2.0)), interval(-2.0,2.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, -1.0), interval(-2.0,2.0)), interval(3.0,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,2.0)), bareinterval(3.0,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, 3.0), interval(-2.0,2.0)), interval(-32.0,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-32.0,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, 3.0), interval(-2.0,2.0)), interval(-32.0,-3.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,2.0)), bareinterval(-32.0,-3.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, -1.0), interval(-2.0,2.0)), interval(3.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,2.0)), bareinterval(3.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, 3.0), interval(-2.0,2.0)), interval(-32.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,2.0)), bareinterval(-32.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, Inf), interval(-2.0,2.0)), interval(-Inf,52.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-Inf,52.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, Inf), interval(-2.0,2.0)), interval(-Inf,-3.0)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf), bareinterval(-2.0,2.0)), bareinterval(-Inf,-3.0)) - @test isequal_interval(fma(interval(-10.0,-5.0), entireinterval(), interval(-2.0,2.0)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), emptyinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,1.0), emptyinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-1.0,1.0), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), entireinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), emptyinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), emptyinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), emptyinterval(), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(0.0,0.0), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-0.0,-0.0), interval(-2.0,Inf)), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(entireinterval(), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(entireinterval(), interval(-5.0, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, Inf), interval(-2.0,Inf)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,Inf), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-5.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-5.0,Inf)) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(-17.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(-17.0,Inf)) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, -1.0), interval(-2.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, -1.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, Inf), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, Inf), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(0.0,0.0), entireinterval(), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, -1.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, 3.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, Inf), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, Inf), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-0.0,-0.0), entireinterval(), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, Inf), interval(-2.0,Inf)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, Inf), interval(-2.0,Inf)), interval(-1.0,Inf)) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(fma(interval(1.0,5.0), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-27.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-27.0,Inf)) - @test isequal_interval(fma(interval(-10.0,2.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-32.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-32.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-1.0, 10.0), interval(-2.0,Inf)), interval(-12.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0), bareinterval(-2.0,Inf)), bareinterval(-12.0,Inf)) - @test isequal_interval(fma(interval(-2.0,2.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-12.0,Inf)) + @test isequal_interval(fma(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-12.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-5.0,Inf)) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-5.0,Inf)) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, -1.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, 3.0), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(0.0,0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-0.0,-0.0), interval(-2.0,Inf)), interval(-2.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0), bareinterval(-2.0,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, -1.0), interval(-2.0,Inf)), interval(3.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0), bareinterval(-2.0,Inf)), bareinterval(3.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, 3.0), interval(-2.0,Inf)), interval(-32.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-32.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, 3.0), interval(-2.0,Inf)), interval(-32.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0), bareinterval(-2.0,Inf)), bareinterval(-32.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, -1.0), interval(-2.0,Inf)), interval(3.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0), bareinterval(-2.0,Inf)), bareinterval(3.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, 3.0), interval(-2.0,Inf)), interval(-32.0,Inf)) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0), bareinterval(-2.0,Inf)), bareinterval(-32.0,Inf)) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, Inf), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), entireinterval(), interval(-2.0,Inf)), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64}), bareinterval(-2.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,1.0), emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-1.0,1.0), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-1.0,1.0), entireinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-1.0,1.0), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), entireinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(0.0,0.0), entireinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(emptyinterval(), interval(-0.0,-0.0), entireinterval()), emptyinterval()) + @test isequal_interval(fma(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(entireinterval(), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,Inf), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,Inf), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,Inf), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,3.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,3.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-Inf,-3.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-Inf,-3.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.0,0.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-0.0,-0.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(1.0,5.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,2.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,2.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-1.0, 10.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-1.0, 10.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-2.0,2.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-2.0,2.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-1.0,5.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(0.0,0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-0.0,-0.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, -1.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, -1.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-Inf, 3.0), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-Inf, 3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(-5.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(-5.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), interval(1.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(-10.0,-5.0), entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(fma(bareinterval(-10.0,-5.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(fma(interval(0.1,0.5), interval(-5.0, 3.0), interval(-0.1,0.1)), interval(-0x1.4CCCCCCCCCCCDP+1,0x1.999999999999AP+0)) + @test isequal_interval(fma(bareinterval(0.1,0.5), bareinterval(-5.0, 3.0), bareinterval(-0.1,0.1)), bareinterval(-0x1.4CCCCCCCCCCCDP+1,0x1.999999999999AP+0)) - @test isequal_interval(fma(interval(-0.5,0.2), interval(-5.0, 3.0), interval(-0.1,0.1)), interval(-0x1.999999999999AP+0,0x1.4CCCCCCCCCCCDP+1)) + @test isequal_interval(fma(bareinterval(-0.5,0.2), bareinterval(-5.0, 3.0), bareinterval(-0.1,0.1)), bareinterval(-0x1.999999999999AP+0,0x1.4CCCCCCCCCCCDP+1)) - @test isequal_interval(fma(interval(-0.5,-0.1), interval(2.0, 3.0), interval(-0.1,0.1)), interval(-0x1.999999999999AP+0,-0x1.999999999999AP-4)) + @test isequal_interval(fma(bareinterval(-0.5,-0.1), bareinterval(2.0, 3.0), bareinterval(-0.1,0.1)), bareinterval(-0x1.999999999999AP+0,-0x1.999999999999AP-4)) - @test isequal_interval(fma(interval(-0.5,-0.1), interval(-Inf, 3.0), interval(-0.1,0.1)), interval(-0x1.999999999999AP+0,Inf)) + @test isequal_interval(fma(bareinterval(-0.5,-0.1), bareinterval(-Inf, 3.0), bareinterval(-0.1,0.1)), bareinterval(-0x1.999999999999AP+0,Inf)) end @testset "minimal_fma_dec_test" begin - @test isequal_interval(fma(DecoratedInterval(interval(-0.5,-0.1), com), DecoratedInterval(interval(-Inf, 3.0), dac), DecoratedInterval(interval(-0.1,0.1), com)), DecoratedInterval(interval(-0x1.999999999999AP+0,Inf), dac)) + @test isequal_interval(fma(Interval(bareinterval(-0.5,-0.1), IntervalArithmetic.com), Interval(bareinterval(-Inf, 3.0), IntervalArithmetic.dac), Interval(bareinterval(-0.1,0.1), IntervalArithmetic.com)), Interval(bareinterval(-0x1.999999999999AP+0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(fma(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(1.0, 0x1.FFFFFFFFFFFFFp1023), com), DecoratedInterval(interval(0.0,1.0), com)), DecoratedInterval(interval(1.0,Inf), dac)) + @test isequal_interval(fma(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(1.0, 0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), Interval(bareinterval(0.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(fma(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(1.0, 2.0), com), DecoratedInterval(interval(2.0,5.0), com)), DecoratedInterval(interval(3.0,9.0), com)) + @test isequal_interval(fma(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com), Interval(bareinterval(2.0,5.0), IntervalArithmetic.com)), Interval(bareinterval(3.0,9.0), IntervalArithmetic.com)) end @testset "minimal_pown_test" begin - @test isequal_interval(^(emptyinterval(), 0), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 0), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,0.0), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(13.1,13.1), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,Inf), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,Inf), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-Inf,0.0), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-Inf,-0.0), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-324.3,2.5), 0), interval(1.0,1.0)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 0), bareinterval(1.0,1.0)) - @test isequal_interval(^(emptyinterval(), 2), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 2), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 2), interval(0.0,Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.0), 2), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 2), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 2), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 2), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(13.1,13.1), 2), interval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 2), bareinterval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 2), interval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 2), bareinterval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 2), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 2), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 2), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 2), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(0.0,Inf), 2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), 2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), 2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,-0.0), 2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-324.3,2.5), 2), interval(0.0,0x1.9AD27D70A3D72P+16)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 2), bareinterval(0.0,0x1.9AD27D70A3D72P+16)) - @test isequal_interval(^(interval(0.01,2.33), 2), interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), 2), bareinterval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2)) - @test isequal_interval(^(interval(-1.9,-0.33), 2), interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), 2), bareinterval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1)) - @test isequal_interval(^(emptyinterval(), 8), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 8), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 8), interval(0.0,Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.0), 8), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 8), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 8), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 8), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(13.1,13.1), 8), interval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 8), bareinterval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 8), interval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 8), bareinterval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 8), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 8), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 8), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 8), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(0.0,Inf), 8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), 8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), 8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,-0.0), 8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-324.3,2.5), 8), interval(0.0,0x1.A87587109655P+66)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 8), bareinterval(0.0,0x1.A87587109655P+66)) - @test isequal_interval(^(interval(0.01,2.33), 8), interval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), 8), bareinterval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9)) - @test isequal_interval(^(interval(-1.9,-0.33), 8), interval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), 8), bareinterval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7)) - @test isequal_interval(^(emptyinterval(), 1), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 1), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 1), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 1), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), 1), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 1), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 1), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 1), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(13.1,13.1), 1), interval(13.1,13.1)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 1), bareinterval(13.1,13.1)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 1), interval(-7451.145,-7451.145)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 1), bareinterval(-7451.145,-7451.145)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 1), interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 1), bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 1), interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 1), bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(^(interval(0.0,Inf), 1), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 1), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), 1), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 1), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), 1), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 1), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), 1), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 1), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), 1), interval(-324.3,2.5)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 1), bareinterval(-324.3,2.5)) - @test isequal_interval(^(interval(0.01,2.33), 1), interval(0.01,2.33)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), 1), bareinterval(0.01,2.33)) - @test isequal_interval(^(interval(-1.9,-0.33), 1), interval(-1.9,-0.33)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), 1), bareinterval(-1.9,-0.33)) - @test isequal_interval(^(emptyinterval(), 3), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 3), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 3), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 3), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), 3), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 3), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 3), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 3), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(13.1,13.1), 3), interval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 3), bareinterval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 3), interval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 3), bareinterval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 3), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 3), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 3), interval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 3), bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(^(interval(0.0,Inf), 3), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 3), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), 3), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 3), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), 3), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 3), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), 3), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 3), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), 3), interval(-0x1.0436D2F418938P+25,0x1.F4P+3)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 3), bareinterval(-0x1.0436D2F418938P+25,0x1.F4P+3)) - @test isequal_interval(^(interval(0.01,2.33), 3), interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), 3), bareinterval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3)) - @test isequal_interval(^(interval(-1.9,-0.33), 3), interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), 3), bareinterval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5)) - @test isequal_interval(^(emptyinterval(), 7), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), 7), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), 7), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 7), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), 7), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), 7), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), 7), interval(0.0,0.0)) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), 7), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(13.1,13.1), 7), interval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), 7), bareinterval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25)) - @test isequal_interval(^(interval(-7451.145,-7451.145), 7), interval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), 7), bareinterval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 7), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 7), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 7), interval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 7), bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(^(interval(0.0,Inf), 7), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), 7), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), 7), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), 7), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), 7), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), 7), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), 7), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), 7), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), 7), interval(-0x1.4F109959E6D7FP+58,0x1.312DP+9)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), 7), bareinterval(-0x1.4F109959E6D7FP+58,0x1.312DP+9)) - @test isequal_interval(^(interval(0.01,2.33), 7), interval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), 7), bareinterval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8)) - @test isequal_interval(^(interval(-1.9,-0.33), 7), interval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), 7), bareinterval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12)) - @test isequal_interval(^(emptyinterval(), -2), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), -2), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), -2), interval(0.0,Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), -2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.0), -2), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), -2), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), -2), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), -2), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(13.1,13.1), -2), interval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), -2), bareinterval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8)) - @test isequal_interval(^(interval(-7451.145,-7451.145), -2), interval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), -2), bareinterval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -2), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -2), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -2), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -2), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(0.0,Inf), -2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), -2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), -2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), -2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), -2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), -2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,-0.0), -2), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), -2), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-324.3,2.5), -2), interval(0x1.3F0C482C977C9P-17,Inf)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), -2), bareinterval(0x1.3F0C482C977C9P-17,Inf)) - @test isequal_interval(^(interval(0.01,2.33), -2), interval(0x1.793D85EF38E47P-3,0x1.388P+13)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), -2), bareinterval(0x1.793D85EF38E47P-3,0x1.388P+13)) - @test isequal_interval(^(interval(-1.9,-0.33), -2), interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), -2), bareinterval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3)) - @test isequal_interval(^(emptyinterval(), -8), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), -8), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), -8), interval(0.0,Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), -8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.0), -8), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), -8), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), -8), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), -8), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(13.1,13.1), -8), interval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), -8), bareinterval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30)) - @test isequal_interval(^(interval(-7451.145,-7451.145), -8), interval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), -8), bareinterval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -8), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -8), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -8), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -8), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(0.0,Inf), -8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), -8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), -8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), -8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), -8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), -8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,-0.0), -8), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), -8), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-324.3,2.5), -8), interval(0x1.34CC3764D1E0CP-67,Inf)) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), -8), bareinterval(0x1.34CC3764D1E0CP-67,Inf)) - @test isequal_interval(^(interval(0.01,2.33), -8), interval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), -8), bareinterval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53)) - @test isequal_interval(^(interval(-1.9,-0.33), -8), interval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), -8), bareinterval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12)) - @test isequal_interval(^(emptyinterval(), -1), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), -1), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), -1), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), -1), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), -1), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), -1), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), -1), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), -1), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(13.1,13.1), -1), interval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), -1), bareinterval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4)) - @test isequal_interval(^(interval(-7451.145,-7451.145), -1), interval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), -1), bareinterval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -1), interval(0x0.4P-1022,0x0.4000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -1), bareinterval(0x0.4P-1022,0x0.4000000000001P-1022)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -1), interval(-0x0.4000000000001P-1022,-0x0.4P-1022)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -1), bareinterval(-0x0.4000000000001P-1022,-0x0.4P-1022)) - @test isequal_interval(^(interval(0.0,Inf), -1), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), -1), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), -1), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), -1), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), -1), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), -1), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), -1), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), -1), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), -1), entireinterval()) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), -1), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.01,2.33), -1), interval(0x1.B77C278DBBE13P-2,0x1.9P+6)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), -1), bareinterval(0x1.B77C278DBBE13P-2,0x1.9P+6)) - @test isequal_interval(^(interval(-1.9,-0.33), -1), interval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), -1), bareinterval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1)) - @test isequal_interval(^(emptyinterval(), -3), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), -3), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), -3), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), -3), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), -3), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), -3), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), -3), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), -3), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(13.1,13.1), -3), interval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), -3), bareinterval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12)) - @test isequal_interval(^(interval(-7451.145,-7451.145), -3), interval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), -3), bareinterval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -3), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -3), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -3), interval(-0x0.0000000000001P-1022,-0x0P+0)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -3), bareinterval(-0x0.0000000000001P-1022,-0x0P+0)) - @test isequal_interval(^(interval(0.0,Inf), -3), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), -3), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), -3), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), -3), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), -3), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), -3), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), -3), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), -3), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), -3), entireinterval()) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), -3), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.01,2.33), -3), interval(0x1.43CFBA61AACABP-4,0x1.E848P+19)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), -3), bareinterval(0x1.43CFBA61AACABP-4,0x1.E848P+19)) - @test isequal_interval(^(interval(-1.9,-0.33), -3), interval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), -3), bareinterval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3)) - @test isequal_interval(^(emptyinterval(), -7), emptyinterval()) + @test isequal_interval(nthpow(emptyinterval(BareInterval{Float64}), -7), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(entireinterval(), -7), entireinterval()) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), -7), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), -7), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(0.0,0.0), -7), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), -7), emptyinterval()) + @test isequal_interval(nthpow(bareinterval(-0.0,-0.0), -7), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(13.1,13.1), -7), interval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26)) + @test isequal_interval(nthpow(bareinterval(13.1,13.1), -7), bareinterval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26)) - @test isequal_interval(^(interval(-7451.145,-7451.145), -7), interval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91)) + @test isequal_interval(nthpow(bareinterval(-7451.145,-7451.145), -7), bareinterval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91)) - @test isequal_interval(^(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -7), interval(0x0P+0,0x0.0000000000001P-1022)) + @test isequal_interval(nthpow(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), -7), bareinterval(0x0P+0,0x0.0000000000001P-1022)) - @test isequal_interval(^(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -7), interval(-0x0.0000000000001P-1022,-0x0P+0)) + @test isequal_interval(nthpow(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), -7), bareinterval(-0x0.0000000000001P-1022,-0x0P+0)) - @test isequal_interval(^(interval(0.0,Inf), -7), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(0.0,Inf), -7), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), -7), interval(0.0,Inf)) + @test isequal_interval(nthpow(bareinterval(-0.0,Inf), -7), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-Inf,0.0), -7), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,0.0), -7), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-Inf,-0.0), -7), interval(-Inf,0.0)) + @test isequal_interval(nthpow(bareinterval(-Inf,-0.0), -7), bareinterval(-Inf,0.0)) - @test isequal_interval(^(interval(-324.3,2.5), -7), entireinterval()) + @test isequal_interval(nthpow(bareinterval(-324.3,2.5), -7), entireinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.01,2.33), -7), interval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46)) + @test isequal_interval(nthpow(bareinterval(0.01,2.33), -7), bareinterval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46)) - @test isequal_interval(^(interval(-1.9,-0.33), -7), interval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7)) + @test isequal_interval(nthpow(bareinterval(-1.9,-0.33), -7), bareinterval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7)) end @testset "minimal_pown_dec_test" begin - @test isequal_interval(^(DecoratedInterval(interval(-5.0,10.0), com), 0), DecoratedInterval(interval(1.0,1.0), com)) + @test isequal_interval(nthpow(Interval(bareinterval(-5.0,10.0), IntervalArithmetic.com), 0), Interval(bareinterval(1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(-Inf,15.0), dac), 0), DecoratedInterval(interval(1.0,1.0), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(-Inf,15.0), IntervalArithmetic.dac), 0), Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-3.0,5.0), def), 2), DecoratedInterval(interval(0.0,25.0), def)) + @test isequal_interval(nthpow(Interval(bareinterval(-3.0,5.0), IntervalArithmetic.def), 2), Interval(bareinterval(0.0,25.0), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), com), 2), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), IntervalArithmetic.com), 2), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-3.0,5.0), dac), 3), DecoratedInterval(interval(-27.0,125.0), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(-3.0,5.0), IntervalArithmetic.dac), 3), Interval(bareinterval(-27.0,125.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,2.0), com), 3), DecoratedInterval(interval(-Inf, 8.0), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,2.0), IntervalArithmetic.com), 3), Interval(bareinterval(-Inf, 8.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(3.0,5.0), com), -2), DecoratedInterval(interval(0x1.47AE147AE147AP-5,0x1.C71C71C71C71DP-4), com)) + @test isequal_interval(nthpow(Interval(bareinterval(3.0,5.0), IntervalArithmetic.com), -2), Interval(bareinterval(0x1.47AE147AE147AP-5,0x1.C71C71C71C71DP-4), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(-5.0,-3.0), def), -2), DecoratedInterval(interval(0x1.47AE147AE147AP-5,0x1.C71C71C71C71DP-4), def)) + @test isequal_interval(nthpow(Interval(bareinterval(-5.0,-3.0), IntervalArithmetic.def), -2), Interval(bareinterval(0x1.47AE147AE147AP-5,0x1.C71C71C71C71DP-4), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(-5.0,3.0), com), -2), DecoratedInterval(interval(0x1.47AE147AE147AP-5,Inf), trv)) + @test isequal_interval(nthpow(Interval(bareinterval(-5.0,3.0), IntervalArithmetic.com), -2), Interval(bareinterval(0x1.47AE147AE147AP-5,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(3.0,5.0), dac), -3), DecoratedInterval(interval(0x1.0624DD2F1A9FBP-7 ,0x1.2F684BDA12F69P-5), dac)) + @test isequal_interval(nthpow(Interval(bareinterval(3.0,5.0), IntervalArithmetic.dac), -3), Interval(bareinterval(0x1.0624DD2F1A9FBP-7 ,0x1.2F684BDA12F69P-5), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-3.0,5.0), com), -3), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(nthpow(Interval(bareinterval(-3.0,5.0), IntervalArithmetic.com), -3), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_pow_test" begin - @test isequal_interval(^(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(0.0,Inf)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(0.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-0.0,Inf)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(1.0,Inf)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(1.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-3.0,5.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-3.0,5.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(-5.0,-5.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(-5.0,-5.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(emptyinterval(), interval(5.0,5.0)), emptyinterval()) + @test isequal_interval(^(emptyinterval(BareInterval{Float64}), bareinterval(5.0,5.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.1,0.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.1,0.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.1,0.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.0,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.0,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.0,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.0,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.0,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.0,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.1,0.1)), interval(0x1.96B230BCDC434P-1,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.1,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.1,1.0)), interval(0x1.999999999999AP-4,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.1,1.0)), bareinterval(0x1.999999999999AP-4,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.1,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.1,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(0.1,Inf)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(0.1,Inf)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(1.0,1.0)), interval(0x1.999999999999AP-4,0x1P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(1.0,1.0)), bareinterval(0x1.999999999999AP-4,0x1P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(1.0,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(1.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(1.0,Inf)), interval(0.0,0x1P-1)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(1.0,Inf)), bareinterval(0.0,0x1P-1)) - @test isequal_interval(^(interval(0.1,0.5), interval(2.5,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(2.5,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(0.1,0.5), interval(2.5,Inf)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(2.5,Inf)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.1,0.1)), interval(0x1.96B230BCDC434P-1,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.1,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.1,1.0)), interval(0x1.999999999999AP-4,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.1,1.0)), bareinterval(0x1.999999999999AP-4,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.1,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.1,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.1,Inf)), interval(0.0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.1,Inf)), bareinterval(0.0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,0.1)), interval(0x1.96B230BCDC434P-1,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,1.0)), interval(0x1.999999999999AP-4,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,1.0)), bareinterval(0x1.999999999999AP-4,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,Inf)), interval(0.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,Inf)), bareinterval(0.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,0.1)), interval(0x1.96B230BCDC434P-1,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,1.0)), interval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,1.0)), bareinterval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,Inf)), interval(0.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,Inf)), bareinterval(0.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,0.1)), interval(0x1.96B230BCDC434P-1,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,0.1)), bareinterval(0x1.96B230BCDC434P-1,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,1.0)), interval(0x1.999999999999AP-4,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,1.0)), bareinterval(0x1.999999999999AP-4,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,2.5)), interval(0x1.9E7C6E43390B7P-9,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,Inf)) - @test isequal_interval(^(interval(0.1,0.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,0.0)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,0.0)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,-0.0)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,-0.0)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,0.0)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,0.0)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,-0.0)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,-0.0)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-0.1,-0.1)), interval(0x1.125FBEE250664P+0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.125FBEE250664P+0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,-0.1)), interval(0x1.125FBEE250664P+0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.125FBEE250664P+0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,-0.1)), interval(0x1.125FBEE250664P+0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.125FBEE250664P+0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-1.0,-1.0)), interval(0x1P+1,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-1.0,-1.0)), bareinterval(0x1P+1,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,-1.0)), interval(0x1P+1,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,-1.0)), bareinterval(0x1P+1,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(0.1,0.5), interval(-2.5,-2.5)), interval(0x1.6A09E667F3BCCP+2,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,0.5), interval(-Inf,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(0.1,0.5), bareinterval(-Inf,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(0.1,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.1,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.1,1.0), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.0,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.0,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.0,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.0,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.0,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.0,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.1,0.1)), interval(0x1.96B230BCDC434P-1,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.1,0.1)), bareinterval(0x1.96B230BCDC434P-1,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.1,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.1,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.1,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.1,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(0.1,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(0.1,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(1.0,1.0)), interval(0x1.999999999999AP-4,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(1.0,1.0)), bareinterval(0x1.999999999999AP-4,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(1.0,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(1.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(1.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(1.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(2.5,2.5)), interval(0x1.9E7C6E43390B7P-9,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(2.5,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(2.5,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(2.5,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,0.1)), interval(0x1.96B230BCDC434P-1,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,1.0)), interval(0x1.999999999999AP-4,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,1.0)), bareinterval(0x1.999999999999AP-4,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,Inf)), interval(0.0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,0.1)), interval(0x1.96B230BCDC434P-1,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,1.0)), interval(0x1.999999999999AP-4,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,1.0)), bareinterval(0x1.999999999999AP-4,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,Inf)), interval(0.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,0.1)), interval(0x1.96B230BCDC434P-1,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,0.1)), bareinterval(0x1.96B230BCDC434P-1,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,1.0)), interval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,1.0)), bareinterval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,2.5)), interval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,Inf)), interval(0.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,0.1)), interval(0x1.96B230BCDC434P-1,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,0.1)), bareinterval(0x1.96B230BCDC434P-1,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,1.0)), interval(0x1.999999999999AP-4,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,1.0)), bareinterval(0x1.999999999999AP-4,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,2.5)), interval(0x1.9E7C6E43390B7P-9,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,2.5)), bareinterval(0x1.9E7C6E43390B7P-9,Inf)) - @test isequal_interval(^(interval(0.1,1.0), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,0.0)), interval(1.0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,0.0)), bareinterval(1.0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,-0.0)), interval(1.0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,-0.0)), bareinterval(1.0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,0.0)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,0.0)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,-0.0)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,-0.0)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,0.0)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,0.0)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,-0.0)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,-0.0)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-0.1,-0.1)), interval(1.0,0x1.4248EF8FC2604P+0)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-0.1,-0.1)), bareinterval(1.0,0x1.4248EF8FC2604P+0)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,-0.1)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,-0.1)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,-0.1)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,-0.1)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-1.0,-1.0)), interval(1.0,0x1.4P+3)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-1.0,-1.0)), bareinterval(1.0,0x1.4P+3)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,-1.0)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,-1.0)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.1,1.0), interval(-2.5,-2.5)), interval(1.0,0x1.3C3A4EDFA9758P+8)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-2.5,-2.5)), bareinterval(1.0,0x1.3C3A4EDFA9758P+8)) - @test isequal_interval(^(interval(0.1,1.0), interval(-Inf,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.1,1.0), bareinterval(-Inf,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.5,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.5,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.0,1.0)), interval(0.5,1.5)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.0,1.0)), bareinterval(0.5,1.5)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.0,1.0)), interval(0.5,1.5)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.0,1.0)), bareinterval(0.5,1.5)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.0,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.0,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.1,0.1)), interval(0x1.DDB680117AB12P-1,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.1,0.1)), bareinterval(0x1.DDB680117AB12P-1,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.1,1.0)), interval(0.5,1.5)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.1,1.0)), bareinterval(0.5,1.5)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.1,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.1,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(1.0,1.0)), interval(0.5,1.5)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(1.0,1.0)), bareinterval(0.5,1.5)) - @test isequal_interval(^(interval(0.5,1.5), interval(1.0,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(1.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(2.5,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(2.5,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.1,0.1)), interval(0x1.DDB680117AB12P-1,0x1.125FBEE250665P+0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.1,0.1)), bareinterval(0x1.DDB680117AB12P-1,0x1.125FBEE250665P+0)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.1,1.0)), interval(0x1P-1,0x1.8P+0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.1,1.0)), bareinterval(0x1P-1,0x1.8P+0)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.1,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.1,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.1,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.1,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,0.1)), interval(0x1.5555555555555P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,0.1)), bareinterval(0x1.5555555555555P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,1.0)), interval(0x1P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,1.0)), bareinterval(0x1P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,0.1)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,1.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,2.5)), interval(0x1.6A09E667F3BCCP-3,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), entireinterval()), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), entireinterval(BareInterval{Float64})), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,0.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,0.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,-0.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,-0.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,0x1.125FBEE250665P+0)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.125FBEE250665P+0)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,-0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,-0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,0x1P+1)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,-1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,-1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,1.5), interval(-Inf,-2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(0.5,1.5), bareinterval(-Inf,-2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.5,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.5,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.0,1.0)), interval(0.5,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.0,1.0)), bareinterval(0.5,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.0,1.0)), interval(0.5,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.0,1.0)), bareinterval(0.5,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.0,2.5)), interval(0x1.6A09E667F3BCCP-3,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.0,2.5)), interval(0x1.6A09E667F3BCCP-3,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.1,0.1)), interval(0x1.DDB680117AB12P-1,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.1,0.1)), bareinterval(0x1.DDB680117AB12P-1,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.1,1.0)), interval(0.5,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.1,1.0)), bareinterval(0.5,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.1,2.5)), interval(0x1.6A09E667F3BCCP-3,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.1,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(1.0,1.0)), interval(0.5,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(1.0,1.0)), bareinterval(0.5,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(1.0,2.5)), interval(0x1.6A09E667F3BCCP-3,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(1.0,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(2.5,2.5)), interval(0x1.6A09E667F3BCCP-3,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(2.5,2.5)), bareinterval(0x1.6A09E667F3BCCP-3,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,0.0)), interval(0.0,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,0.0)), bareinterval(0.0,0x1P+1)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,-0.0)), interval(0.0,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,-0.0)), bareinterval(0.0,0x1P+1)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,0.0)), interval(0.0,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,0.0)), bareinterval(0.0,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,-0.0)), interval(0.0,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,-0.0)), bareinterval(0.0,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-0.1,-0.1)), interval(0.0,0x1.125FBEE250665P+0)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-0.1,-0.1)), bareinterval(0.0,0x1.125FBEE250665P+0)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,-0.1)), interval(0.0,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,-0.1)), bareinterval(0.0,0x1P+1)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,-0.1)), interval(0.0,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,-0.1)), bareinterval(0.0,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-1.0,-1.0)), interval(0.0,0x1P+1)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-1.0,-1.0)), bareinterval(0.0,0x1P+1)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,-1.0)), interval(0.0,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,-1.0)), bareinterval(0.0,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.5,Inf), interval(-2.5,-2.5)), interval(0.0,0x1.6A09E667F3BCDP+2)) + @test isequal_interval(^(bareinterval(0.5,Inf), bareinterval(-2.5,-2.5)), bareinterval(0.0,0x1.6A09E667F3BCDP+2)) - @test isequal_interval(^(interval(1.0,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(1.0,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(1.0,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.0,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.0,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.0,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.0,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.0,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.0,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.0,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.0,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.1,0.1)), interval(1.0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.1,0.1)), bareinterval(1.0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.1,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.1,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.1,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.1,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(0.1,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(0.1,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(1.0,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(1.0,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(1.0,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(1.0,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(1.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(1.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(2.5,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(2.5,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(2.5,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(2.5,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.1,0.1)), interval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.1,0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.1,1.0)), interval(0x1.EBA7C9E4D31E9P-1,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.1,1.0)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.1,2.5)), interval(0x1.EBA7C9E4D31E9P-1,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.1,2.5)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.1,Inf)), interval(0x1.EBA7C9E4D31E9P-1,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.1,Inf)), bareinterval(0x1.EBA7C9E4D31E9P-1,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,0.1)), interval(0x1.5555555555555P-1,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,0.1)), bareinterval(0x1.5555555555555P-1,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,1.0)), interval(0x1.5555555555555P-1,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,1.0)), bareinterval(0x1.5555555555555P-1,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,2.5)), interval(0x1.5555555555555P-1,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,2.5)), bareinterval(0x1.5555555555555P-1,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,Inf)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,Inf)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,0.1)), interval(0x1.7398BF1D1EE6FP-2,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,1.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,2.5)), interval(0x1.7398BF1D1EE6FP-2,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,Inf)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,Inf)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,0.1)), interval(0x0P+0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,0.1)), bareinterval(0x0P+0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,1.0)), interval(0x0P+0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,1.0)), bareinterval(0x0P+0,0x1.8P+0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,2.5)), interval(0x0P+0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,2.5)), bareinterval(0x0P+0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.0,1.5), entireinterval()), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,1.5), entireinterval(BareInterval{Float64})), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,-0.1)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,-0.1)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,-1.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,-1.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.0,1.5), interval(-Inf,-2.5)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,1.5), bareinterval(-Inf,-2.5)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(1.0,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(1.0,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.0,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.0,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.0,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.0,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.0,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.0,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.0,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.0,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.1,0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.1,0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.1,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.1,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.1,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.1,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(0.1,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(0.1,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(1.0,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(1.0,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(1.0,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(1.0,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(1.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(1.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(2.5,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(2.5,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(2.5,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(2.5,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.1,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.1,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.1,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.1,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.1,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.1,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.1,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.1,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), entireinterval()), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-0.1,-0.1)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-0.1,-0.1)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,-0.1)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,-0.1)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,-0.1)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,-0.1)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,-0.1)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,-0.1)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-1.0,-1.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-1.0,-1.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,-1.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,-1.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,-1.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,-1.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-2.5,-2.5)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-2.5,-2.5)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.0,Inf), interval(-Inf,-2.5)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.0,Inf), bareinterval(-Inf,-2.5)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(1.1,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(1.1,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.0,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.0,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.0,1.0)), interval(1.0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.0,1.0)), bareinterval(1.0,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.0,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.0,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.0,2.5)), interval(1.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.0,2.5)), bareinterval(1.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.1,0.1)), interval(0x1.02739C65D58BFP+0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.1,0.1)), bareinterval(0x1.02739C65D58BFP+0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.1,1.0)), interval(0x1.02739C65D58BFP+0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.1,1.0)), bareinterval(0x1.02739C65D58BFP+0,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.1,2.5)), interval(0x1.02739C65D58BFP+0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.1,2.5)), bareinterval(0x1.02739C65D58BFP+0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(0.1,Inf)), interval(0x1.02739C65D58BFP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(0.1,Inf)), bareinterval(0x1.02739C65D58BFP+0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(1.0,1.0)), interval(0x1.199999999999AP+0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(1.0,1.0)), bareinterval(0x1.199999999999AP+0,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(1.0,2.5)), interval(0x1.199999999999AP+0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(1.0,2.5)), bareinterval(0x1.199999999999AP+0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(1.0,Inf)), interval(0x1.199999999999AP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(1.0,Inf)), bareinterval(0x1.199999999999AP+0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(2.5,2.5)), interval(0x1.44E1080833B25P+0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(2.5,2.5)), bareinterval(0x1.44E1080833B25P+0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(2.5,Inf)), interval(0x1.44E1080833B25P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(2.5,Inf)), bareinterval(0x1.44E1080833B25P+0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.1,0.1)), interval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.1,0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.1,1.0)), interval(0x1.EBA7C9E4D31E9P-1,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.1,1.0)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.1,2.5)), interval(0x1.EBA7C9E4D31E9P-1,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.1,2.5)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.1,Inf)), interval(0x1.EBA7C9E4D31E9P-1,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.1,Inf)), bareinterval(0x1.EBA7C9E4D31E9P-1,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,0.1)), interval(0x1.5555555555555P-1,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,0.1)), bareinterval(0x1.5555555555555P-1,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,1.0)), interval(0x1.5555555555555P-1,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,1.0)), bareinterval(0x1.5555555555555P-1,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,2.5)), interval(0x1.5555555555555P-1,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,2.5)), bareinterval(0x1.5555555555555P-1,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,Inf)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,Inf)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,0.1)), interval(0x1.7398BF1D1EE6FP-2,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,1.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,2.5)), interval(0x1.7398BF1D1EE6FP-2,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,Inf)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,Inf)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,0.1)), interval(0x0P+0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,0.1)), bareinterval(0x0P+0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,1.0)), interval(0x0P+0,0x1.8P+0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,1.0)), bareinterval(0x0P+0,0x1.8P+0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,2.5)), interval(0x0P+0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,2.5)), bareinterval(0x0P+0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(1.1,1.5), entireinterval()), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,1.5), entireinterval(BareInterval{Float64})), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,-0.1)), interval(0x0P+0,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,-0.1)), bareinterval(0x0P+0,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,-1.0)), interval(0x0P+0,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,-1.0)), bareinterval(0x0P+0,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,0x1.9372D999784C8P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,0x1.9372D999784C8P-1)) - @test isequal_interval(^(interval(1.1,1.5), interval(-Inf,-2.5)), interval(0x0P+0,0x1.9372D999784C8P-1)) + @test isequal_interval(^(bareinterval(1.1,1.5), bareinterval(-Inf,-2.5)), bareinterval(0x0P+0,0x1.9372D999784C8P-1)) - @test isequal_interval(^(interval(1.1,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(1.1,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(1.1,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.0,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.0,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.0,1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.0,1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.0,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.0,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.0,2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.0,2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.1,0.1)), interval(0x1.02739C65D58BFP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.1,0.1)), bareinterval(0x1.02739C65D58BFP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.1,1.0)), interval(0x1.02739C65D58BFP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.1,1.0)), bareinterval(0x1.02739C65D58BFP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.1,2.5)), interval(0x1.02739C65D58BFP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.1,2.5)), bareinterval(0x1.02739C65D58BFP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(0.1,Inf)), interval(0x1.02739C65D58BFP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(0.1,Inf)), bareinterval(0x1.02739C65D58BFP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(1.0,1.0)), interval(0x1.199999999999AP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(1.0,1.0)), bareinterval(0x1.199999999999AP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(1.0,2.5)), interval(0x1.199999999999AP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(1.0,2.5)), bareinterval(0x1.199999999999AP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(1.0,Inf)), interval(0x1.199999999999AP+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(1.0,Inf)), bareinterval(0x1.199999999999AP+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(2.5,2.5)), interval(0x1.44E1080833B25P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(2.5,2.5)), bareinterval(0x1.44E1080833B25P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(2.5,Inf)), interval(0x1.44E1080833B25P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(2.5,Inf)), bareinterval(0x1.44E1080833B25P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.1,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.1,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.1,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.1,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.1,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.1,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.1,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.1,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,Inf)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,Inf)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,0.1)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,0.1)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,1.0)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,1.0)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,2.5)), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,2.5)), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), entireinterval()), interval(0x0P+0,Inf)) + @test isequal_interval(^(bareinterval(1.1,Inf), entireinterval(BareInterval{Float64})), bareinterval(0x0P+0,Inf)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,-0.0)), interval(0x0P+0,1.0)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,-0.0)), bareinterval(0x0P+0,1.0)) - @test isequal_interval(^(interval(1.1,Inf), interval(-0.1,-0.1)), interval(0x0P+0,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-0.1,-0.1)), bareinterval(0x0P+0,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,-0.1)), interval(0x0P+0,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,-0.1)), bareinterval(0x0P+0,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,-0.1)), interval(0x0P+0,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,-0.1)), bareinterval(0x0P+0,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,-0.1)), interval(0x0P+0,0x1.FB24AF5281928P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,-0.1)), bareinterval(0x0P+0,0x1.FB24AF5281928P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-1.0,-1.0)), interval(0x0P+0,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-1.0,-1.0)), bareinterval(0x0P+0,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,-1.0)), interval(0x0P+0,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,-1.0)), bareinterval(0x0P+0,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,-1.0)), interval(0x0P+0,0x1.D1745D1745D17P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,-1.0)), bareinterval(0x0P+0,0x1.D1745D1745D17P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-2.5,-2.5)), interval(0x0P+0,0x1.9372D999784C8P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-2.5,-2.5)), bareinterval(0x0P+0,0x1.9372D999784C8P-1)) - @test isequal_interval(^(interval(1.1,Inf), interval(-Inf,-2.5)), interval(0x0P+0,0x1.9372D999784C8P-1)) + @test isequal_interval(^(bareinterval(1.1,Inf), bareinterval(-Inf,-2.5)), bareinterval(0x0P+0,0x1.9372D999784C8P-1)) - @test isequal_interval(^(interval(0.0,0.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.1,0.1)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.1,1.0)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.1,1.0)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.1,2.5)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.0,0.5), interval(0.1,Inf)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(0.1,Inf)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(0.0,0.5), interval(1.0,1.0)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(1.0,1.0)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(0.0,0.5), interval(1.0,2.5)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(1.0,2.5)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(0.0,0.5), interval(1.0,Inf)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(1.0,Inf)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(0.0,0.5), interval(2.5,2.5)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(0.0,0.5), interval(2.5,Inf)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(2.5,Inf)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-0.1,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-1.0,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-1.0,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-2.5,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(0.0,0.5), interval(-Inf,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(0.0,0.5), bareinterval(-Inf,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(0.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,1.0), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.1,0.1)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.1,0.1)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.1,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.1,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.1,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.1,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(0.1,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(0.1,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(1.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(1.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(1.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(1.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(1.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(1.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(2.5,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(2.5,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(2.5,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(2.5,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-0.1,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-0.1,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-1.0,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-1.0,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-2.5,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-2.5,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.0), interval(-Inf,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.0), bareinterval(-Inf,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.1,0.1)), interval(0.0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.1,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.1,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.1,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.0,1.5), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(1.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(1.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(0.0,1.5), interval(1.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(1.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.0,1.5), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(2.5,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(0.0,1.5), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(0.0,1.5), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,1.5), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-0.1,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-0.1,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-1.0,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-1.0,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,Inf), interval(-2.5,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(0.0,Inf), bareinterval(-2.5,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.1,0.1)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.1,1.0)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.1,1.0)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.1,2.5)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.0,0.5), interval(0.1,Inf)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(0.1,Inf)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.0,0.5), interval(1.0,1.0)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(1.0,1.0)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.0,0.5), interval(1.0,2.5)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(1.0,2.5)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.0,0.5), interval(1.0,Inf)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(1.0,Inf)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.0,0.5), interval(2.5,2.5)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(-0.0,0.5), interval(2.5,Inf)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(2.5,Inf)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-0.1,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-1.0,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-1.0,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-2.5,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(-0.0,0.5), interval(-Inf,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,0.5), bareinterval(-Inf,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.1,0.1)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.1,0.1)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.1,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.1,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.1,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.1,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(0.1,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(0.1,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(1.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(1.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(1.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(1.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(1.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(1.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(2.5,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(2.5,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(2.5,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(2.5,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-0.1,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-0.1,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-1.0,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-1.0,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-2.5,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-2.5,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.0), interval(-Inf,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.0), bareinterval(-Inf,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.1,0.1)), interval(0.0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.1,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.1,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.1,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.0,1.5), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(1.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(1.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.0,1.5), interval(1.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(1.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.0,1.5), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(2.5,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.0,1.5), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.0,1.5), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,1.5), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-0.1,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-0.1,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-1.0,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-1.0,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.0,Inf), interval(-2.5,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.0,Inf), bareinterval(-2.5,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.1,0.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.1,0.1)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.1,1.0)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.1,1.0)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.1,2.5)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.1,0.5), interval(0.1,Inf)), interval(0.0,0x1.DDB680117AB13P-1)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(0.1,Inf)), bareinterval(0.0,0x1.DDB680117AB13P-1)) - @test isequal_interval(^(interval(-0.1,0.5), interval(1.0,1.0)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(1.0,1.0)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.1,0.5), interval(1.0,2.5)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(1.0,2.5)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.1,0.5), interval(1.0,Inf)), interval(0.0,0.5)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(1.0,Inf)), bareinterval(0.0,0.5)) - @test isequal_interval(^(interval(-0.1,0.5), interval(2.5,2.5)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(-0.1,0.5), interval(2.5,Inf)), interval(0.0,0x1.6A09E667F3BCDP-3)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(2.5,Inf)), bareinterval(0.0,0x1.6A09E667F3BCDP-3)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-0.1,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,-0.1)), interval(0x1.125FBEE250664P+0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,-0.1)), bareinterval(0x1.125FBEE250664P+0,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-1.0,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-1.0,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,-1.0)), interval(0x1P+1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,-1.0)), bareinterval(0x1P+1,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-2.5,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(-0.1,0.5), interval(-Inf,-2.5)), interval(0x1.6A09E667F3BCCP+2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,0.5), bareinterval(-Inf,-2.5)), bareinterval(0x1.6A09E667F3BCCP+2,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.1,1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.1,0.1)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.1,0.1)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.1,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.1,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.1,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.1,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(0.1,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(0.1,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(1.0,1.0)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(1.0,1.0)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(1.0,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(1.0,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(1.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(1.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(2.5,2.5)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(2.5,2.5)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(2.5,Inf)), interval(0.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(2.5,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-0.1,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-0.1,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,-0.1)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,-0.1)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-1.0,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-1.0,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,-1.0)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,-1.0)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-2.5,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-2.5,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.0), interval(-Inf,-2.5)), interval(1.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.0), bareinterval(-Inf,-2.5)), bareinterval(1.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.1,1.5), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.1,0.1)), interval(0.0,0x1.0A97DCE72A0CBP+0)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.1,0.1)), bareinterval(0.0,0x1.0A97DCE72A0CBP+0)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.1,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.1,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.1,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.1,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.1,1.5), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(1.0,1.0)), interval(0.0,1.5)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(1.0,1.0)), bareinterval(0.0,1.5)) - @test isequal_interval(^(interval(-0.1,1.5), interval(1.0,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(1.0,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.1,1.5), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(2.5,2.5)), interval(0.0,0x1.60B9FD68A4555P+1)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(2.5,2.5)), bareinterval(0.0,0x1.60B9FD68A4555P+1)) - @test isequal_interval(^(interval(-0.1,1.5), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,-0.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,-0.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,-0.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,-0.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-0.1,-0.1)), interval(0x1.EBA7C9E4D31E9P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-0.1,-0.1)), bareinterval(0x1.EBA7C9E4D31E9P-1,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,-0.1)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,-0.1)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,-0.1)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,-0.1)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-1.0,-1.0)), interval(0x1.5555555555555P-1,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-1.0,-1.0)), bareinterval(0x1.5555555555555P-1,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,-1.0)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,-1.0)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-2.5,-2.5)), interval(0x1.7398BF1D1EE6FP-2,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-2.5,-2.5)), bareinterval(0x1.7398BF1D1EE6FP-2,Inf)) - @test isequal_interval(^(interval(-0.1,1.5), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,1.5), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.1,Inf), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.1,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.1,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.1,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.1,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.1,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.1,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.1,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.1,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), entireinterval()), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,-0.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,-0.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-0.1,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-0.1,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,-0.1)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,-0.1)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-1.0,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-1.0,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,-1.0)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,-1.0)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-Inf,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-Inf,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(-0.1,Inf), interval(-2.5,-2.5)), interval(0.0,Inf)) + @test isequal_interval(^(bareinterval(-0.1,Inf), bareinterval(-2.5,-2.5)), bareinterval(0.0,Inf)) - @test isequal_interval(^(interval(0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,-0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,-0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,-0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-0.0,0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-0.0,0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-0.0,0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(0.0,-0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(0.0,-0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(0.0,-0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.1,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.1,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.1,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.1,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.1,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.1,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.1,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.1,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,Inf)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,0.1)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,0.1)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,2.5)), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,2.5)), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), entireinterval()), interval(0.0,0.0)) + @test isequal_interval(^(bareinterval(-1.0,-0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0.0)) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.0), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.0), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), emptyinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.0,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.0,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.0,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.0,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.0,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.0,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.0,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.0,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.1,0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.1,0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.1,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.1,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.1,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.1,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(0.1,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(0.1,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(1.0,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(1.0,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(1.0,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(1.0,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(1.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(2.5,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(2.5,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(2.5,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(2.5,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.1,0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.1,0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.1,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.1,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.1,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.1,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.1,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.1,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,Inf)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), entireinterval()), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-0.1,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-0.1,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,-0.1)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,-0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-Inf,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-Inf,-2.5)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(^(interval(-1.0,-0.1), interval(-2.5,-2.5)), emptyinterval()) + @test isequal_interval(^(bareinterval(-1.0,-0.1), bareinterval(-2.5,-2.5)), emptyinterval(BareInterval{Float64})) end @testset "minimal_pow_dec_test" begin - @test isequal_interval(^(DecoratedInterval(interval(0.1,0.5), com), DecoratedInterval(interval(0.0,1.0), com)), DecoratedInterval(interval(0x1.999999999999AP-4,1.0), com)) + @test isequal_interval(^(Interval(bareinterval(0.1,0.5), IntervalArithmetic.com), Interval(bareinterval(0.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.999999999999AP-4,1.0), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,0.5), com), DecoratedInterval(interval(0.1,0.1), def)), DecoratedInterval(interval(0x1.96B230BCDC434P-1,0x1.DDB680117AB13P-1), def)) + @test isequal_interval(^(Interval(bareinterval(0.1,0.5), IntervalArithmetic.com), Interval(bareinterval(0.1,0.1), IntervalArithmetic.def)), Interval(bareinterval(0x1.96B230BCDC434P-1,0x1.DDB680117AB13P-1), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,0.5), trv), DecoratedInterval(interval(-2.5,2.5), dac)), DecoratedInterval(interval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8), trv)) + @test isequal_interval(^(Interval(bareinterval(0.1,0.5), IntervalArithmetic.trv), Interval(bareinterval(-2.5,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0x1.9E7C6E43390B7P-9,0x1.3C3A4EDFA9758P+8), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,0.5), com), DecoratedInterval(interval(-2.5,Inf), dac)), DecoratedInterval(interval(0.0,0x1.3C3A4EDFA9758P+8), dac)) + @test isequal_interval(^(Interval(bareinterval(0.1,0.5), IntervalArithmetic.com), Interval(bareinterval(-2.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.3C3A4EDFA9758P+8), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,0.5), trv), DecoratedInterval(interval(-Inf,0.1), dac)), DecoratedInterval(interval(0x1.96B230BCDC434P-1,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.1,0.5), IntervalArithmetic.trv), Interval(bareinterval(-Inf,0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.96B230BCDC434P-1,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,1.0), com), DecoratedInterval(interval(0.0,2.5), com)), DecoratedInterval(interval(0x1.9E7C6E43390B7P-9,1.0), com)) + @test isequal_interval(^(Interval(bareinterval(0.1,1.0), IntervalArithmetic.com), Interval(bareinterval(0.0,2.5), IntervalArithmetic.com)), Interval(bareinterval(0x1.9E7C6E43390B7P-9,1.0), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,1.0), def), DecoratedInterval(interval(1.0,1.0), dac)), DecoratedInterval(interval(0x1.999999999999AP-4,1.0), def)) + @test isequal_interval(^(Interval(bareinterval(0.1,1.0), IntervalArithmetic.def), Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.999999999999AP-4,1.0), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(0.1,1.0), trv), DecoratedInterval(interval(-2.5,1.0), def)), DecoratedInterval(interval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8), trv)) + @test isequal_interval(^(Interval(bareinterval(0.1,1.0), IntervalArithmetic.trv), Interval(bareinterval(-2.5,1.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.999999999999AP-4,0x1.3C3A4EDFA9758P+8), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.5,1.5), dac), DecoratedInterval(interval(0.1,0.1), com)), DecoratedInterval(interval(0x1.DDB680117AB12P-1,0x1.0A97DCE72A0CBP+0), dac)) + @test isequal_interval(^(Interval(bareinterval(0.5,1.5), IntervalArithmetic.dac), Interval(bareinterval(0.1,0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.DDB680117AB12P-1,0x1.0A97DCE72A0CBP+0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.5,1.5), def), DecoratedInterval(interval(-2.5,0.1), trv)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2), trv)) + @test isequal_interval(^(Interval(bareinterval(0.5,1.5), IntervalArithmetic.def), Interval(bareinterval(-2.5,0.1), IntervalArithmetic.trv)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.5,1.5), com), DecoratedInterval(interval(-2.5,-2.5), com)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2), com)) + @test isequal_interval(^(Interval(bareinterval(0.5,1.5), IntervalArithmetic.com), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.com)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,0x1.6A09E667F3BCDP+2), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(0.5,Inf), dac), DecoratedInterval(interval(0.1,0.1), com)), DecoratedInterval(interval(0x1.DDB680117AB12P-1,Inf), dac)) + @test isequal_interval(^(Interval(bareinterval(0.5,Inf), IntervalArithmetic.dac), Interval(bareinterval(0.1,0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.DDB680117AB12P-1,Inf), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.5,Inf), def), DecoratedInterval(interval(-2.5,-0.0), com)), DecoratedInterval(interval(0.0,0x1.6A09E667F3BCDP+2), def)) + @test isequal_interval(^(Interval(bareinterval(0.5,Inf), IntervalArithmetic.def), Interval(bareinterval(-2.5,-0.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.6A09E667F3BCDP+2), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(1.0,1.5), com), DecoratedInterval(interval(-0.1,0.1), def)), DecoratedInterval(interval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0), def)) + @test isequal_interval(^(Interval(bareinterval(1.0,1.5), IntervalArithmetic.com), Interval(bareinterval(-0.1,0.1), IntervalArithmetic.def)), Interval(bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.0A97DCE72A0CBP+0), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(1.0,1.5), trv), DecoratedInterval(interval(-0.1,-0.1), com)), DecoratedInterval(interval(0x1.EBA7C9E4D31E9P-1,1.0), trv)) + @test isequal_interval(^(Interval(bareinterval(1.0,1.5), IntervalArithmetic.trv), Interval(bareinterval(-0.1,-0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.EBA7C9E4D31E9P-1,1.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(1.0,Inf), dac), DecoratedInterval(interval(1.0,1.0), dac)), DecoratedInterval(interval(1.0,Inf), dac)) + @test isequal_interval(^(Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac), Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(1.0,Inf), def), DecoratedInterval(interval(-1.0,-0.0), dac)), DecoratedInterval(interval(0x0P+0,1.0), def)) + @test isequal_interval(^(Interval(bareinterval(1.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-1.0,-0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x0P+0,1.0), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(1.1,1.5), def), DecoratedInterval(interval(1.0,2.5), com)), DecoratedInterval(interval(0x1.199999999999AP+0,0x1.60B9FD68A4555P+1), def)) + @test isequal_interval(^(Interval(bareinterval(1.1,1.5), IntervalArithmetic.def), Interval(bareinterval(1.0,2.5), IntervalArithmetic.com)), Interval(bareinterval(0x1.199999999999AP+0,0x1.60B9FD68A4555P+1), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(1.1,1.5), com), DecoratedInterval(interval(-0.1,-0.1), com)), DecoratedInterval(interval(0x1.EBA7C9E4D31E9P-1,0x1.FB24AF5281928P-1), com)) + @test isequal_interval(^(Interval(bareinterval(1.1,1.5), IntervalArithmetic.com), Interval(bareinterval(-0.1,-0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.EBA7C9E4D31E9P-1,0x1.FB24AF5281928P-1), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(1.1,Inf), dac), DecoratedInterval(interval(0.1,Inf), dac)), DecoratedInterval(interval(0x1.02739C65D58BFP+0,Inf), dac)) + @test isequal_interval(^(Interval(bareinterval(1.1,Inf), IntervalArithmetic.dac), Interval(bareinterval(0.1,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0x1.02739C65D58BFP+0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(1.1,Inf), def), DecoratedInterval(interval(-2.5,Inf), dac)), DecoratedInterval(interval(0x0P+0,Inf), def)) + @test isequal_interval(^(Interval(bareinterval(1.1,Inf), IntervalArithmetic.def), Interval(bareinterval(-2.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0x0P+0,Inf), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(1.1,Inf), trv), DecoratedInterval(interval(-Inf,-1.0), def)), DecoratedInterval(interval(0x0P+0,0x1.D1745D1745D17P-1), trv)) + @test isequal_interval(^(Interval(bareinterval(1.1,Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,-1.0), IntervalArithmetic.def)), Interval(bareinterval(0x0P+0,0x1.D1745D1745D17P-1), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.5), com), DecoratedInterval(interval(0.1,0.1), com)), DecoratedInterval(interval(0.0,0x1.DDB680117AB13P-1), com)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.5), IntervalArithmetic.com), Interval(bareinterval(0.1,0.1), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.DDB680117AB13P-1), IntervalArithmetic.com)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.5), com), DecoratedInterval(interval(2.5,Inf), dac)), DecoratedInterval(interval(0.0,0x1.6A09E667F3BCDP-3), dac)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.5), IntervalArithmetic.com), Interval(bareinterval(2.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.6A09E667F3BCDP-3), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.5), com), DecoratedInterval(interval(-Inf,-2.5), dac)), DecoratedInterval(interval(0x1.6A09E667F3BCCP+2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.5), IntervalArithmetic.com), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.dac)), Interval(bareinterval(0x1.6A09E667F3BCCP+2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), com), DecoratedInterval(interval(0.0,0.0), com)), DecoratedInterval(interval(1.0,1.0), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.com), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), def), DecoratedInterval(interval(0.0,2.5), dac)), DecoratedInterval(interval(0.0,1.0), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.def), Interval(bareinterval(0.0,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), dac), DecoratedInterval(interval(1.0,2.5), com)), DecoratedInterval(interval(0.0,1.0), dac)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(1.0,2.5), IntervalArithmetic.com)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), com), DecoratedInterval(interval(-2.5,0.1), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.com), Interval(bareinterval(-2.5,0.1), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), def), DecoratedInterval(entireinterval(), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), dac), DecoratedInterval(interval(-0.1,0.0), com)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(-0.1,0.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), com), DecoratedInterval(interval(-Inf,0.0), dac)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.com), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.dac)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.0), def), DecoratedInterval(interval(-Inf,-2.5), dac)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.0), IntervalArithmetic.def), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.dac)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.5), com), DecoratedInterval(interval(0.0,2.5), com)), DecoratedInterval(interval(0.0,0x1.60B9FD68A4555P+1), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.5), IntervalArithmetic.com), Interval(bareinterval(0.0,2.5), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.60B9FD68A4555P+1), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.5), def), DecoratedInterval(interval(2.5,2.5), dac)), DecoratedInterval(interval(0.0,0x1.60B9FD68A4555P+1), def)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.5), IntervalArithmetic.def), Interval(bareinterval(2.5,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.60B9FD68A4555P+1), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.5), dac), DecoratedInterval(interval(-1.0,0.0), com)), DecoratedInterval(interval(0x1.5555555555555P-1,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.5), IntervalArithmetic.dac), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.5555555555555P-1,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,1.5), com), DecoratedInterval(interval(-2.5,-2.5), def)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,1.5), IntervalArithmetic.com), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.def)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,Inf), dac), DecoratedInterval(interval(0.1,0.1), com)), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(^(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), Interval(bareinterval(0.1,0.1), IntervalArithmetic.com)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,Inf), def), DecoratedInterval(interval(-1.0,1.0), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,Inf), trv), DecoratedInterval(interval(-Inf,-1.0), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,-1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,Inf), dac), DecoratedInterval(interval(-2.5,-2.5), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), com), DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,1.0), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.com), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), def), DecoratedInterval(interval(0.1,Inf), def)), DecoratedInterval(interval(0.0,0x1.DDB680117AB13P-1), def)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.def), Interval(bareinterval(0.1,Inf), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.DDB680117AB13P-1), IntervalArithmetic.def)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), dac), DecoratedInterval(interval(2.5,2.5), com)), DecoratedInterval(interval(0.0,0x1.6A09E667F3BCDP-3), dac)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.dac), Interval(bareinterval(2.5,2.5), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.6A09E667F3BCDP-3), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), trv), DecoratedInterval(interval(-2.5,-0.0), dac)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.trv), Interval(bareinterval(-2.5,-0.0), IntervalArithmetic.dac)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), com), DecoratedInterval(interval(-Inf,-0.1), def)), DecoratedInterval(interval(0x1.125FBEE250664P+0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.com), Interval(bareinterval(-Inf,-0.1), IntervalArithmetic.def)), Interval(bareinterval(0x1.125FBEE250664P+0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,0.5), def), DecoratedInterval(interval(-Inf,-2.5), dac)), DecoratedInterval(interval(0x1.6A09E667F3BCCP+2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,0.5), IntervalArithmetic.def), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.dac)), Interval(bareinterval(0x1.6A09E667F3BCCP+2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.0), com), DecoratedInterval(interval(2.5,2.5), dac)), DecoratedInterval(interval(0.0,1.0), dac)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.0), IntervalArithmetic.com), Interval(bareinterval(2.5,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.0), dac), DecoratedInterval(interval(-1.0,Inf), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.0), com), DecoratedInterval(entireinterval(), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.0), IntervalArithmetic.com), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.0), def), DecoratedInterval(interval(-2.5,-2.5), com)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.0), IntervalArithmetic.def), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.com)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.0), dac), DecoratedInterval(interval(-Inf,-2.5), def)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.def)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.5), com), DecoratedInterval(interval(0.1,2.5), dac)), DecoratedInterval(interval(0.0,0x1.60B9FD68A4555P+1), dac)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.5), IntervalArithmetic.com), Interval(bareinterval(0.1,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.60B9FD68A4555P+1), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.5), def), DecoratedInterval(interval(-1.0,0.0), trv)), DecoratedInterval(interval(0x1.5555555555555P-1,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.5), IntervalArithmetic.def), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.5555555555555P-1,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.5), dac), DecoratedInterval(interval(-2.5,-0.1), def)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.5), IntervalArithmetic.dac), Interval(bareinterval(-2.5,-0.1), IntervalArithmetic.def)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.5), com), DecoratedInterval(interval(-2.5,-2.5), com)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.5), IntervalArithmetic.com), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.com)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,1.5), def), DecoratedInterval(interval(-Inf,-2.5), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,1.5), IntervalArithmetic.def), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,Inf), dac), DecoratedInterval(interval(-0.1,Inf), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.1,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,Inf), def), DecoratedInterval(interval(-2.5,-0.0), com)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-2.5,-0.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,Inf), trv), DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.trv), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,Inf), dac), DecoratedInterval(interval(-Inf,-0.0), trv)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.0,Inf), def), DecoratedInterval(interval(-Inf,-1.0), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-Inf,-1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,0.5), def), DecoratedInterval(interval(0.1,Inf), dac)), DecoratedInterval(interval(0.0,0x1.DDB680117AB13P-1), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,0.5), IntervalArithmetic.def), Interval(bareinterval(0.1,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.DDB680117AB13P-1), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,0.5), com), DecoratedInterval(interval(-0.1,-0.1), com)), DecoratedInterval(interval(0x1.125FBEE250664P+0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,0.5), IntervalArithmetic.com), Interval(bareinterval(-0.1,-0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.125FBEE250664P+0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,0.5), dac), DecoratedInterval(interval(-Inf,-2.5), def)), DecoratedInterval(interval(0x1.6A09E667F3BCCP+2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,0.5), IntervalArithmetic.dac), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.def)), Interval(bareinterval(0x1.6A09E667F3BCCP+2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.0), com), DecoratedInterval(interval(0.0,0.0), com)), DecoratedInterval(interval(1.0,1.0), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.com), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.0), dac), DecoratedInterval(interval(-Inf,2.5), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.0), def), DecoratedInterval(interval(-Inf,-1.0), def)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.def), Interval(bareinterval(-Inf,-1.0), IntervalArithmetic.def)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.0), com), DecoratedInterval(interval(-2.5,-2.5), com)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.com), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.com)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.0), trv), DecoratedInterval(interval(-Inf,-2.5), trv)), DecoratedInterval(interval(1.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv), Interval(bareinterval(-Inf,-2.5), IntervalArithmetic.trv)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.5), trv), DecoratedInterval(interval(0.0,2.5), com)), DecoratedInterval(interval(0.0,0x1.60B9FD68A4555P+1), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.5), IntervalArithmetic.trv), Interval(bareinterval(0.0,2.5), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.60B9FD68A4555P+1), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.5), com), DecoratedInterval(interval(2.5,2.5), dac)), DecoratedInterval(interval(0.0,0x1.60B9FD68A4555P+1), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.5), IntervalArithmetic.com), Interval(bareinterval(2.5,2.5), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.60B9FD68A4555P+1), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.5), dac), DecoratedInterval(interval(-1.0,0.0), trv)), DecoratedInterval(interval(0x1.5555555555555P-1,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.5), IntervalArithmetic.dac), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.5555555555555P-1,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.5), com), DecoratedInterval(interval(-0.1,-0.1), com)), DecoratedInterval(interval(0x1.EBA7C9E4D31E9P-1,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.5), IntervalArithmetic.com), Interval(bareinterval(-0.1,-0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.EBA7C9E4D31E9P-1,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,1.5), def), DecoratedInterval(interval(-2.5,-2.5), def)), DecoratedInterval(interval(0x1.7398BF1D1EE6FP-2,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,1.5), IntervalArithmetic.def), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.def)), Interval(bareinterval(0x1.7398BF1D1EE6FP-2,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,Inf), dac), DecoratedInterval(interval(-0.1,2.5), com)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.1,2.5), IntervalArithmetic.com)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,Inf), def), DecoratedInterval(interval(-2.5,0.0), def)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,Inf), IntervalArithmetic.def), Interval(bareinterval(-2.5,0.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-0.1,Inf), dac), DecoratedInterval(interval(-2.5,-2.5), trv)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(^(Interval(bareinterval(-0.1,Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.5,-2.5), IntervalArithmetic.trv)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.0), com), DecoratedInterval(interval(1.0,Inf), dac)), DecoratedInterval(interval(0.0,0.0), dac)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.0), com), DecoratedInterval(interval(-2.5,0.1), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), Interval(bareinterval(-2.5,0.1), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(0.0,0.0), dac), DecoratedInterval(interval(-1.0,0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(^(Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-1.0,-0.1), com), DecoratedInterval(interval(-0.1,1.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(^(Interval(bareinterval(-1.0,-0.1), IntervalArithmetic.com), Interval(bareinterval(-0.1,1.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-1.0,-0.1), dac), DecoratedInterval(interval(-0.1,2.5), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(^(Interval(bareinterval(-1.0,-0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.1,2.5), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(^(DecoratedInterval(interval(-1.0,-0.1), def), DecoratedInterval(interval(-0.1,Inf), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(^(Interval(bareinterval(-1.0,-0.1), IntervalArithmetic.def), Interval(bareinterval(-0.1,Inf), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_exp_test" begin - @test isequal_interval(exp(emptyinterval()), emptyinterval()) + @test isequal_interval(exp(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(exp(interval(-Inf,0.0)), interval(0.0,1.0)) + @test isequal_interval(exp(bareinterval(-Inf,0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp(interval(-Inf,-0.0)), interval(0.0,1.0)) + @test isequal_interval(exp(bareinterval(-Inf,-0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp(interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp(bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp(interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp(bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(exp(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(exp(interval(-Inf,0x1.62E42FEFA39FP+9)), interval(0.0,Inf)) + @test isequal_interval(exp(bareinterval(-Inf,0x1.62E42FEFA39FP+9)), bareinterval(0.0,Inf)) - @test isequal_interval(exp(interval(0x1.62E42FEFA39FP+9,0x1.62E42FEFA39FP+9)), interval( 0x1.FFFFFFFFFFFFFP+1023,Inf)) + @test isequal_interval(exp(bareinterval(0x1.62E42FEFA39FP+9,0x1.62E42FEFA39FP+9)), bareinterval( 0x1.FFFFFFFFFFFFFP+1023,Inf)) - @test isequal_interval(exp(interval(0.0,0x1.62E42FEFA39EP+9)), interval(1.0,0x1.FFFFFFFFFC32BP+1023)) + @test isequal_interval(exp(bareinterval(0.0,0x1.62E42FEFA39EP+9)), bareinterval(1.0,0x1.FFFFFFFFFC32BP+1023)) - @test isequal_interval(exp(interval(-0.0,0x1.62E42FEFA39EP+9)), interval(1.0,0x1.FFFFFFFFFC32BP+1023)) + @test isequal_interval(exp(bareinterval(-0.0,0x1.62E42FEFA39EP+9)), bareinterval(1.0,0x1.FFFFFFFFFC32BP+1023)) - @test isequal_interval(exp(interval(-0x1.6232BDD7ABCD3P+9,0x1.62E42FEFA39EP+9)), interval(0x0.FFFFFFFFFFE7BP-1022,0x1.FFFFFFFFFC32BP+1023)) + @test isequal_interval(exp(bareinterval(-0x1.6232BDD7ABCD3P+9,0x1.62E42FEFA39EP+9)), bareinterval(0x0.FFFFFFFFFFE7BP-1022,0x1.FFFFFFFFFC32BP+1023)) - @test isequal_interval(exp(interval(-0x1.6232BDD7ABCD3P+8,0x1.62E42FEFA39EP+9)), interval(0x1.FFFFFFFFFFE7BP-512,0x1.FFFFFFFFFC32BP+1023)) + @test isequal_interval(exp(bareinterval(-0x1.6232BDD7ABCD3P+8,0x1.62E42FEFA39EP+9)), bareinterval(0x1.FFFFFFFFFFE7BP-512,0x1.FFFFFFFFFC32BP+1023)) - @test isequal_interval(exp(interval(-0x1.6232BDD7ABCD3P+8,0.0)), interval(0x1.FFFFFFFFFFE7BP-512,1.0)) + @test isequal_interval(exp(bareinterval(-0x1.6232BDD7ABCD3P+8,0.0)), bareinterval(0x1.FFFFFFFFFFE7BP-512,1.0)) - @test isequal_interval(exp(interval(-0x1.6232BDD7ABCD3P+8,-0.0)), interval(0x1.FFFFFFFFFFE7BP-512,1.0)) + @test isequal_interval(exp(bareinterval(-0x1.6232BDD7ABCD3P+8,-0.0)), bareinterval(0x1.FFFFFFFFFFE7BP-512,1.0)) - @test isequal_interval(exp(interval(-0x1.6232BDD7ABCD3P+8,1.0)), interval(0x1.FFFFFFFFFFE7BP-512,0x1.5BF0A8B14576AP+1)) + @test isequal_interval(exp(bareinterval(-0x1.6232BDD7ABCD3P+8,1.0)), bareinterval(0x1.FFFFFFFFFFE7BP-512,0x1.5BF0A8B14576AP+1)) - @test isequal_interval(exp(interval(1.0,5.0)), interval(0x1.5BF0A8B145769P+1,0x1.28D389970339P+7)) + @test isequal_interval(exp(bareinterval(1.0,5.0)), bareinterval(0x1.5BF0A8B145769P+1,0x1.28D389970339P+7)) - @test isequal_interval(exp(interval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), interval(0x1.2797F0A337A5FP-5,0x1.86091CC9095C5P+2)) + @test isequal_interval(exp(bareinterval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), bareinterval(0x1.2797F0A337A5FP-5,0x1.86091CC9095C5P+2)) - @test isequal_interval(exp(interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), interval(0x1.1337E9E45812AP+1, 0x1.805A5C88021B6P+142)) + @test isequal_interval(exp(bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), bareinterval(0x1.1337E9E45812AP+1, 0x1.805A5C88021B6P+142)) - @test isequal_interval(exp(interval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), interval(0x1.EF461A783114CP+16,0x1.691D36C6B008CP+37)) + @test isequal_interval(exp(bareinterval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), bareinterval(0x1.EF461A783114CP+16,0x1.691D36C6B008CP+37)) end @testset "minimal_exp_dec_test" begin - @test isequal_interval(exp(DecoratedInterval(interval(0x1.62E42FEFA39FP+9,0x1.62E42FEFA39FP+9), com)), DecoratedInterval(interval( 0x1.FFFFFFFFFFFFFP+1023,Inf), dac)) + @test isequal_interval(exp(Interval(bareinterval(0x1.62E42FEFA39FP+9,0x1.62E42FEFA39FP+9), IntervalArithmetic.com)), Interval(bareinterval( 0x1.FFFFFFFFFFFFFP+1023,Inf), IntervalArithmetic.dac)) - @test isequal_interval(exp(DecoratedInterval(interval(0.0,0x1.62E42FEFA39EP+9), def)), DecoratedInterval(interval(1.0,0x1.FFFFFFFFFC32BP+1023), def)) + @test isequal_interval(exp(Interval(bareinterval(0.0,0x1.62E42FEFA39EP+9), IntervalArithmetic.def)), Interval(bareinterval(1.0,0x1.FFFFFFFFFC32BP+1023), IntervalArithmetic.def)) end @testset "minimal_exp2_test" begin - @test isequal_interval(exp2(emptyinterval()), emptyinterval()) + @test isequal_interval(exp2(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(exp2(interval(-Inf,0.0)), interval(0.0,1.0)) + @test isequal_interval(exp2(bareinterval(-Inf,0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp2(interval(-Inf,-0.0)), interval(0.0,1.0)) + @test isequal_interval(exp2(bareinterval(-Inf,-0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp2(interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp2(bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp2(interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp2(bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp2(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(exp2(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(exp2(interval(-Inf,1024.0)), interval(0.0,Inf)) + @test isequal_interval(exp2(bareinterval(-Inf,1024.0)), bareinterval(0.0,Inf)) - @test isequal_interval(exp2(interval(1024.0,1024.0)), interval(0x1.FFFFFFFFFFFFFP+1023,Inf)) + @test isequal_interval(exp2(bareinterval(1024.0,1024.0)), bareinterval(0x1.FFFFFFFFFFFFFP+1023,Inf)) - @test isequal_interval(exp2(interval(0.0,1023.0)), interval(1.0,0x1P+1023)) + @test isequal_interval(exp2(bareinterval(0.0,1023.0)), bareinterval(1.0,0x1P+1023)) - @test isequal_interval(exp2(interval(-0.0,1023.0)), interval(1.0,0x1P+1023)) + @test isequal_interval(exp2(bareinterval(-0.0,1023.0)), bareinterval(1.0,0x1P+1023)) - @test isequal_interval(exp2(interval(-1022.0,1023.0)), interval(0x1P-1022,0x1P+1023)) + @test isequal_interval(exp2(bareinterval(-1022.0,1023.0)), bareinterval(0x1P-1022,0x1P+1023)) - @test isequal_interval(exp2(interval(-1022.0,0.0)), interval(0x1P-1022,1.0)) + @test isequal_interval(exp2(bareinterval(-1022.0,0.0)), bareinterval(0x1P-1022,1.0)) - @test isequal_interval(exp2(interval(-1022.0,-0.0)), interval(0x1P-1022,1.0)) + @test isequal_interval(exp2(bareinterval(-1022.0,-0.0)), bareinterval(0x1P-1022,1.0)) - @test isequal_interval(exp2(interval(-1022.0,1.0)), interval(0x1P-1022,2.0)) + @test isequal_interval(exp2(bareinterval(-1022.0,1.0)), bareinterval(0x1P-1022,2.0)) - @test isequal_interval(exp2(interval(1.0,5.0)), interval(2.0,32.0)) + @test isequal_interval(exp2(bareinterval(1.0,5.0)), bareinterval(2.0,32.0)) - @test isequal_interval(exp2(interval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), interval(0x1.9999999999998P-4,0x1.C000000000001P+1)) + @test isequal_interval(exp2(bareinterval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), bareinterval(0x1.9999999999998P-4,0x1.C000000000001P+1)) - @test isequal_interval(exp2(interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), interval(0x1.B333333333332P+0,0x1.C81FD88228B4FP+98)) + @test isequal_interval(exp2(bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), bareinterval(0x1.B333333333332P+0,0x1.C81FD88228B4FP+98)) - @test isequal_interval(exp2(interval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), interval(0x1.AEA0000721857P+11,0x1.FCA0555555559P+25)) + @test isequal_interval(exp2(bareinterval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), bareinterval(0x1.AEA0000721857P+11,0x1.FCA0555555559P+25)) end @testset "minimal_exp2_dec_test" begin - @test isequal_interval(exp2(DecoratedInterval(interval(1024.0,1024.0), com)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFP+1023,Inf), dac)) + @test isequal_interval(exp2(Interval(bareinterval(1024.0,1024.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.FFFFFFFFFFFFFP+1023,Inf), IntervalArithmetic.dac)) - @test isequal_interval(exp2(DecoratedInterval(interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6), def)), DecoratedInterval(interval(0x1.B333333333332P+0,0x1.C81FD88228B4FP+98), def)) + @test isequal_interval(exp2(Interval(bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6), IntervalArithmetic.def)), Interval(bareinterval(0x1.B333333333332P+0,0x1.C81FD88228B4FP+98), IntervalArithmetic.def)) end @testset "minimal_exp10_test" begin - @test isequal_interval(exp10(emptyinterval()), emptyinterval()) + @test isequal_interval(exp10(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(exp10(interval(-Inf,0.0)), interval(0.0,1.0)) + @test isequal_interval(exp10(bareinterval(-Inf,0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp10(interval(-Inf,-0.0)), interval(0.0,1.0)) + @test isequal_interval(exp10(bareinterval(-Inf,-0.0)), bareinterval(0.0,1.0)) - @test isequal_interval(exp10(interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp10(bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp10(interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(exp10(bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(exp10(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(exp10(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(exp10(interval(-Inf,0x1.34413509F79FFP+8)), interval(0.0,Inf)) + @test isequal_interval(exp10(bareinterval(-Inf,0x1.34413509F79FFP+8)), bareinterval(0.0,Inf)) - @test isequal_interval(exp10(interval(0x1.34413509F79FFP+8,0x1.34413509F79FFP+8)), interval(0x1.FFFFFFFFFFFFFP+1023,Inf)) + @test isequal_interval(exp10(bareinterval(0x1.34413509F79FFP+8,0x1.34413509F79FFP+8)), bareinterval(0x1.FFFFFFFFFFFFFP+1023,Inf)) - @test isequal_interval(exp10(interval(0.0,0x1.34413509F79FEP+8)), interval(1.0,0x1.FFFFFFFFFFBA1P+1023)) + @test isequal_interval(exp10(bareinterval(0.0,0x1.34413509F79FEP+8)), bareinterval(1.0,0x1.FFFFFFFFFFBA1P+1023)) - @test isequal_interval(exp10(interval(-0.0,0x1.34413509F79FEP+8)), interval(1.0,0x1.FFFFFFFFFFBA1P+1023)) + @test isequal_interval(exp10(bareinterval(-0.0,0x1.34413509F79FEP+8)), bareinterval(1.0,0x1.FFFFFFFFFFBA1P+1023)) - @test isequal_interval(exp10(interval(-0x1.33A7146F72A42P+8,0x1.34413509F79FEP+8)), interval(0x0.FFFFFFFFFFFE3P-1022,0x1.FFFFFFFFFFBA1P+1023)) + @test isequal_interval(exp10(bareinterval(-0x1.33A7146F72A42P+8,0x1.34413509F79FEP+8)), bareinterval(0x0.FFFFFFFFFFFE3P-1022,0x1.FFFFFFFFFFBA1P+1023)) - @test isequal_interval(exp10(interval(-0x1.22P+7,0x1.34413509F79FEP+8)), interval(0x1.3FAAC3E3FA1F3P-482,0x1.FFFFFFFFFFBA1P+1023)) + @test isequal_interval(exp10(bareinterval(-0x1.22P+7,0x1.34413509F79FEP+8)), bareinterval(0x1.3FAAC3E3FA1F3P-482,0x1.FFFFFFFFFFBA1P+1023)) - @test isequal_interval(exp10(interval(-0x1.22P+7,0.0)), interval(0x1.3FAAC3E3FA1F3P-482,1.0)) + @test isequal_interval(exp10(bareinterval(-0x1.22P+7,0.0)), bareinterval(0x1.3FAAC3E3FA1F3P-482,1.0)) - @test isequal_interval(exp10(interval(-0x1.22P+7,-0.0)), interval(0x1.3FAAC3E3FA1F3P-482,1.0)) + @test isequal_interval(exp10(bareinterval(-0x1.22P+7,-0.0)), bareinterval(0x1.3FAAC3E3FA1F3P-482,1.0)) - @test isequal_interval(exp10(interval(-0x1.22P+7,1.0)), interval(0x1.3FAAC3E3FA1F3P-482,10.0)) + @test isequal_interval(exp10(bareinterval(-0x1.22P+7,1.0)), bareinterval(0x1.3FAAC3E3FA1F3P-482,10.0)) - @test isequal_interval(exp10(interval(1.0,5.0)), interval(10.0,100000.0)) + @test isequal_interval(exp10(bareinterval(1.0,5.0)), bareinterval(10.0,100000.0)) - @test isequal_interval(exp10(interval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), interval(0x1.F3A8254311F9AP-12,0x1.00B18AD5B7D56P+6)) + @test isequal_interval(exp10(bareinterval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)), bareinterval(0x1.F3A8254311F9AP-12,0x1.00B18AD5B7D56P+6)) - @test isequal_interval(exp10(interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), interval(0x1.75014B7296807P+2,0x1.3EEC1D47DFB2BP+328)) + @test isequal_interval(exp10(bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)), bareinterval(0x1.75014B7296807P+2,0x1.3EEC1D47DFB2BP+328)) - @test isequal_interval(exp10(interval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), interval(0x1.0608D2279A811P+39,0x1.43AF5D4271CB8P+86)) + @test isequal_interval(exp10(bareinterval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)), bareinterval(0x1.0608D2279A811P+39,0x1.43AF5D4271CB8P+86)) end @testset "minimal_exp10_dec_test" begin - @test isequal_interval(exp10(DecoratedInterval(interval(0x1.34413509F79FFP+8,0x1.34413509F79FFP+8), com)), DecoratedInterval(interval( 0x1.FFFFFFFFFFFFFP+1023,Inf), dac)) + @test isequal_interval(exp10(Interval(bareinterval(0x1.34413509F79FFP+8,0x1.34413509F79FFP+8), IntervalArithmetic.com)), Interval(bareinterval( 0x1.FFFFFFFFFFFFFP+1023,Inf), IntervalArithmetic.dac)) - @test isequal_interval(exp10(DecoratedInterval(interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6), def)), DecoratedInterval(interval(0x1.75014B7296807P+2,0x1.3EEC1D47DFB2BP+328), def)) + @test isequal_interval(exp10(Interval(bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6), IntervalArithmetic.def)), Interval(bareinterval(0x1.75014B7296807P+2,0x1.3EEC1D47DFB2BP+328), IntervalArithmetic.def)) end @testset "minimal_log_test" begin - @test isequal_interval(log(emptyinterval()), emptyinterval()) + @test isequal_interval(log(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(log(bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(log(bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log(bareinterval(0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log(interval(-0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log(bareinterval(-0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log(interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(log(bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(log(interval(0.0,Inf)), entireinterval()) + @test isequal_interval(log(bareinterval(0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(-0.0,Inf)), entireinterval()) + @test isequal_interval(log(bareinterval(-0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log(entireinterval()), entireinterval()) + @test isequal_interval(log(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,0x1.62E42FEFA39FP+9)) + @test isequal_interval(log(bareinterval(0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,0x1.62E42FEFA39FP+9)) - @test isequal_interval(log(interval(-0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,0x1.62E42FEFA39FP+9)) + @test isequal_interval(log(bareinterval(-0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,0x1.62E42FEFA39FP+9)) - @test isequal_interval(log(interval(1.0,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,0x1.62E42FEFA39FP+9)) + @test isequal_interval(log(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,0x1.62E42FEFA39FP+9)) - @test isequal_interval(log(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), interval(-0x1.74385446D71C4p9, +0x1.62E42FEFA39Fp9)) + @test isequal_interval(log(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-0x1.74385446D71C4p9, +0x1.62E42FEFA39Fp9)) - @test isequal_interval(log(interval(0x0.0000000000001p-1022,1.0)), interval(-0x1.74385446D71C4p9,0.0)) + @test isequal_interval(log(bareinterval(0x0.0000000000001p-1022,1.0)), bareinterval(-0x1.74385446D71C4p9,0.0)) - @test isequal_interval(log(interval(0x1.5BF0A8B145769P+1,0x1.5BF0A8B145769P+1)), interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) + @test isequal_interval(log(bareinterval(0x1.5BF0A8B145769P+1,0x1.5BF0A8B145769P+1)), bareinterval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) - @test isequal_interval(log(interval(0x1.5BF0A8B14576AP+1,0x1.5BF0A8B14576AP+1)), interval(0x1P+0,0x1.0000000000001P+0)) + @test isequal_interval(log(bareinterval(0x1.5BF0A8B14576AP+1,0x1.5BF0A8B14576AP+1)), bareinterval(0x1P+0,0x1.0000000000001P+0)) - @test isequal_interval(log(interval(0x0.0000000000001p-1022,0x1.5BF0A8B14576AP+1)), interval(-0x1.74385446D71C4p9,0x1.0000000000001P+0)) + @test isequal_interval(log(bareinterval(0x0.0000000000001p-1022,0x1.5BF0A8B14576AP+1)), bareinterval(-0x1.74385446D71C4p9,0x1.0000000000001P+0)) - @test isequal_interval(log(interval(0x1.5BF0A8B145769P+1,32.0)), interval(0x1.FFFFFFFFFFFFFP-1,0x1.BB9D3BEB8C86CP+1)) + @test isequal_interval(log(bareinterval(0x1.5BF0A8B145769P+1,32.0)), bareinterval(0x1.FFFFFFFFFFFFFP-1,0x1.BB9D3BEB8C86CP+1)) - @test isequal_interval(log(interval(0x1.999999999999AP-4,0x1.CP+1)), interval(-0x1.26BB1BBB55516P+1,0x1.40B512EB53D6P+0)) + @test isequal_interval(log(bareinterval(0x1.999999999999AP-4,0x1.CP+1)), bareinterval(-0x1.26BB1BBB55516P+1,0x1.40B512EB53D6P+0)) - @test isequal_interval(log(interval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), interval(0x1.0FAE81914A99P-1,0x1.120627F6AE7F1P+6)) + @test isequal_interval(log(bareinterval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), bareinterval(0x1.0FAE81914A99P-1,0x1.120627F6AE7F1P+6)) - @test isequal_interval(log(interval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), interval(0x1.04A1363DB1E63P+3,0x1.203E52C0256B5P+4)) + @test isequal_interval(log(bareinterval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), bareinterval(0x1.04A1363DB1E63P+3,0x1.203E52C0256B5P+4)) end @testset "minimal_log_dec_test" begin - @test isequal_interval(log(DecoratedInterval(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-0x1.74385446D71C4p9,0x1.62E42FEFA39FP+9), com)) + @test isequal_interval(log(Interval(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-0x1.74385446D71C4p9,0x1.62E42FEFA39FP+9), IntervalArithmetic.com)) - @test isequal_interval(log(DecoratedInterval(interval(0.0,1.0), com)), DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(log(Interval(bareinterval(0.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(log(DecoratedInterval(interval(0x1.5BF0A8B14576AP+1,0x1.5BF0A8B14576AP+1), def)), DecoratedInterval(interval(0x1P+0,0x1.0000000000001P+0), def)) + @test isequal_interval(log(Interval(bareinterval(0x1.5BF0A8B14576AP+1,0x1.5BF0A8B14576AP+1), IntervalArithmetic.def)), Interval(bareinterval(0x1P+0,0x1.0000000000001P+0), IntervalArithmetic.def)) end @testset "minimal_log2_test" begin - @test isequal_interval(log2(emptyinterval()), emptyinterval()) + @test isequal_interval(log2(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(log2(bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(log2(bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log2(bareinterval(0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log2(interval(-0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log2(bareinterval(-0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log2(interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(log2(bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(log2(interval(0.0,Inf)), entireinterval()) + @test isequal_interval(log2(bareinterval(0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(-0.0,Inf)), entireinterval()) + @test isequal_interval(log2(bareinterval(-0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log2(entireinterval()), entireinterval()) + @test isequal_interval(log2(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,1024.0)) + @test isequal_interval(log2(bareinterval(0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,1024.0)) - @test isequal_interval(log2(interval(-0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,1024.0)) + @test isequal_interval(log2(bareinterval(-0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,1024.0)) - @test isequal_interval(log2(interval(1.0,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,1024.0)) + @test isequal_interval(log2(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,1024.0)) - @test isequal_interval(log2(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), interval(-1074.0,1024.0)) + @test isequal_interval(log2(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-1074.0,1024.0)) - @test isequal_interval(log2(interval(0x0.0000000000001p-1022,1.0)), interval(-1074.0,0.0)) + @test isequal_interval(log2(bareinterval(0x0.0000000000001p-1022,1.0)), bareinterval(-1074.0,0.0)) - @test isequal_interval(log2(interval(0x0.0000000000001p-1022,2.0)), interval(-1074.0,1.0)) + @test isequal_interval(log2(bareinterval(0x0.0000000000001p-1022,2.0)), bareinterval(-1074.0,1.0)) - @test isequal_interval(log2(interval(2.0,32.0)), interval(1.0,5.0)) + @test isequal_interval(log2(bareinterval(2.0,32.0)), bareinterval(1.0,5.0)) - @test isequal_interval(log2(interval(0x1.999999999999AP-4,0x1.CP+1)), interval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)) + @test isequal_interval(log2(bareinterval(0x1.999999999999AP-4,0x1.CP+1)), bareinterval(-0x1.A934F0979A372P+1,0x1.CEAECFEA8085AP+0)) - @test isequal_interval(log2(interval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), interval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)) + @test isequal_interval(log2(bareinterval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), bareinterval(0x1.87F42B972949CP-1,0x1.8B55484710029P+6)) - @test isequal_interval(log2(interval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), interval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)) + @test isequal_interval(log2(bareinterval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), bareinterval(0x1.78025C8B3FD39P+3,0x1.9FD8EEF3FA79BP+4)) end @testset "minimal_log2_dec_test" begin - @test isequal_interval(log2(DecoratedInterval(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-1074.0,1024.0), com)) + @test isequal_interval(log2(Interval(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-1074.0,1024.0), IntervalArithmetic.com)) - @test isequal_interval(log2(DecoratedInterval(interval(0x0.0000000000001p-1022,Inf), dac)), DecoratedInterval(interval(-1074.0,Inf), dac)) + @test isequal_interval(log2(Interval(bareinterval(0x0.0000000000001p-1022,Inf), IntervalArithmetic.dac)), Interval(bareinterval(-1074.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(log2(DecoratedInterval(interval(2.0,32.0), def)), DecoratedInterval(interval(1.0,5.0), def)) + @test isequal_interval(log2(Interval(bareinterval(2.0,32.0), IntervalArithmetic.def)), Interval(bareinterval(1.0,5.0), IntervalArithmetic.def)) - @test isequal_interval(log2(DecoratedInterval(interval(0.0,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-Inf,1024.0), trv)) + @test isequal_interval(log2(Interval(bareinterval(0.0,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-Inf,1024.0), IntervalArithmetic.trv)) end @testset "minimal_log10_test" begin - @test isequal_interval(log10(emptyinterval()), emptyinterval()) + @test isequal_interval(log10(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(-Inf,0.0)), emptyinterval()) + @test isequal_interval(log10(bareinterval(-Inf,0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(-Inf,-0.0)), emptyinterval()) + @test isequal_interval(log10(bareinterval(-Inf,-0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log10(bareinterval(0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log10(interval(-0.0,1.0)), interval(-Inf,0.0)) + @test isequal_interval(log10(bareinterval(-0.0,1.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(log10(interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(log10(bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(log10(interval(0.0,Inf)), entireinterval()) + @test isequal_interval(log10(bareinterval(0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(-0.0,Inf)), entireinterval()) + @test isequal_interval(log10(bareinterval(-0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log10(entireinterval()), entireinterval()) + @test isequal_interval(log10(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,0x1.34413509F79FFP+8)) + @test isequal_interval(log10(bareinterval(0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,0x1.34413509F79FFP+8)) - @test isequal_interval(log10(interval(-0.0,0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,0x1.34413509F79FFP+8)) + @test isequal_interval(log10(bareinterval(-0.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,0x1.34413509F79FFP+8)) - @test isequal_interval(log10(interval(1.0,0x1.FFFFFFFFFFFFFp1023)), interval(0.0,0x1.34413509F79FFP+8)) + @test isequal_interval(log10(bareinterval(1.0,0x1.FFFFFFFFFFFFFp1023)), bareinterval(0.0,0x1.34413509F79FFP+8)) - @test isequal_interval(log10(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), interval(-0x1.434E6420F4374p+8, +0x1.34413509F79FFp+8)) + @test isequal_interval(log10(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023)), bareinterval(-0x1.434E6420F4374p+8, +0x1.34413509F79FFp+8)) - @test isequal_interval(log10(interval(0x0.0000000000001p-1022,1.0)), interval(-0x1.434E6420F4374p+8 ,0.0)) + @test isequal_interval(log10(bareinterval(0x0.0000000000001p-1022,1.0)), bareinterval(-0x1.434E6420F4374p+8 ,0.0)) - @test isequal_interval(log10(interval(0x0.0000000000001p-1022,10.0)), interval(-0x1.434E6420F4374p+8 ,1.0)) + @test isequal_interval(log10(bareinterval(0x0.0000000000001p-1022,10.0)), bareinterval(-0x1.434E6420F4374p+8 ,1.0)) - @test isequal_interval(log10(interval(10.0,100000.0)), interval(1.0,5.0)) + @test isequal_interval(log10(bareinterval(10.0,100000.0)), bareinterval(1.0,5.0)) - @test isequal_interval(log10(interval(0x1.999999999999AP-4,0x1.CP+1)), interval(-0x1P+0,0x1.1690163290F4P-1)) + @test isequal_interval(log10(bareinterval(0x1.999999999999AP-4,0x1.CP+1)), bareinterval(-0x1P+0,0x1.1690163290F4P-1)) - @test isequal_interval(log10(interval(0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(log10(bareinterval(0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(log10(interval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), interval(0x1.D7F59AA5BECB9P-3,0x1.DC074D84E5AABP+4)) + @test isequal_interval(log10(bareinterval(0x1.B333333333333P+0,0x1.C81FD88228B2FP+98)), bareinterval(0x1.D7F59AA5BECB9P-3,0x1.DC074D84E5AABP+4)) - @test isequal_interval(log10(interval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), interval(0x1.C4C29DD829191P+1,0x1.F4BAEBBA4FA4P+2)) + @test isequal_interval(log10(bareinterval(0x1.AEA0000721861P+11,0x1.FCA055555554CP+25)), bareinterval(0x1.C4C29DD829191P+1,0x1.F4BAEBBA4FA4P+2)) end @testset "minimal_log10_dec_test" begin - @test isequal_interval(log10(DecoratedInterval(interval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-0x1.434E6420F4374p+8,0x1.34413509F79FFP+8), com)) + @test isequal_interval(log10(Interval(bareinterval(0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-0x1.434E6420F4374p+8,0x1.34413509F79FFP+8), IntervalArithmetic.com)) - @test isequal_interval(log10(DecoratedInterval(interval(0.0,0x1.FFFFFFFFFFFFFp1023), dac)), DecoratedInterval(interval(-Inf,0x1.34413509F79FFP+8), trv)) + @test isequal_interval(log10(Interval(bareinterval(0.0,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)), Interval(bareinterval(-Inf,0x1.34413509F79FFP+8), IntervalArithmetic.trv)) end @testset "minimal_sin_test" begin - @test isequal_interval(sin(emptyinterval()), emptyinterval()) + @test isequal_interval(sin(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin(interval(0.0,Inf)), interval(-1.0,1.0)) + @test isequal_interval(sin(bareinterval(0.0,Inf)), bareinterval(-1.0,1.0)) - @test isequal_interval(sin(interval(-0.0,Inf)), interval(-1.0,1.0)) + @test isequal_interval(sin(bareinterval(-0.0,Inf)), bareinterval(-1.0,1.0)) - @test isequal_interval(sin(interval(-Inf,0.0)), interval(-1.0,1.0)) + @test isequal_interval(sin(bareinterval(-Inf,0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(sin(interval(-Inf,-0.0)), interval(-1.0,1.0)) + @test isequal_interval(sin(bareinterval(-Inf,-0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(sin(entireinterval()), interval(-1.0,1.0)) + @test isequal_interval(sin(entireinterval(BareInterval{Float64})), bareinterval(-1.0,1.0)) - @test isequal_interval(sin(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(sin(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sin(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(sin(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), bareinterval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), bareinterval(0x1.FFFFFFFFFFFFFP-1,0x1P+0)) - @test isequal_interval(sin(interval(0.0,0x1.921FB54442D18P+0)), interval(0.0,0x1P+0)) + @test isequal_interval(sin(bareinterval(0.0,0x1.921FB54442D18P+0)), bareinterval(0.0,0x1P+0)) - @test isequal_interval(sin(interval(-0.0,0x1.921FB54442D18P+0)), interval(0.0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0.0,0x1.921FB54442D18P+0)), bareinterval(0.0,0x1P+0)) - @test isequal_interval(sin(interval(0.0,0x1.921FB54442D19P+0)), interval(0.0,0x1P+0)) + @test isequal_interval(sin(bareinterval(0.0,0x1.921FB54442D19P+0)), bareinterval(0.0,0x1P+0)) - @test isequal_interval(sin(interval(-0.0,0x1.921FB54442D19P+0)), interval(0.0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0.0,0x1.921FB54442D19P+0)), bareinterval(0.0,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), bareinterval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53)) - @test isequal_interval(sin(interval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,0x1.1A62633145C07P-53)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,0x1.1A62633145C07P-53)) - @test isequal_interval(sin(interval(0.0,0x1.921FB54442D18P+1)), interval(0.0,1.0)) + @test isequal_interval(sin(bareinterval(0.0,0x1.921FB54442D18P+1)), bareinterval(0.0,1.0)) - @test isequal_interval(sin(interval(-0.0,0x1.921FB54442D18P+1)), interval(0.0,1.0)) + @test isequal_interval(sin(bareinterval(-0.0,0x1.921FB54442D18P+1)), bareinterval(0.0,1.0)) - @test isequal_interval(sin(interval(0.0,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,1.0)) + @test isequal_interval(sin(bareinterval(0.0,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,1.0)) - @test isequal_interval(sin(interval(-0.0,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,1.0)) + @test isequal_interval(sin(bareinterval(-0.0,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,1.0)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+1)), interval(0x1.1A62633145C06P-53,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+1)), bareinterval(0x1.1A62633145C06P-53,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D19P+0,0x1.921FB54442D18P+1)), interval(0x1.1A62633145C06P-53,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D18P+1)), bareinterval(0x1.1A62633145C06P-53,0x1P+0)) - @test isequal_interval(sin(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+1)), interval(-0x1.72CECE675D1FDP-52,0x1P+0)) + @test isequal_interval(sin(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+1)), bareinterval(-0x1.72CECE675D1FDP-52,0x1P+0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D19P+0)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D19P+0)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+0,0.0)), interval(-0x1P+0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+0,0.0)), bareinterval(-0x1P+0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+0,-0.0)), interval(-0x1P+0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+0,-0.0)), bareinterval(-0x1P+0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,0.0)), interval(-0x1P+0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,0.0)), bareinterval(-0x1P+0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,-0.0)), interval(-0x1P+0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,-0.0)), bareinterval(-0x1P+0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+1)), interval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+1)), bareinterval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+1)), interval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+1)), bareinterval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+1)), interval(-0x1.1A62633145C07P-53,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+1)), bareinterval(-0x1.1A62633145C07P-53,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+1,0.0)), interval(-1.0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+1,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+1,-0.0)), interval(-1.0,0.0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+1,-0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,0.0)), interval(-1.0,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,0.0)), bareinterval(-1.0,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,-0.0)), interval(-1.0,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,-0.0)), bareinterval(-1.0,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0)), interval(-0x1P+0,-0x1.1A62633145C06P-53)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,-0x1.1A62633145C06P-53)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+0)), interval(-0x1P+0,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D19P+0)), interval(-0x1P+0,-0x1.1A62633145C06P-53)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D19P+0)), bareinterval(-0x1P+0,-0x1.1A62633145C06P-53)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+0)), interval(-0x1P+0,0x1.72CECE675D1FDP-52)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+0)), bareinterval(-0x1P+0,0x1.72CECE675D1FDP-52)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(-0x1P+0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,0x1P+0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), interval(-0x1P+0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1P+0,0x1P+0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), interval(-0x1P+0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), bareinterval(-0x1P+0,0x1P+0)) - @test isequal_interval(sin(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), interval(-0x1P+0,0x1P+0)) + @test isequal_interval(sin(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1P+0,0x1P+0)) - @test isequal_interval(sin(interval(-0.7,0.1)), interval(-0x1.49D6E694619B9P-1,0x1.98EAECB8BCB2DP-4)) + @test isequal_interval(sin(bareinterval(-0.7,0.1)), bareinterval(-0x1.49D6E694619B9P-1,0x1.98EAECB8BCB2DP-4)) - @test isequal_interval(sin(interval(1.0,2.0)), interval(0x1.AED548F090CEEP-1,1.0)) + @test isequal_interval(sin(bareinterval(1.0,2.0)), bareinterval(0x1.AED548F090CEEP-1,1.0)) - @test isequal_interval(sin(interval(-3.2,-2.9)), interval(-0x1.E9FB8D64830E3P-3,0x1.DE33739E82D33P-5)) + @test isequal_interval(sin(bareinterval(-3.2,-2.9)), bareinterval(-0x1.E9FB8D64830E3P-3,0x1.DE33739E82D33P-5)) - @test isequal_interval(sin(interval(2.0,3.0)), interval(0x1.210386DB6D55BP-3,0x1.D18F6EAD1B446P-1)) + @test isequal_interval(sin(bareinterval(2.0,3.0)), bareinterval(0x1.210386DB6D55BP-3,0x1.D18F6EAD1B446P-1)) end @testset "minimal_sin_dec_test" begin - @test isequal_interval(sin(DecoratedInterval(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0), def)), DecoratedInterval(interval(-0x1P+0,-0x1.1A62633145C06P-53), def)) + @test isequal_interval(sin(Interval(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0), IntervalArithmetic.def)), Interval(bareinterval(-0x1P+0,-0x1.1A62633145C06P-53), IntervalArithmetic.def)) - @test isequal_interval(sin(DecoratedInterval(interval(-Inf,-0.0), trv)), DecoratedInterval(interval(-1.0,1.0), trv)) + @test isequal_interval(sin(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sin(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-1.0,1.0), dac)) + @test isequal_interval(sin(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.dac)) end @testset "minimal_cos_test" begin - @test isequal_interval(cos(emptyinterval()), emptyinterval()) + @test isequal_interval(cos(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos(interval(0.0,Inf)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(0.0,Inf)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0.0,Inf)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,Inf)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-Inf,0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-Inf,0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-Inf,-0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-Inf,-0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(entireinterval()), interval(-1.0,1.0)) + @test isequal_interval(cos(entireinterval(BareInterval{Float64})), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(cos(bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(cos(interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(0.0,0x1.921FB54442D18P+0)), interval(0x1.1A62633145C06P-54,1.0)) + @test isequal_interval(cos(bareinterval(0.0,0x1.921FB54442D18P+0)), bareinterval(0x1.1A62633145C06P-54,1.0)) - @test isequal_interval(cos(interval(-0.0,0x1.921FB54442D18P+0)), interval(0x1.1A62633145C06P-54,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,0x1.921FB54442D18P+0)), bareinterval(0x1.1A62633145C06P-54,1.0)) - @test isequal_interval(cos(interval(0.0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(0.0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0.0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(0.0,0x1.921FB54442D18P+1)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(0.0,0x1.921FB54442D18P+1)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0.0,0x1.921FB54442D18P+1)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,0x1.921FB54442D18P+1)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(0.0,0x1.921FB54442D19P+1)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(0.0,0x1.921FB54442D19P+1)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0.0,0x1.921FB54442D19P+1)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0.0,0x1.921FB54442D19P+1)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+1)), interval(-1.0,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+1)), bareinterval(-1.0,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)), interval(-1.0,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)), bareinterval(-1.0,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(0x1.921FB54442D19P+0,0x1.921FB54442D18P+1)), interval(-1.0,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D18P+1)), bareinterval(-1.0,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+1)), interval(-1.0,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+1)), bareinterval(-1.0,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0)), interval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0)), bareinterval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)), interval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)), bareinterval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+0,0.0)), interval(0x1.1A62633145C06P-54,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+0,0.0)), bareinterval(0x1.1A62633145C06P-54,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+0,-0.0)), interval(0x1.1A62633145C06P-54,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+0,-0.0)), bareinterval(0x1.1A62633145C06P-54,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,0.0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,0.0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,-0.0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,-0.0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+1)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+1)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+1,0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+1,0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+1,-0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+1,-0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,-0.0)), interval(-1.0,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,-0.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0)), interval(-1.0,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D18P+0)), bareinterval(-1.0,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+0)), interval(-1.0,0x1.1A62633145C07P-54)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D18P+0)), bareinterval(-1.0,0x1.1A62633145C07P-54)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+1,-0x1.921FB54442D19P+0)), interval(-1.0,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+1,-0x1.921FB54442D19P+0)), bareinterval(-1.0,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+0)), interval(-1.0,-0x1.72CECE675D1FCP-53)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+1,-0x1.921FB54442D19P+0)), bareinterval(-1.0,-0x1.72CECE675D1FCP-53)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(0x1.1A62633145C06P-54,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(0x1.1A62633145C06P-54,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), interval(-0x1.72CECE675D1FDP-53,1.0)) + @test isequal_interval(cos(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1.72CECE675D1FDP-53,1.0)) - @test isequal_interval(cos(interval(-0.7,0.1)), interval(0x1.87996529F9D92P-1,1.0)) + @test isequal_interval(cos(bareinterval(-0.7,0.1)), bareinterval(0x1.87996529F9D92P-1,1.0)) - @test isequal_interval(cos(interval(1.0,2.0)), interval(-0x1.AA22657537205P-2,0x1.14A280FB5068CP-1)) + @test isequal_interval(cos(bareinterval(1.0,2.0)), bareinterval(-0x1.AA22657537205P-2,0x1.14A280FB5068CP-1)) - @test isequal_interval(cos(interval(-3.2,-2.9)), interval(-1.0,-0x1.F1216DBA340C8P-1)) + @test isequal_interval(cos(bareinterval(-3.2,-2.9)), bareinterval(-1.0,-0x1.F1216DBA340C8P-1)) - @test isequal_interval(cos(interval(2.0,3.0)), interval(-0x1.FAE04BE85E5D3P-1,-0x1.AA22657537204P-2)) + @test isequal_interval(cos(bareinterval(2.0,3.0)), bareinterval(-0x1.FAE04BE85E5D3P-1,-0x1.AA22657537204P-2)) end @testset "minimal_cos_dec_test" begin - @test isequal_interval(cos(DecoratedInterval(interval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0), trv)), DecoratedInterval(interval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54), trv)) + @test isequal_interval(cos(Interval(bareinterval(-0x1.921FB54442D18P+0,-0x1.921FB54442D18P+0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54), IntervalArithmetic.trv)) - @test isequal_interval(cos(DecoratedInterval(interval(-Inf,-0.0), def)), DecoratedInterval(interval(-1.0,1.0), def)) + @test isequal_interval(cos(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.def)) - @test isequal_interval(cos(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-1.0,1.0), dac)) + @test isequal_interval(cos(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.dac)) end @testset "minimal_tan_test" begin - @test isequal_interval(tan(emptyinterval()), emptyinterval()) + @test isequal_interval(tan(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.0,Inf)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0.0,Inf)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0.0,Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-Inf,0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-Inf,0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-Inf,-0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-Inf,-0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(entireinterval()), entireinterval()) + @test isequal_interval(tan(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(tan(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(tan(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(tan(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(tan(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53)) + @test isequal_interval(tan(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53)) - @test isequal_interval(tan(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), interval(-0x1.617A15494767BP+52,-0x1.617A15494767AP+52)) + @test isequal_interval(tan(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), bareinterval(-0x1.617A15494767BP+52,-0x1.617A15494767AP+52)) - @test isequal_interval(tan(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), interval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53)) + @test isequal_interval(tan(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1)), bareinterval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53)) - @test isequal_interval(tan(interval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), interval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52)) + @test isequal_interval(tan(bareinterval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1)), bareinterval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52)) - @test isequal_interval(tan(interval(0.0,0x1.921FB54442D18P+0)), interval(0.0,0x1.D02967C31CDB5P+53)) + @test isequal_interval(tan(bareinterval(0.0,0x1.921FB54442D18P+0)), bareinterval(0.0,0x1.D02967C31CDB5P+53)) - @test isequal_interval(tan(interval(-0.0,0x1.921FB54442D18P+0)), interval(0.0,0x1.D02967C31CDB5P+53)) + @test isequal_interval(tan(bareinterval(-0.0,0x1.921FB54442D18P+0)), bareinterval(0.0,0x1.D02967C31CDB5P+53)) - @test isequal_interval(tan(interval(0.0,0x1.921FB54442D19P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0,0x1.921FB54442D19P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0.0,0x1.921FB54442D19P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0.0,0x1.921FB54442D19P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.0,0x1.921FB54442D18P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0,0x1.921FB54442D18P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0.0,0x1.921FB54442D18P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0.0,0x1.921FB54442D18P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.0,0x1.921FB54442D19P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0,0x1.921FB54442D19P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0.0,0x1.921FB54442D19P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0.0,0x1.921FB54442D19P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1P-51,0x1.921FB54442D18P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1P-51,0x1.921FB54442D18P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1P-51,0x1.921FB54442D19P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1P-51,0x1.921FB54442D19P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1P-52,0x1.921FB54442D18P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1P-52,0x1.921FB54442D18P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1P-52,0x1.921FB54442D19P+1)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1P-52,0x1.921FB54442D19P+1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), interval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53)) + @test isequal_interval(tan(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0)), bareinterval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53)) - @test isequal_interval(tan(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-0x1.555475A31A4BEP-2,0x1.999999999999AP-4)), interval(-0x1.628F4FD931FEFP-2,0x1.9AF8877430B81P-4)) + @test isequal_interval(tan(bareinterval(-0x1.555475A31A4BEP-2,0x1.999999999999AP-4)), bareinterval(-0x1.628F4FD931FEFP-2,0x1.9AF8877430B81P-4)) - @test isequal_interval(tan(interval(0x1.4E18E147AE148P+12,0x1.4E2028F5C28F6P+12)), interval(-0x1.D6D67B035B6B4P+2,-0x1.7E42B0760E3F3P+0)) + @test isequal_interval(tan(bareinterval(0x1.4E18E147AE148P+12,0x1.4E2028F5C28F6P+12)), bareinterval(-0x1.D6D67B035B6B4P+2,-0x1.7E42B0760E3F3P+0)) - @test isequal_interval(tan(interval(0x1.4E18E147AE148P+12,0x1.546028F5C28F6P+12)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1.4E18E147AE148P+12,0x1.546028F5C28F6P+12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1.FAE147AE147AEP-1,0x1.028F5C28F5C29P+0)), interval(0x1.860FADCC59064P+0,0x1.979AD0628469DP+0)) + @test isequal_interval(tan(bareinterval(0x1.FAE147AE147AEP-1,0x1.028F5C28F5C29P+0)), bareinterval(0x1.860FADCC59064P+0,0x1.979AD0628469DP+0)) end @testset "minimal_tan_dec_test" begin - @test isequal_interval(tan(DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(tan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,Inf), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-Inf,0.0), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-Inf,-0.0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,0.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(tan(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,-0.0), def)), DecoratedInterval(interval(0.0,0.0), def)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0), com)), DecoratedInterval(interval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53), com)) + @test isequal_interval(tan(Interval(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D18P+0), IntervalArithmetic.com)), Interval(bareinterval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), def)), DecoratedInterval(interval(-0x1.617A15494767BP+52,-0x1.617A15494767AP+52), def)) + @test isequal_interval(tan(Interval(bareinterval(0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.617A15494767BP+52,-0x1.617A15494767AP+52), IntervalArithmetic.def)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1), trv)), DecoratedInterval(interval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D18P+1), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1), com)), DecoratedInterval(interval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52), com)) + @test isequal_interval(tan(Interval(bareinterval(0x1.921FB54442D19P+1,0x1.921FB54442D19P+1), IntervalArithmetic.com)), Interval(bareinterval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,0x1.921FB54442D18P+0), dac)), DecoratedInterval(interval(0.0,0x1.D02967C31CDB5P+53), dac)) + @test isequal_interval(tan(Interval(bareinterval(0.0,0x1.921FB54442D18P+0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.D02967C31CDB5P+53), IntervalArithmetic.dac)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,0x1.921FB54442D18P+0), com)), DecoratedInterval(interval(0.0,0x1.D02967C31CDB5P+53), com)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,0x1.921FB54442D18P+0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.D02967C31CDB5P+53), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,0x1.921FB54442D19P+0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,0x1.921FB54442D19P+0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,0x1.921FB54442D18P+1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0.0,0x1.921FB54442D18P+1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,0x1.921FB54442D18P+1), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,0x1.921FB54442D18P+1), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0.0,0x1.921FB54442D19P+1), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0.0,0x1.921FB54442D19P+1), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1P-51,0x1.921FB54442D18P+1), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1P-51,0x1.921FB54442D18P+1), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1P-51,0x1.921FB54442D19P+1), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1P-51,0x1.921FB54442D19P+1), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1P-52,0x1.921FB54442D18P+1), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1P-52,0x1.921FB54442D18P+1), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1P-52,0x1.921FB54442D19P+1), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1P-52,0x1.921FB54442D19P+1), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0), com)), DecoratedInterval(interval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53), com)) + @test isequal_interval(tan(Interval(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D18P+0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0), trv)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0x1.921FB54442D18P+0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D18P+0), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(-0x1.555475A31A4BEP-2,0x1.999999999999AP-4), com)), DecoratedInterval(interval(-0x1.628F4FD931FEFP-2,0x1.9AF8877430B81P-4), com)) + @test isequal_interval(tan(Interval(bareinterval(-0x1.555475A31A4BEP-2,0x1.999999999999AP-4), IntervalArithmetic.com)), Interval(bareinterval(-0x1.628F4FD931FEFP-2,0x1.9AF8877430B81P-4), IntervalArithmetic.com)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.4E18E147AE148P+12,0x1.4E2028F5C28F6P+12), dac)), DecoratedInterval(interval(-0x1.D6D67B035B6B4P+2,-0x1.7E42B0760E3F3P+0), dac)) + @test isequal_interval(tan(Interval(bareinterval(0x1.4E18E147AE148P+12,0x1.4E2028F5C28F6P+12), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.D6D67B035B6B4P+2,-0x1.7E42B0760E3F3P+0), IntervalArithmetic.dac)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.4E18E147AE148P+12,0x1.546028F5C28F6P+12), def)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1.4E18E147AE148P+12,0x1.546028F5C28F6P+12), IntervalArithmetic.def)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan(DecoratedInterval(interval(0x1.FAE147AE147AEP-1,0x1.028F5C28F5C29P+0), trv)), DecoratedInterval(interval(0x1.860FADCC59064P+0,0x1.979AD0628469DP+0), trv)) + @test isequal_interval(tan(Interval(bareinterval(0x1.FAE147AE147AEP-1,0x1.028F5C28F5C29P+0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.860FADCC59064P+0,0x1.979AD0628469DP+0), IntervalArithmetic.trv)) end @testset "minimal_asin_test" begin - @test isequal_interval(asin(emptyinterval()), emptyinterval()) + @test isequal_interval(asin(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(asin(interval(0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(bareinterval(0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(-0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(bareinterval(-0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(-Inf,0.0)), interval(-0x1.921FB54442D19P+0,0.0)) + @test isequal_interval(asin(bareinterval(-Inf,0.0)), bareinterval(-0x1.921FB54442D19P+0,0.0)) - @test isequal_interval(asin(interval(-Inf,-0.0)), interval(-0x1.921FB54442D19P+0,0.0)) + @test isequal_interval(asin(bareinterval(-Inf,-0.0)), bareinterval(-0x1.921FB54442D19P+0,0.0)) - @test isequal_interval(asin(entireinterval()), interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(-1.0,1.0)), interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(bareinterval(-1.0,1.0)), bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(-Inf,-1.0)), interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)) + @test isequal_interval(asin(bareinterval(-Inf,-1.0)), bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)) - @test isequal_interval(asin(interval(1.0,Inf)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(bareinterval(1.0,Inf)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(-1.0,-1.0)), interval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)) + @test isequal_interval(asin(bareinterval(-1.0,-1.0)), bareinterval(-0x1.921FB54442D19P+0,-0x1.921FB54442D18P+0)) - @test isequal_interval(asin(interval(1.0,1.0)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(asin(bareinterval(1.0,1.0)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(asin(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(asin(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(asin(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(asin(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(asin(interval(-Inf,-0x1.0000000000001P+0)), emptyinterval()) + @test isequal_interval(asin(bareinterval(-Inf,-0x1.0000000000001P+0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(asin(interval(0x1.0000000000001P+0,Inf)), emptyinterval()) + @test isequal_interval(asin(bareinterval(0x1.0000000000001P+0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(asin(interval(-0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(-0x1.9A49276037885P-4,0x1.9A49276037885P-4)) + @test isequal_interval(asin(bareinterval(-0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(-0x1.9A49276037885P-4,0x1.9A49276037885P-4)) - @test isequal_interval(asin(interval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1)), interval(-0x1.585FF6E341C3FP-2,0x1.921FB50442D19P+0)) + @test isequal_interval(asin(bareinterval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1)), bareinterval(-0x1.585FF6E341C3FP-2,0x1.921FB50442D19P+0)) - @test isequal_interval(asin(interval(-0x1.FFFFFFFFFFFFFP-1,0x1.FFFFFFFFFFFFFP-1)), interval(-0x1.921FB50442D19P+0,0x1.921FB50442D19P+0)) + @test isequal_interval(asin(bareinterval(-0x1.FFFFFFFFFFFFFP-1,0x1.FFFFFFFFFFFFFP-1)), bareinterval(-0x1.921FB50442D19P+0,0x1.921FB50442D19P+0)) end @testset "minimal_asin_dec_test" begin - @test isequal_interval(asin(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(asin(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(asin(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0,0.0), trv)) + @test isequal_interval(asin(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(asin(DecoratedInterval(interval(-1.0,1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), com)) + @test isequal_interval(asin(Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), IntervalArithmetic.com)) - @test isequal_interval(asin(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(asin(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(asin(DecoratedInterval(interval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1), def)), DecoratedInterval(interval(-0x1.585FF6E341C3FP-2,0x1.921FB50442D19P+0), def)) + @test isequal_interval(asin(Interval(bareinterval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.def)), Interval(bareinterval(-0x1.585FF6E341C3FP-2,0x1.921FB50442D19P+0), IntervalArithmetic.def)) end @testset "minimal_acos_test" begin - @test isequal_interval(acos(emptyinterval()), emptyinterval()) + @test isequal_interval(acos(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(acos(interval(0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-Inf,0.0)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(bareinterval(-Inf,0.0)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(interval(-Inf,-0.0)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(bareinterval(-Inf,-0.0)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(entireinterval()), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(entireinterval(BareInterval{Float64})), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(interval(-1.0,1.0)), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(bareinterval(-1.0,1.0)), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(interval(-Inf,-1.0)), interval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(bareinterval(-Inf,-1.0)), bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(interval(1.0,Inf)), interval(0.0,0.0)) + @test isequal_interval(acos(bareinterval(1.0,Inf)), bareinterval(0.0,0.0)) - @test isequal_interval(acos(interval(-1.0,-1.0)), interval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)) + @test isequal_interval(acos(bareinterval(-1.0,-1.0)), bareinterval(0x1.921FB54442D18P+1,0x1.921FB54442D19P+1)) - @test isequal_interval(acos(interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(acos(bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(acos(interval(0.0,0.0)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(0.0,0.0)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-0.0,-0.0)), interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(acos(bareinterval(-0.0,-0.0)), bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(acos(interval(-Inf,-0x1.0000000000001P+0)), emptyinterval()) + @test isequal_interval(acos(bareinterval(-Inf,-0x1.0000000000001P+0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(acos(interval(0x1.0000000000001P+0,Inf)), emptyinterval()) + @test isequal_interval(acos(bareinterval(0x1.0000000000001P+0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(acos(interval(-0x1.999999999999AP-4,0x1.999999999999AP-4)), interval(0x1.787B22CE3F59P+0,0x1.ABC447BA464A1P+0)) + @test isequal_interval(acos(bareinterval(-0x1.999999999999AP-4,0x1.999999999999AP-4)), bareinterval(0x1.787B22CE3F59P+0,0x1.ABC447BA464A1P+0)) - @test isequal_interval(acos(interval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1)), interval(0x1P-26,0x1.E837B2FD13428P+0)) + @test isequal_interval(acos(bareinterval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1)), bareinterval(0x1P-26,0x1.E837B2FD13428P+0)) - @test isequal_interval(acos(interval(-0x1.FFFFFFFFFFFFFP-1,0x1.FFFFFFFFFFFFFP-1)), interval(0x1P-26,0x1.921FB52442D19P+1)) + @test isequal_interval(acos(bareinterval(-0x1.FFFFFFFFFFFFFP-1,0x1.FFFFFFFFFFFFFP-1)), bareinterval(0x1P-26,0x1.921FB52442D19P+1)) end @testset "minimal_acos_dec_test" begin - @test isequal_interval(acos(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(acos(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(acos(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(acos(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(acos(DecoratedInterval(interval(-1.0,1.0), com)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), com)) + @test isequal_interval(acos(Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.com)) - @test isequal_interval(acos(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(acos(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(acos(DecoratedInterval(interval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1), def)), DecoratedInterval(interval(0x1P-26,0x1.E837B2FD13428P+0), def)) + @test isequal_interval(acos(Interval(bareinterval(-0x1.51EB851EB851FP-2,0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.def)), Interval(bareinterval(0x1P-26,0x1.E837B2FD13428P+0), IntervalArithmetic.def)) end @testset "minimal_atan_test" begin - @test isequal_interval(atan(emptyinterval()), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0,Inf)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0,Inf)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-Inf,0.0)), interval(-0x1.921FB54442D19P+0,0.0)) + @test isequal_interval(atan(bareinterval(-Inf,0.0)), bareinterval(-0x1.921FB54442D19P+0,0.0)) - @test isequal_interval(atan(interval(-Inf,-0.0)), interval(-0x1.921FB54442D19P+0,0.0)) + @test isequal_interval(atan(bareinterval(-Inf,-0.0)), bareinterval(-0x1.921FB54442D19P+0,0.0)) - @test isequal_interval(atan(entireinterval()), interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(1.0,0x1.4C2463567C5ACP+25)), interval(0x1.921FB54442D18P-1,0x1.921FB4E19ABD7P+0)) + @test isequal_interval(atan(bareinterval(1.0,0x1.4C2463567C5ACP+25)), bareinterval(0x1.921FB54442D18P-1,0x1.921FB4E19ABD7P+0)) - @test isequal_interval(atan(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), interval(-0x1.921FB54440CEBP+0,-0x1.91ABE5C1E4C6DP+0)) + @test isequal_interval(atan(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), bareinterval(-0x1.921FB54440CEBP+0,-0x1.91ABE5C1E4C6DP+0)) end @testset "minimal_atan_dec_test" begin - @test isequal_interval(atan(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0,0.0), def)) + @test isequal_interval(atan(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0,0.0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), dac)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0,0x1.921FB54442D19P+0), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(1.0,0x1.4C2463567C5ACP+25), trv)), DecoratedInterval(interval(0x1.921FB54442D18P-1,0x1.921FB4E19ABD7P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(1.0,0x1.4C2463567C5ACP+25), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P-1,0x1.921FB4E19ABD7P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), com)), DecoratedInterval(interval(-0x1.921FB54440CEBP+0,-0x1.91ABE5C1E4C6DP+0), com)) + @test isequal_interval(atan(Interval(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54440CEBP+0,-0x1.91ABE5C1E4C6DP+0), IntervalArithmetic.com)) end @testset "minimal_atan2_test" begin - @test isequal_interval(atan(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-2.0, -0.1)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-2.0, -0.1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-2.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-2.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-2.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-2.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-2.0, 1.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-2.0, 1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(0.0, 1.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(0.0, 1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(-0.0, 1.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(-0.0, 1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(emptyinterval(), interval(0.1, 1.0)), emptyinterval()) + @test isequal_interval(atan(emptyinterval(BareInterval{Float64}), bareinterval(0.1, 1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(entireinterval(), entireinterval()), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(entireinterval(), interval(0.0, 0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(-0.0, 0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(-0.0, -0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(-2.0, -0.1)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-2.0, -0.1)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(entireinterval(), interval(-2.0, 0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-2.0, 0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(entireinterval(), interval(-2.0, -0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-2.0, -0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(entireinterval(), interval(-2.0, 1.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-2.0, 1.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(entireinterval(), interval(0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(-0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(-0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(entireinterval(), interval(0.1, 1.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(0.1, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), entireinterval()), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-2.0, -0.1)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-2.0, 1.0)), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-2.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.1, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.1, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, 0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 0.0), entireinterval()), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-2.0, -0.1)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-2.0, 1.0)), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-2.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(-0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, 0.0), interval(0.1, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, 0.0), bareinterval(0.1, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(0.0, -0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, -0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, -0.0), entireinterval()), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, -0.0), interval(0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-2.0, -0.1)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-2.0, 1.0)), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-2.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(-0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(0.0, -0.0), interval(0.1, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(0.0, -0.0), bareinterval(0.1, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, -0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, -0.0), entireinterval()), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-0.0, -0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-0.0, -0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-2.0, -0.1)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-2.0, 1.0)), interval(0.0,0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-2.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(-0.0, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-0.0, -0.0), interval(0.1, 1.0)), interval(0.0,0.0)) + @test isequal_interval(atan(bareinterval(-0.0, -0.0), bareinterval(0.1, 1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atan(interval(-2.0, -0.1), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-2.0, -0.1), entireinterval()), interval(-0x1.921FB54442D19P+1,0.0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+1,0.0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-2.0, -0.1)), interval(-0x1.8BBAABDE5E29CP+1, -0x1.9EE9C8100C211P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-2.0, -0.1)), bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.9EE9C8100C211P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-2.0, 0.0)), interval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-2.0, 0.0)), bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-2.0, -0.0)), interval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-2.0, -0.0)), bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-2.0, 1.0)), interval(-0x1.8BBAABDE5E29CP+1, -0x1.983E282E2CC4CP-4)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-2.0, 1.0)), bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.983E282E2CC4CP-4)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(0.0, 1.0)), interval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(-0.0, 1.0)), interval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(-0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4)) - @test isequal_interval(atan(interval(-2.0, -0.1), interval(0.1, 1.0)), interval(-0x1.8555A2787982P+0, -0x1.983E282E2CC4CP-4)) + @test isequal_interval(atan(bareinterval(-2.0, -0.1), bareinterval(0.1, 1.0)), bareinterval(-0x1.8555A2787982P+0, -0x1.983E282E2CC4CP-4)) - @test isequal_interval(atan(interval(-2.0, 0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-2.0, 0.0), entireinterval()), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-2.0, -0.1)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-2.0, -0.1)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-2.0, 0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-2.0, 0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-2.0, -0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-2.0, -0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-2.0, 1.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-2.0, 1.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(-0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(-0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, 0.0), interval(0.1, 1.0)), interval(-0x1.8555A2787982P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, 0.0), bareinterval(0.1, 1.0)), bareinterval(-0x1.8555A2787982P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, -0.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-2.0, -0.0), entireinterval()), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-0.0, 0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-0.0, -0.0)), interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-2.0, -0.1)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-2.0, -0.1)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-2.0, 0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-2.0, 0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-2.0, -0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-2.0, -0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-2.0, 1.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-2.0, 1.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(-0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(-0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, -0.0), interval(0.1, 1.0)), interval(-0x1.8555A2787982P+0, 0.0)) + @test isequal_interval(atan(bareinterval(-2.0, -0.0), bareinterval(0.1, 1.0)), bareinterval(-0x1.8555A2787982P+0, 0.0)) - @test isequal_interval(atan(interval(-2.0, 1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-2.0, 1.0), entireinterval()), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), entireinterval(BareInterval{Float64})), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(0.0, 0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-0.0, 0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-0.0, 0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(0.0, -0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-0.0, -0.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-0.0, -0.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-2.0, -0.1)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-2.0, -0.1)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-2.0, 0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-2.0, 0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-2.0, -0.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-2.0, -0.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-2.0, 1.0)), interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-2.0, 1.0)), bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(-0.0, 1.0)), interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(-0.0, 1.0)), bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-2.0, 1.0), interval(0.1, 1.0)), interval(-0x1.8555A2787982P+0, 0x1.789BD2C160054P+0)) + @test isequal_interval(atan(bareinterval(-2.0, 1.0), bareinterval(0.1, 1.0)), bareinterval(-0x1.8555A2787982P+0, 0x1.789BD2C160054P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(-0.0, 1.0), entireinterval()), interval(0.0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-2.0, -0.1)), interval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-2.0, 1.0)), interval(0.0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-2.0, 1.0)), bareinterval(0.0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(0.0, 1.0)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(-0.0, 1.0)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(-0.0, 1.0), interval(0.1, 1.0)), interval(0.0, 0x1.789BD2C160054P+0)) + @test isequal_interval(atan(bareinterval(-0.0, 1.0), bareinterval(0.1, 1.0)), bareinterval(0.0, 0x1.789BD2C160054P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, 1.0), entireinterval()), interval(0.0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-2.0, -0.1)), interval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-2.0, 1.0)), interval(0.0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-2.0, 1.0)), bareinterval(0.0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(0.0, 1.0)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(0.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(-0.0, 1.0)), interval(0.0,0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(-0.0, 1.0)), bareinterval(0.0,0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.0, 1.0), interval(0.1, 1.0)), interval(0.0,0x1.789BD2C160054P+0)) + @test isequal_interval(atan(bareinterval(0.0, 1.0), bareinterval(0.1, 1.0)), bareinterval(0.0,0x1.789BD2C160054P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), emptyinterval()), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.1, 1.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.1, 1.0), entireinterval()), interval(0.0, 0x1.921FB54442D19P+1)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0x1.921FB54442D19P+1)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-0.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-0.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-0.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-0.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-2.0, -0.1)), interval(0x1.ABA397C7259DDP+0, 0x1.8BBAABDE5E29CP+1)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-2.0, -0.1)), bareinterval(0x1.ABA397C7259DDP+0, 0x1.8BBAABDE5E29CP+1)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-2.0, 0.0)), interval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-2.0, 0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-2.0, -0.0)), interval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-2.0, -0.0)), bareinterval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-2.0, 1.0)), interval(0x1.983E282E2CC4CP-4, 0x1.8BBAABDE5E29CP+1)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-2.0, 1.0)), bareinterval(0x1.983E282E2CC4CP-4, 0x1.8BBAABDE5E29CP+1)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(0.0, 1.0)), interval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(0.0, 1.0)), bareinterval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(-0.0, 1.0)), interval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(-0.0, 1.0)), bareinterval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0)) - @test isequal_interval(atan(interval(0.1, 1.0), interval(0.1, 1.0)), interval(0x1.983E282E2CC4CP-4, 0x1.789BD2C160054P+0)) + @test isequal_interval(atan(bareinterval(0.1, 1.0), bareinterval(0.1, 1.0)), bareinterval(0x1.983E282E2CC4CP-4, 0x1.789BD2C160054P+0)) end @testset "minimal_atan2_dec_test" begin - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.0, 0.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.0, -0.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-2.0, -0.1), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-2.0, 0.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-2.0, -0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-2.0, 1.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0, 1.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.1, 1.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-0.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-0.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.0, -0.1), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), def)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.0, -0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.0, 1.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 1.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-0.0, 1.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), dac)) + @test isequal_interval(atan(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), def), DecoratedInterval(interval(0.0, 0.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), trv), DecoratedInterval(interval(-0.0, 0.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-0.0, -0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), trv), DecoratedInterval(interval(-2.0, 0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(-2.0, -0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-2.0, 1.0), def)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), def), DecoratedInterval(interval(0.0, 1.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), trv), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), def), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), trv), DecoratedInterval(interval(-0.0, 0.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), com), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), dac), DecoratedInterval(interval(-0.0, -0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), dac), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), trv), DecoratedInterval(interval(-2.0, 0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), com), DecoratedInterval(interval(-2.0, -0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), dac), DecoratedInterval(interval(-2.0, 1.0), def)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), com), DecoratedInterval(interval(0.0, 1.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), def), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 0.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), def), DecoratedInterval(interval(0.0, 0.0), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), trv), DecoratedInterval(interval(-0.0, 0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), dac), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(interval(-0.0, -0.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), def), DecoratedInterval(interval(-2.0, 0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(interval(-2.0, -0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), dac), DecoratedInterval(interval(-2.0, 1.0), com)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(interval(0.0, 1.0), trv)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), def), DecoratedInterval(interval(-0.0, 1.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, -0.0), com), DecoratedInterval(interval(0.1, 1.0), def)), DecoratedInterval(interval(0.0,0.0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), def), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), dac), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), trv), DecoratedInterval(interval(-0.0, 0.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), com), DecoratedInterval(interval(0.0, -0.0), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), dac), DecoratedInterval(interval(-0.0, -0.0), com)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), def), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), def)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), trv), DecoratedInterval(interval(-2.0, 0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), dac), DecoratedInterval(interval(-2.0, -0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), def), DecoratedInterval(interval(-2.0, 1.0), com)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), com), DecoratedInterval(interval(0.0, 1.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), trv), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, -0.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1,0.0), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1,0.0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), trv), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.trv), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, -0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), dac)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-0.0, 0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(interval(-2.0, -0.1), com)), DecoratedInterval(interval(-0x1.8BBAABDE5E29CP+1, -0x1.9EE9C8100C211P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com)), Interval(bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.9EE9C8100C211P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(-2.0, 0.0), def)), DecoratedInterval(interval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), trv), DecoratedInterval(interval(-2.0, -0.0), dac)), DecoratedInterval(interval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.trv), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(interval(-2.0, 1.0), trv)), DecoratedInterval(interval(-0x1.8BBAABDE5E29CP+1, -0x1.983E282E2CC4CP-4), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.8BBAABDE5E29CP+1, -0x1.983E282E2CC4CP-4), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, 1.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-0.0, 1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4), dac)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.983E282E2CC4CP-4), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(-0x1.8555A2787982P+0, -0x1.983E282E2CC4CP-4), com)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.8555A2787982P+0, -0x1.983E282E2CC4CP-4), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), trv), DecoratedInterval(interval(-0.0, 0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(interval(-0.0, -0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-2.0, 0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(-2.0, -0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), trv), DecoratedInterval(interval(-2.0, 1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(interval(0.0, 1.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(-0x1.8555A2787982P+0, 0.0), com)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.8555A2787982P+0, 0.0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), dac), DecoratedInterval(entireinterval(), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), com), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), def), DecoratedInterval(interval(-0.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), dac), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), com), DecoratedInterval(interval(-0.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+0, -0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), def), DecoratedInterval(interval(-2.0, -0.1), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), com), DecoratedInterval(interval(-2.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), dac), DecoratedInterval(interval(-2.0, -0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), def), DecoratedInterval(interval(-2.0, 1.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), trv), DecoratedInterval(interval(0.0, 1.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), com), DecoratedInterval(interval(-0.0, 1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0.0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, -0.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(-0x1.8555A2787982P+0, 0.0), com)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.8555A2787982P+0, 0.0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), def), DecoratedInterval(interval(0.0, 0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), com), DecoratedInterval(interval(-0.0, 0.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), trv), DecoratedInterval(interval(0.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), com), DecoratedInterval(interval(-0.0, -0.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), dac), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), def)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), def), DecoratedInterval(interval(-2.0, 0.0), def)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), trv), DecoratedInterval(interval(-2.0, -0.0), trv)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.trv)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), dac), DecoratedInterval(interval(-2.0, 1.0), com)), DecoratedInterval(interval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.921FB54442D19P+1, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), com), DecoratedInterval(interval(0.0, 1.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), trv), DecoratedInterval(interval(-0.0, 1.0), dac)), DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-2.0, 1.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(-0x1.8555A2787982P+0, 0x1.789BD2C160054P+0), com)) + @test isequal_interval(atan(Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.8555A2787982P+0, 0x1.789BD2C160054P+0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), com), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), dac), DecoratedInterval(entireinterval(), def)), DecoratedInterval(interval(0.0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(bareinterval(0.0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), def), DecoratedInterval(interval(0.0, 0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), trv), DecoratedInterval(interval(-0.0, 0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), dac), DecoratedInterval(interval(0.0, -0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), com), DecoratedInterval(interval(-0.0, -0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), com), DecoratedInterval(interval(-2.0, -0.1), com)), DecoratedInterval(interval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com)), Interval(bareinterval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), def), DecoratedInterval(interval(-2.0, 0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), def), DecoratedInterval(interval(-2.0, -0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), dac), DecoratedInterval(interval(-2.0, 1.0), dac)), DecoratedInterval(interval(0.0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), dac), DecoratedInterval(interval(0.0, 1.0), dac)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), trv), DecoratedInterval(interval(-0.0, 1.0), com)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(-0.0, 1.0), trv), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(0.0, 0x1.789BD2C160054P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0, 0x1.789BD2C160054P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(0.0, 0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), trv), DecoratedInterval(interval(-0.0, 0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), trv), DecoratedInterval(interval(0.0, -0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.trv), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), def), DecoratedInterval(interval(-0.0, -0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(-2.0, -0.1), dac)), DecoratedInterval(interval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac)), Interval(bareinterval(0x1.ABA397C7259DDP+0, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), def), DecoratedInterval(interval(-2.0, 0.0), trv)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.trv)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(-2.0, -0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(-2.0, 1.0), def)), DecoratedInterval(interval(0.0, 0x1.921FB54442D19P+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0, 0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(0.0, 1.0), trv)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.trv)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), dac), DecoratedInterval(interval(-0.0, 1.0), def)), DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.0, 1.0), com), DecoratedInterval(interval(0.1, 1.0), com)), DecoratedInterval(interval(0.0,0x1.789BD2C160054P+0), com)) + @test isequal_interval(atan(Interval(bareinterval(0.0, 1.0), IntervalArithmetic.com), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.789BD2C160054P+0), IntervalArithmetic.com)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0, 0x1.921FB54442D19P+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0, 0x1.921FB54442D19P+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), def), DecoratedInterval(interval(0.0, 0.0), com)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), trv), DecoratedInterval(interval(-0.0, 0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.trv), Interval(bareinterval(-0.0, 0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), trv), DecoratedInterval(interval(0.0, -0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.trv), Interval(bareinterval(0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), dac), DecoratedInterval(interval(-0.0, -0.0), def)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, -0.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), com), DecoratedInterval(interval(-2.0, -0.1), trv)), DecoratedInterval(interval(0x1.ABA397C7259DDP+0, 0x1.8BBAABDE5E29CP+1), trv)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.trv)), Interval(bareinterval(0x1.ABA397C7259DDP+0, 0x1.8BBAABDE5E29CP+1), IntervalArithmetic.trv)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), com), DecoratedInterval(interval(-2.0, 0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), com), DecoratedInterval(interval(-2.0, -0.0), dac)), DecoratedInterval(interval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1), dac)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.com), Interval(bareinterval(-2.0, -0.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.921FB54442D18P+0, 0x1.8BBAABDE5E29CP+1), IntervalArithmetic.dac)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), def), DecoratedInterval(interval(-2.0, 1.0), dac)), DecoratedInterval(interval(0x1.983E282E2CC4CP-4, 0x1.8BBAABDE5E29CP+1), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def), Interval(bareinterval(-2.0, 1.0), IntervalArithmetic.dac)), Interval(bareinterval(0x1.983E282E2CC4CP-4, 0x1.8BBAABDE5E29CP+1), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), def), DecoratedInterval(interval(0.0, 1.0), def)), DecoratedInterval(interval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def), Interval(bareinterval(0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), dac), DecoratedInterval(interval(-0.0, 1.0), def)), DecoratedInterval(interval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.dac), Interval(bareinterval(-0.0, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.983E282E2CC4CP-4, 0x1.921FB54442D19P+0), IntervalArithmetic.def)) - @test isequal_interval(atan(DecoratedInterval(interval(0.1, 1.0), dac), DecoratedInterval(interval(0.1, 1.0), def)), DecoratedInterval(interval(0x1.983E282E2CC4CP-4, 0x1.789BD2C160054P+0), def)) + @test isequal_interval(atan(Interval(bareinterval(0.1, 1.0), IntervalArithmetic.dac), Interval(bareinterval(0.1, 1.0), IntervalArithmetic.def)), Interval(bareinterval(0x1.983E282E2CC4CP-4, 0x1.789BD2C160054P+0), IntervalArithmetic.def)) end @testset "minimal_sinh_test" begin - @test isequal_interval(sinh(emptyinterval()), emptyinterval()) + @test isequal_interval(sinh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(sinh(interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(sinh(bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(sinh(interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(sinh(bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(sinh(interval(-Inf,0.0)), interval(-Inf,0.0)) + @test isequal_interval(sinh(bareinterval(-Inf,0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(sinh(interval(-Inf,-0.0)), interval(-Inf,0.0)) + @test isequal_interval(sinh(bareinterval(-Inf,-0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(sinh(entireinterval()), entireinterval()) + @test isequal_interval(sinh(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(sinh(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(sinh(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sinh(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(sinh(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sinh(interval(1.0,0x1.2C903022DD7AAP+8)), interval(0x1.2CD9FC44EB982P+0,0x1.89BCA168970C6P+432)) + @test isequal_interval(sinh(bareinterval(1.0,0x1.2C903022DD7AAP+8)), bareinterval(0x1.2CD9FC44EB982P+0,0x1.89BCA168970C6P+432)) - @test isequal_interval(sinh(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), interval(-Inf,-0x1.53045B4F849DEP+815)) + @test isequal_interval(sinh(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), bareinterval(-Inf,-0x1.53045B4F849DEP+815)) - @test isequal_interval(sinh(interval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), interval(-0x1.55ECFE1B2B215P+0,0x1.3BF72EA61AF1BP+2)) + @test isequal_interval(sinh(bareinterval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), bareinterval(-0x1.55ECFE1B2B215P+0,0x1.3BF72EA61AF1BP+2)) end @testset "minimal_sinh_dec_test" begin - @test isequal_interval(sinh(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(sinh(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(sinh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(sinh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(sinh(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(-Inf,0.0), def)) + @test isequal_interval(sinh(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)) - @test isequal_interval(sinh(DecoratedInterval(interval(1.0,0x1.2C903022DD7AAP+8), com)), DecoratedInterval(interval(0x1.2CD9FC44EB982P+0,0x1.89BCA168970C6P+432), com)) + @test isequal_interval(sinh(Interval(bareinterval(1.0,0x1.2C903022DD7AAP+8), IntervalArithmetic.com)), Interval(bareinterval(0x1.2CD9FC44EB982P+0,0x1.89BCA168970C6P+432), IntervalArithmetic.com)) - @test isequal_interval(sinh(DecoratedInterval(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), com)), DecoratedInterval(interval(-Inf,-0x1.53045B4F849DEP+815), dac)) + @test isequal_interval(sinh(Interval(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), IntervalArithmetic.com)), Interval(bareinterval(-Inf,-0x1.53045B4F849DEP+815), IntervalArithmetic.dac)) end @testset "minimal_cosh_test" begin - @test isequal_interval(cosh(emptyinterval()), emptyinterval()) + @test isequal_interval(cosh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(cosh(interval(0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(cosh(bareinterval(0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(cosh(interval(-0.0,Inf)), interval(1.0,Inf)) + @test isequal_interval(cosh(bareinterval(-0.0,Inf)), bareinterval(1.0,Inf)) - @test isequal_interval(cosh(interval(-Inf,0.0)), interval(1.0,Inf)) + @test isequal_interval(cosh(bareinterval(-Inf,0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(cosh(interval(-Inf,-0.0)), interval(1.0,Inf)) + @test isequal_interval(cosh(bareinterval(-Inf,-0.0)), bareinterval(1.0,Inf)) - @test isequal_interval(cosh(entireinterval()), interval(1.0,Inf)) + @test isequal_interval(cosh(entireinterval(BareInterval{Float64})), bareinterval(1.0,Inf)) - @test isequal_interval(cosh(interval(0.0,0.0)), interval(1.0,1.0)) + @test isequal_interval(cosh(bareinterval(0.0,0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(cosh(interval(-0.0,-0.0)), interval(1.0,1.0)) + @test isequal_interval(cosh(bareinterval(-0.0,-0.0)), bareinterval(1.0,1.0)) - @test isequal_interval(cosh(interval(1.0,0x1.2C903022DD7AAP+8)), interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432)) + @test isequal_interval(cosh(bareinterval(1.0,0x1.2C903022DD7AAP+8)), bareinterval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432)) - @test isequal_interval(cosh(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), interval(0x1.53045B4F849DEP+815,Inf)) + @test isequal_interval(cosh(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), bareinterval(0x1.53045B4F849DEP+815,Inf)) - @test isequal_interval(cosh(interval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), interval(1.0,0x1.4261D2B7D6181P+2)) + @test isequal_interval(cosh(bareinterval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), bareinterval(1.0,0x1.4261D2B7D6181P+2)) end @testset "minimal_cosh_dec_test" begin - @test isequal_interval(cosh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(1.0,Inf), dac)) + @test isequal_interval(cosh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(cosh(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(1.0,Inf), def)) + @test isequal_interval(cosh(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(cosh(DecoratedInterval(entireinterval(), def)), DecoratedInterval(interval(1.0,Inf), def)) + @test isequal_interval(cosh(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(cosh(DecoratedInterval(interval(1.0,0x1.2C903022DD7AAP+8), def)), DecoratedInterval(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), def)) + @test isequal_interval(cosh(Interval(bareinterval(1.0,0x1.2C903022DD7AAP+8), IntervalArithmetic.def)), Interval(bareinterval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), IntervalArithmetic.def)) - @test isequal_interval(cosh(DecoratedInterval(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), com)), DecoratedInterval(interval(0x1.53045B4F849DEP+815,Inf), dac)) + @test isequal_interval(cosh(Interval(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), IntervalArithmetic.com)), Interval(bareinterval(0x1.53045B4F849DEP+815,Inf), IntervalArithmetic.dac)) end @testset "minimal_tanh_test" begin - @test isequal_interval(tanh(emptyinterval()), emptyinterval()) + @test isequal_interval(tanh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(tanh(interval(0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(tanh(bareinterval(0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(tanh(interval(-0.0,Inf)), interval(0.0,1.0)) + @test isequal_interval(tanh(bareinterval(-0.0,Inf)), bareinterval(0.0,1.0)) - @test isequal_interval(tanh(interval(-Inf,0.0)), interval(-1.0,0.0)) + @test isequal_interval(tanh(bareinterval(-Inf,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(tanh(interval(-Inf,-0.0)), interval(-1.0,0.0)) + @test isequal_interval(tanh(bareinterval(-Inf,-0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(tanh(entireinterval()), interval(-1.0,1.0)) + @test isequal_interval(tanh(entireinterval(BareInterval{Float64})), bareinterval(-1.0,1.0)) - @test isequal_interval(tanh(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(tanh(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(tanh(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(tanh(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(tanh(interval(1.0,0x1.2C903022DD7AAP+8)), interval(0x1.85EFAB514F394P-1,0x1P+0)) + @test isequal_interval(tanh(bareinterval(1.0,0x1.2C903022DD7AAP+8)), bareinterval(0x1.85EFAB514F394P-1,0x1P+0)) - @test isequal_interval(tanh(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) + @test isequal_interval(tanh(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1)) - @test isequal_interval(tanh(interval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), interval(-0x1.99DB01FDE2406P-1,0x1.F5CF31E1C8103P-1)) + @test isequal_interval(tanh(bareinterval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), bareinterval(-0x1.99DB01FDE2406P-1,0x1.F5CF31E1C8103P-1)) end @testset "minimal_tanh_dec_test" begin - @test isequal_interval(tanh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,1.0), dac)) + @test isequal_interval(tanh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac)) - @test isequal_interval(tanh(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(tanh(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(tanh(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(-1.0,1.0), dac)) + @test isequal_interval(tanh(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.dac)) - @test isequal_interval(tanh(DecoratedInterval(interval(1.0,0x1.2C903022DD7AAP+8), com)), DecoratedInterval(interval(0x1.85EFAB514F394P-1,0x1P+0), com)) + @test isequal_interval(tanh(Interval(bareinterval(1.0,0x1.2C903022DD7AAP+8), IntervalArithmetic.com)), Interval(bareinterval(0x1.85EFAB514F394P-1,0x1P+0), IntervalArithmetic.com)) - @test isequal_interval(tanh(DecoratedInterval(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), trv)), DecoratedInterval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), trv)) + @test isequal_interval(tanh(Interval(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), IntervalArithmetic.trv)), Interval(bareinterval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.trv)) end @testset "minimal_asinh_test" begin - @test isequal_interval(asinh(emptyinterval()), emptyinterval()) + @test isequal_interval(asinh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(asinh(interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(asinh(bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(asinh(interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(asinh(bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(asinh(interval(-Inf,0.0)), interval(-Inf,0.0)) + @test isequal_interval(asinh(bareinterval(-Inf,0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(asinh(interval(-Inf,-0.0)), interval(-Inf,0.0)) + @test isequal_interval(asinh(bareinterval(-Inf,-0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(asinh(entireinterval()), entireinterval()) + @test isequal_interval(asinh(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(asinh(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(asinh(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(asinh(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(asinh(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(asinh(interval(1.0,0x1.2C903022DD7AAP+8)), interval(0x1.C34366179D426P-1,0x1.9986127438A87P+2)) + @test isequal_interval(asinh(bareinterval(1.0,0x1.2C903022DD7AAP+8)), bareinterval(0x1.C34366179D426P-1,0x1.9986127438A87P+2)) - @test isequal_interval(asinh(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), interval(-0x1.BB86380A6CC45P+4,-0x1.C204D8EB20827P+2)) + @test isequal_interval(asinh(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9)), bareinterval(-0x1.BB86380A6CC45P+4,-0x1.C204D8EB20827P+2)) - @test isequal_interval(asinh(interval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), interval(-0x1.E693DF6EDF1E7P-1,0x1.91FDC64DE0E51P+0)) + @test isequal_interval(asinh(bareinterval(-0x1.199999999999AP+0,0x1.2666666666666P+1)), bareinterval(-0x1.E693DF6EDF1E7P-1,0x1.91FDC64DE0E51P+0)) end @testset "minimal_asinh_dec_test" begin - @test isequal_interval(asinh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(asinh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(asinh(DecoratedInterval(interval(-Inf,0.0), trv)), DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(asinh(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(asinh(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), dac)) + @test isequal_interval(asinh(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) - @test isequal_interval(asinh(DecoratedInterval(interval(1.0,0x1.2C903022DD7AAP+8), com)), DecoratedInterval(interval(0x1.C34366179D426P-1,0x1.9986127438A87P+2), com)) + @test isequal_interval(asinh(Interval(bareinterval(1.0,0x1.2C903022DD7AAP+8), IntervalArithmetic.com)), Interval(bareinterval(0x1.C34366179D426P-1,0x1.9986127438A87P+2), IntervalArithmetic.com)) - @test isequal_interval(asinh(DecoratedInterval(interval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), def)), DecoratedInterval(interval(-0x1.BB86380A6CC45P+4,-0x1.C204D8EB20827P+2), def)) + @test isequal_interval(asinh(Interval(bareinterval(-0x1.FD219490EAAC1P+38,-0x1.1AF1C9D74F06DP+9), IntervalArithmetic.def)), Interval(bareinterval(-0x1.BB86380A6CC45P+4,-0x1.C204D8EB20827P+2), IntervalArithmetic.def)) end @testset "minimal_acosh_test" begin - @test isequal_interval(acosh(emptyinterval()), emptyinterval()) + @test isequal_interval(acosh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(acosh(interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(acosh(bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(acosh(interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(acosh(bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(acosh(interval(1.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(acosh(bareinterval(1.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(acosh(interval(-Inf,1.0)), interval(0.0,0.0)) + @test isequal_interval(acosh(bareinterval(-Inf,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(acosh(interval(-Inf,0x1.FFFFFFFFFFFFFP-1)), emptyinterval()) + @test isequal_interval(acosh(bareinterval(-Inf,0x1.FFFFFFFFFFFFFP-1)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(acosh(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(acosh(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(acosh(interval(1.0,1.0)), interval(0.0,0.0)) + @test isequal_interval(acosh(bareinterval(1.0,1.0)), bareinterval(0.0,0.0)) - @test isequal_interval(acosh(interval(1.0,0x1.2C903022DD7AAP+8)), interval(0.0,0x1.9985FB3D532AFP+2)) + @test isequal_interval(acosh(bareinterval(1.0,0x1.2C903022DD7AAP+8)), bareinterval(0.0,0x1.9985FB3D532AFP+2)) - @test isequal_interval(acosh(interval(0x1.199999999999AP+0,0x1.2666666666666P+1)), interval(0x1.C636C1A882F2CP-2,0x1.799C88E79140DP+0)) + @test isequal_interval(acosh(bareinterval(0x1.199999999999AP+0,0x1.2666666666666P+1)), bareinterval(0x1.C636C1A882F2CP-2,0x1.799C88E79140DP+0)) - @test isequal_interval(acosh(interval(0x1.14D4E82B2B26FP+15,0x1.72DBE91C837B5P+29)), interval(0x1.656510B4BAEC3P+3,0x1.52A415EE8455AP+4)) + @test isequal_interval(acosh(bareinterval(0x1.14D4E82B2B26FP+15,0x1.72DBE91C837B5P+29)), bareinterval(0x1.656510B4BAEC3P+3,0x1.52A415EE8455AP+4)) end @testset "minimal_acosh_dec_test" begin - @test isequal_interval(acosh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(acosh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(acosh(DecoratedInterval(interval(1.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(acosh(Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(acosh(DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(acosh(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(acosh(DecoratedInterval(interval(1.0,1.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(acosh(Interval(bareinterval(1.0,1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(acosh(DecoratedInterval(interval(0.9,1.0), com)), DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(acosh(Interval(bareinterval(0.9,1.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(acosh(DecoratedInterval(interval(1.0,0x1.2C903022DD7AAP+8), dac)), DecoratedInterval(interval(0.0,0x1.9985FB3D532AFP+2), dac)) + @test isequal_interval(acosh(Interval(bareinterval(1.0,0x1.2C903022DD7AAP+8), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0x1.9985FB3D532AFP+2), IntervalArithmetic.dac)) - @test isequal_interval(acosh(DecoratedInterval(interval(0.9,0x1.2C903022DD7AAP+8), com)), DecoratedInterval(interval(0.0,0x1.9985FB3D532AFP+2), trv)) + @test isequal_interval(acosh(Interval(bareinterval(0.9,0x1.2C903022DD7AAP+8), IntervalArithmetic.com)), Interval(bareinterval(0.0,0x1.9985FB3D532AFP+2), IntervalArithmetic.trv)) - @test isequal_interval(acosh(DecoratedInterval(interval(0x1.14D4E82B2B26FP+15,0x1.72DBE91C837B5P+29), def)), DecoratedInterval(interval(0x1.656510B4BAEC3P+3,0x1.52A415EE8455AP+4), def)) + @test isequal_interval(acosh(Interval(bareinterval(0x1.14D4E82B2B26FP+15,0x1.72DBE91C837B5P+29), IntervalArithmetic.def)), Interval(bareinterval(0x1.656510B4BAEC3P+3,0x1.52A415EE8455AP+4), IntervalArithmetic.def)) end @testset "minimal_atanh_test" begin - @test isequal_interval(atanh(emptyinterval()), emptyinterval()) + @test isequal_interval(atanh(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(atanh(bareinterval(0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(atanh(interval(-0.0,Inf)), interval(0.0,Inf)) + @test isequal_interval(atanh(bareinterval(-0.0,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(atanh(interval(1.0,Inf)), emptyinterval()) + @test isequal_interval(atanh(bareinterval(1.0,Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(-Inf,0.0)), interval(-Inf,0.0)) + @test isequal_interval(atanh(bareinterval(-Inf,0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(atanh(interval(-Inf,-0.0)), interval(-Inf,0.0)) + @test isequal_interval(atanh(bareinterval(-Inf,-0.0)), bareinterval(-Inf,0.0)) - @test isequal_interval(atanh(interval(-Inf,-1.0)), emptyinterval()) + @test isequal_interval(atanh(bareinterval(-Inf,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(-1.0,1.0)), entireinterval()) + @test isequal_interval(atanh(bareinterval(-1.0,1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(atanh(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atanh(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(atanh(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(atanh(interval(-1.0,-1.0)), emptyinterval()) + @test isequal_interval(atanh(bareinterval(-1.0,-1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(1.0,1.0)), emptyinterval()) + @test isequal_interval(atanh(bareinterval(1.0,1.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atanh(entireinterval()), entireinterval()) + @test isequal_interval(atanh(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(0x1.4C0420F6F08CCP-2,0x1.FFFFFFFFFFFFFP-1)), interval(0x1.5871DD2DF9102P-2,0x1.2B708872320E2P+4)) + @test isequal_interval(atanh(bareinterval(0x1.4C0420F6F08CCP-2,0x1.FFFFFFFFFFFFFP-1)), bareinterval(0x1.5871DD2DF9102P-2,0x1.2B708872320E2P+4)) - @test isequal_interval(atanh(interval(-0x1.FFB88E9EB6307P-1,0x1.999999999999AP-4)), interval(-0x1.06A3A97D7979CP+2,0x1.9AF93CD234413P-4)) + @test isequal_interval(atanh(bareinterval(-0x1.FFB88E9EB6307P-1,0x1.999999999999AP-4)), bareinterval(-0x1.06A3A97D7979CP+2,0x1.9AF93CD234413P-4)) end @testset "minimal_atanh_dec_test" begin - @test isequal_interval(atanh(DecoratedInterval(interval(0.0,Inf), dac)), DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(atanh(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(atanh(DecoratedInterval(interval(-Inf,0.0), def)), DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(atanh(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def)), Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(atanh(DecoratedInterval(interval(-1.0,1.0), com)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(atanh(Interval(bareinterval(-1.0,1.0), IntervalArithmetic.com)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atanh(DecoratedInterval(interval(0.0,0.0), com)), DecoratedInterval(interval(0.0,0.0), com)) + @test isequal_interval(atanh(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.com)) - @test isequal_interval(atanh(DecoratedInterval(interval(1.0,1.0), def)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(atanh(Interval(bareinterval(1.0,1.0), IntervalArithmetic.def)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(atanh(DecoratedInterval(interval(0x1.4C0420F6F08CCP-2,0x1.FFFFFFFFFFFFFP-1), com)), DecoratedInterval(interval(0x1.5871DD2DF9102P-2,0x1.2B708872320E2P+4), com)) + @test isequal_interval(atanh(Interval(bareinterval(0x1.4C0420F6F08CCP-2,0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.com)), Interval(bareinterval(0x1.5871DD2DF9102P-2,0x1.2B708872320E2P+4), IntervalArithmetic.com)) - @test isequal_interval(atanh(DecoratedInterval(interval(-1.0,0x1.FFFFFFFFFFFFFP-1), com)), DecoratedInterval(interval(-Inf,0x1.2B708872320E2P+4), trv)) + @test isequal_interval(atanh(Interval(bareinterval(-1.0,0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.com)), Interval(bareinterval(-Inf,0x1.2B708872320E2P+4), IntervalArithmetic.trv)) - @test isequal_interval(atanh(DecoratedInterval(interval(-0x1.FFB88E9EB6307P-1,0x1.999999999999AP-4), def)), DecoratedInterval(interval(-0x1.06A3A97D7979CP+2,0x1.9AF93CD234413P-4), def)) + @test isequal_interval(atanh(Interval(bareinterval(-0x1.FFB88E9EB6307P-1,0x1.999999999999AP-4), IntervalArithmetic.def)), Interval(bareinterval(-0x1.06A3A97D7979CP+2,0x1.9AF93CD234413P-4), IntervalArithmetic.def)) - @test isequal_interval(atanh(DecoratedInterval(interval(-0x1.FFB88E9EB6307P-1,1.0), com)), DecoratedInterval(interval(-0x1.06A3A97D7979CP+2,Inf), trv)) + @test isequal_interval(atanh(Interval(bareinterval(-0x1.FFB88E9EB6307P-1,1.0), IntervalArithmetic.com)), Interval(bareinterval(-0x1.06A3A97D7979CP+2,Inf), IntervalArithmetic.trv)) end @testset "minimal_sign_test" begin - @test isequal_interval(sign(emptyinterval()), emptyinterval()) + @test isequal_interval(sign(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(sign(interval(1.0,2.0)), interval(1.0,1.0)) + @test isequal_interval(sign(bareinterval(1.0,2.0)), bareinterval(1.0,1.0)) - @test isequal_interval(sign(interval(-1.0,2.0)), interval(-1.0,1.0)) + @test isequal_interval(sign(bareinterval(-1.0,2.0)), bareinterval(-1.0,1.0)) - @test isequal_interval(sign(interval(-1.0,0.0)), interval(-1.0,0.0)) + @test isequal_interval(sign(bareinterval(-1.0,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(sign(interval(0.0,2.0)), interval(0.0,1.0)) + @test isequal_interval(sign(bareinterval(0.0,2.0)), bareinterval(0.0,1.0)) - @test isequal_interval(sign(interval(-0.0,2.0)), interval(0.0,1.0)) + @test isequal_interval(sign(bareinterval(-0.0,2.0)), bareinterval(0.0,1.0)) - @test isequal_interval(sign(interval(-5.0,-2.0)), interval(-1.0,-1.0)) + @test isequal_interval(sign(bareinterval(-5.0,-2.0)), bareinterval(-1.0,-1.0)) - @test isequal_interval(sign(interval(0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(sign(bareinterval(0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sign(interval(-0.0,-0.0)), interval(0.0,0.0)) + @test isequal_interval(sign(bareinterval(-0.0,-0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sign(interval(-0.0,0.0)), interval(0.0,0.0)) + @test isequal_interval(sign(bareinterval(-0.0,0.0)), bareinterval(0.0,0.0)) - @test isequal_interval(sign(entireinterval()), interval(-1.0,1.0)) + @test isequal_interval(sign(entireinterval(BareInterval{Float64})), bareinterval(-1.0,1.0)) end @testset "minimal_sign_dec_test" begin - @test isequal_interval(sign(DecoratedInterval(interval(1.0,2.0), com)), DecoratedInterval(interval(1.0,1.0), com)) + @test isequal_interval(sign(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(sign(DecoratedInterval(interval(-1.0,2.0), com)), DecoratedInterval(interval(-1.0,1.0), def)) + @test isequal_interval(sign(Interval(bareinterval(-1.0,2.0), IntervalArithmetic.com)), Interval(bareinterval(-1.0,1.0), IntervalArithmetic.def)) - @test isequal_interval(sign(DecoratedInterval(interval(-1.0,0.0), com)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(sign(Interval(bareinterval(-1.0,0.0), IntervalArithmetic.com)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(sign(DecoratedInterval(interval(0.0,2.0), com)), DecoratedInterval(interval(0.0,1.0), def)) + @test isequal_interval(sign(Interval(bareinterval(0.0,2.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.def)) - @test isequal_interval(sign(DecoratedInterval(interval(-0.0,2.0), def)), DecoratedInterval(interval(0.0,1.0), def)) + @test isequal_interval(sign(Interval(bareinterval(-0.0,2.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,1.0), IntervalArithmetic.def)) - @test isequal_interval(sign(DecoratedInterval(interval(-5.0,-2.0), trv)), DecoratedInterval(interval(-1.0,-1.0), trv)) + @test isequal_interval(sign(Interval(bareinterval(-5.0,-2.0), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,-1.0), IntervalArithmetic.trv)) - @test isequal_interval(sign(DecoratedInterval(interval(0.0,0.0), dac)), DecoratedInterval(interval(0.0,0.0), dac)) + @test isequal_interval(sign(Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac)) end @testset "minimal_ceil_test" begin - @test isequal_interval(ceil(emptyinterval()), emptyinterval()) + @test isequal_interval(ceil(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(ceil(entireinterval()), entireinterval()) + @test isequal_interval(ceil(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(ceil(interval(1.1,2.0)), interval(2.0,2.0)) + @test isequal_interval(ceil(bareinterval(1.1,2.0)), bareinterval(2.0,2.0)) - @test isequal_interval(ceil(interval(-1.1,2.0)), interval(-1.0,2.0)) + @test isequal_interval(ceil(bareinterval(-1.1,2.0)), bareinterval(-1.0,2.0)) - @test isequal_interval(ceil(interval(-1.1,0.0)), interval(-1.0,0.0)) + @test isequal_interval(ceil(bareinterval(-1.1,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(ceil(interval(-1.1,-0.0)), interval(-1.0,0.0)) + @test isequal_interval(ceil(bareinterval(-1.1,-0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(ceil(interval(-1.1,-0.4)), interval(-1.0,0.0)) + @test isequal_interval(ceil(bareinterval(-1.1,-0.4)), bareinterval(-1.0,0.0)) - @test isequal_interval(ceil(interval(-1.9,2.2)), interval(-1.0,3.0)) + @test isequal_interval(ceil(bareinterval(-1.9,2.2)), bareinterval(-1.0,3.0)) - @test isequal_interval(ceil(interval(-1.0,2.2)), interval(-1.0,3.0)) + @test isequal_interval(ceil(bareinterval(-1.0,2.2)), bareinterval(-1.0,3.0)) - @test isequal_interval(ceil(interval(0.0,2.2)), interval(0.0,3.0)) + @test isequal_interval(ceil(bareinterval(0.0,2.2)), bareinterval(0.0,3.0)) - @test isequal_interval(ceil(interval(-0.0,2.2)), interval(0.0,3.0)) + @test isequal_interval(ceil(bareinterval(-0.0,2.2)), bareinterval(0.0,3.0)) - @test isequal_interval(ceil(interval(-1.5,Inf)), interval(-1.0,Inf)) + @test isequal_interval(ceil(bareinterval(-1.5,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(ceil(interval(0x1.FFFFFFFFFFFFFp1023,Inf)), interval(0x1.FFFFFFFFFFFFFp1023,Inf)) + @test isequal_interval(ceil(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)), bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf)) - @test isequal_interval(ceil(interval(-Inf,2.2)), interval(-Inf,3.0)) + @test isequal_interval(ceil(bareinterval(-Inf,2.2)), bareinterval(-Inf,3.0)) - @test isequal_interval(ceil(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023)), interval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(ceil(bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023)), bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023)) end @testset "minimal_ceil_dec_test" begin - @test isequal_interval(ceil(DecoratedInterval(interval(1.1,2.0), com)), DecoratedInterval(interval(2.0,2.0), dac)) + @test isequal_interval(ceil(Interval(bareinterval(1.1,2.0), IntervalArithmetic.com)), Interval(bareinterval(2.0,2.0), IntervalArithmetic.dac)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.1,2.0), com)), DecoratedInterval(interval(-1.0,2.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.com)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.1,0.0), dac)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.1,-0.0), trv)), DecoratedInterval(interval(-1.0,0.0), trv)) + @test isequal_interval(ceil(Interval(bareinterval(-1.1,-0.0), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.1,-0.4), dac)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.9,2.2), com)), DecoratedInterval(interval(-1.0,3.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-1.9,2.2), IntervalArithmetic.com)), Interval(bareinterval(-1.0,3.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.0,2.2), dac)), DecoratedInterval(interval(-1.0,3.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-1.0,2.2), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,3.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(0.0,2.2), trv)), DecoratedInterval(interval(0.0,3.0), trv)) + @test isequal_interval(ceil(Interval(bareinterval(0.0,2.2), IntervalArithmetic.trv)), Interval(bareinterval(0.0,3.0), IntervalArithmetic.trv)) - @test isequal_interval(ceil(DecoratedInterval(interval(-0.0,2.2), def)), DecoratedInterval(interval(0.0,3.0), def)) + @test isequal_interval(ceil(Interval(bareinterval(-0.0,2.2), IntervalArithmetic.def)), Interval(bareinterval(0.0,3.0), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(-1.5,Inf), trv)), DecoratedInterval(interval(-1.0,Inf), trv)) + @test isequal_interval(ceil(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(ceil(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), dac)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), def)) + @test isequal_interval(ceil(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.def)) - @test isequal_interval(ceil(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac)) + @test isequal_interval(ceil(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)) - @test isequal_interval(ceil(DecoratedInterval(interval(-Inf,2.2), trv)), DecoratedInterval(interval(-Inf,3.0), trv)) + @test isequal_interval(ceil(Interval(bareinterval(-Inf,2.2), IntervalArithmetic.trv)), Interval(bareinterval(-Inf,3.0), IntervalArithmetic.trv)) - @test isequal_interval(ceil(DecoratedInterval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), dac)), DecoratedInterval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), def)) + @test isequal_interval(ceil(Interval(bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)), Interval(bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.def)) end @testset "minimal_floor_test" begin - @test isequal_interval(floor(emptyinterval()), emptyinterval()) + @test isequal_interval(floor(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(floor(entireinterval()), entireinterval()) + @test isequal_interval(floor(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(floor(interval(1.1,2.0)), interval(1.0,2.0)) + @test isequal_interval(floor(bareinterval(1.1,2.0)), bareinterval(1.0,2.0)) - @test isequal_interval(floor(interval(-1.1,2.0)), interval(-2.0,2.0)) + @test isequal_interval(floor(bareinterval(-1.1,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(floor(interval(-1.1,0.0)), interval(-2.0,0.0)) + @test isequal_interval(floor(bareinterval(-1.1,0.0)), bareinterval(-2.0,0.0)) - @test isequal_interval(floor(interval(-1.1,-0.0)), interval(-2.0,0.0)) + @test isequal_interval(floor(bareinterval(-1.1,-0.0)), bareinterval(-2.0,0.0)) - @test isequal_interval(floor(interval(-1.1,-0.4)), interval(-2.0,-1.0)) + @test isequal_interval(floor(bareinterval(-1.1,-0.4)), bareinterval(-2.0,-1.0)) - @test isequal_interval(floor(interval(-1.9,2.2)), interval(-2.0,2.0)) + @test isequal_interval(floor(bareinterval(-1.9,2.2)), bareinterval(-2.0,2.0)) - @test isequal_interval(floor(interval(-1.0,2.2)), interval(-1.0,2.0)) + @test isequal_interval(floor(bareinterval(-1.0,2.2)), bareinterval(-1.0,2.0)) - @test isequal_interval(floor(interval(0.0,2.2)), interval(0.0,2.0)) + @test isequal_interval(floor(bareinterval(0.0,2.2)), bareinterval(0.0,2.0)) - @test isequal_interval(floor(interval(-0.0,2.2)), interval(0.0,2.0)) + @test isequal_interval(floor(bareinterval(-0.0,2.2)), bareinterval(0.0,2.0)) - @test isequal_interval(floor(interval(-1.5,Inf)), interval(-2.0,Inf)) + @test isequal_interval(floor(bareinterval(-1.5,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(floor(interval(-Inf,2.2)), interval(-Inf,2.0)) + @test isequal_interval(floor(bareinterval(-Inf,2.2)), bareinterval(-Inf,2.0)) end @testset "minimal_floor_dec_test" begin - @test isequal_interval(floor(DecoratedInterval(interval(1.1,2.0), com)), DecoratedInterval(interval(1.0,2.0), def)) + @test isequal_interval(floor(Interval(bareinterval(1.1,2.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.1,2.0), def)), DecoratedInterval(interval(-2.0,2.0), def)) + @test isequal_interval(floor(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.def)), Interval(bareinterval(-2.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.1,0.0), dac)), DecoratedInterval(interval(-2.0,0.0), def)) + @test isequal_interval(floor(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.dac)), Interval(bareinterval(-2.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.2,-1.1), com)), DecoratedInterval(interval(-2.0,-2.0), com)) + @test isequal_interval(floor(Interval(bareinterval(-1.2,-1.1), IntervalArithmetic.com)), Interval(bareinterval(-2.0,-2.0), IntervalArithmetic.com)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.1,-0.4), def)), DecoratedInterval(interval(-2.0,-1.0), def)) + @test isequal_interval(floor(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.def)), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.9,2.2), com)), DecoratedInterval(interval(-2.0,2.0), def)) + @test isequal_interval(floor(Interval(bareinterval(-1.9,2.2), IntervalArithmetic.com)), Interval(bareinterval(-2.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.0,2.2), trv)), DecoratedInterval(interval(-1.0,2.0), trv)) + @test isequal_interval(floor(Interval(bareinterval(-1.0,2.2), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(floor(DecoratedInterval(interval(0.0,2.2), trv)), DecoratedInterval(interval(0.0,2.0), trv)) + @test isequal_interval(floor(Interval(bareinterval(0.0,2.2), IntervalArithmetic.trv)), Interval(bareinterval(0.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(floor(DecoratedInterval(interval(-0.0,2.2), com)), DecoratedInterval(interval(0.0,2.0), def)) + @test isequal_interval(floor(Interval(bareinterval(-0.0,2.2), IntervalArithmetic.com)), Interval(bareinterval(0.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-1.5,Inf), dac)), DecoratedInterval(interval(-2.0,Inf), def)) + @test isequal_interval(floor(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(-2.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(floor(DecoratedInterval(interval(-Inf,2.2), trv)), DecoratedInterval(interval(-Inf,2.0), trv)) + @test isequal_interval(floor(Interval(bareinterval(-Inf,2.2), IntervalArithmetic.trv)), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) - @test isequal_interval(floor(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), dac)) + @test isequal_interval(floor(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)) end @testset "minimal_trunc_test" begin - @test isequal_interval(trunc(emptyinterval()), emptyinterval()) + @test isequal_interval(trunc(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(trunc(entireinterval()), entireinterval()) + @test isequal_interval(trunc(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(trunc(interval(1.1,2.1)), interval(1.0,2.0)) + @test isequal_interval(trunc(bareinterval(1.1,2.1)), bareinterval(1.0,2.0)) - @test isequal_interval(trunc(interval(-1.1,2.0)), interval(-1.0,2.0)) + @test isequal_interval(trunc(bareinterval(-1.1,2.0)), bareinterval(-1.0,2.0)) - @test isequal_interval(trunc(interval(-1.1,0.0)), interval(-1.0,0.0)) + @test isequal_interval(trunc(bareinterval(-1.1,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(trunc(interval(-1.1,-0.0)), interval(-1.0,0.0)) + @test isequal_interval(trunc(bareinterval(-1.1,-0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(trunc(interval(-1.1,-0.4)), interval(-1.0,0.0)) + @test isequal_interval(trunc(bareinterval(-1.1,-0.4)), bareinterval(-1.0,0.0)) - @test isequal_interval(trunc(interval(-1.9,2.2)), interval(-1.0,2.0)) + @test isequal_interval(trunc(bareinterval(-1.9,2.2)), bareinterval(-1.0,2.0)) - @test isequal_interval(trunc(interval(-1.0,2.2)), interval(-1.0,2.0)) + @test isequal_interval(trunc(bareinterval(-1.0,2.2)), bareinterval(-1.0,2.0)) - @test isequal_interval(trunc(interval(0.0,2.2)), interval(0.0,2.0)) + @test isequal_interval(trunc(bareinterval(0.0,2.2)), bareinterval(0.0,2.0)) - @test isequal_interval(trunc(interval(-0.0,2.2)), interval(0.0,2.0)) + @test isequal_interval(trunc(bareinterval(-0.0,2.2)), bareinterval(0.0,2.0)) - @test isequal_interval(trunc(interval(-1.5,Inf)), interval(-1.0,Inf)) + @test isequal_interval(trunc(bareinterval(-1.5,Inf)), bareinterval(-1.0,Inf)) - @test isequal_interval(trunc(interval(-Inf,2.2)), interval(-Inf,2.0)) + @test isequal_interval(trunc(bareinterval(-Inf,2.2)), bareinterval(-Inf,2.0)) end @testset "minimal_trunc_dec_test" begin - @test isequal_interval(trunc(DecoratedInterval(interval(1.1,2.1), com)), DecoratedInterval(interval(1.0,2.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(1.1,2.1), IntervalArithmetic.com)), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(1.1,1.9), com)), DecoratedInterval(interval(1.0,1.0), com)) + @test isequal_interval(trunc(Interval(bareinterval(1.1,1.9), IntervalArithmetic.com)), Interval(bareinterval(1.0,1.0), IntervalArithmetic.com)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.1,2.0), dac)), DecoratedInterval(interval(-1.0,2.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.1,0.0), trv)), DecoratedInterval(interval(-1.0,0.0), trv)) + @test isequal_interval(trunc(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.1,-0.0), def)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.1,-0.0), IntervalArithmetic.def)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.1,-0.4), com)), DecoratedInterval(interval(-1.0,0.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.com)), Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.9,2.2), def)), DecoratedInterval(interval(-1.0,2.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.9,2.2), IntervalArithmetic.def)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.0,2.2), dac)), DecoratedInterval(interval(-1.0,2.0), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.0,2.2), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-1.5,Inf), dac)), DecoratedInterval(interval(-1.0,Inf), def)) + @test isequal_interval(trunc(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(-1.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(trunc(DecoratedInterval(interval(-Inf,2.2), trv)), DecoratedInterval(interval(-Inf,2.0), trv)) + @test isequal_interval(trunc(Interval(bareinterval(-Inf,2.2), IntervalArithmetic.trv)), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) - @test isequal_interval(trunc(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac)) + @test isequal_interval(trunc(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)) - @test isequal_interval(trunc(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), dac)), DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,Inf), def)) + @test isequal_interval(trunc(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,Inf), IntervalArithmetic.def)) end @testset "minimal_round_ties_to_even_test" begin - @test isequal_interval(round(emptyinterval()), emptyinterval()) + @test isequal_interval(round(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(round(entireinterval()), entireinterval()) + @test isequal_interval(round(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(round(interval(1.1,2.1)), interval(1.0,2.0)) + @test isequal_interval(round(bareinterval(1.1,2.1)), bareinterval(1.0,2.0)) - @test isequal_interval(round(interval(-1.1,2.0)), interval(-1.0,2.0)) + @test isequal_interval(round(bareinterval(-1.1,2.0)), bareinterval(-1.0,2.0)) - @test isequal_interval(round(interval(-1.1,-0.4)), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.4)), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.1,0.0)), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.1,-0.0)), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.0)), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.9,2.2)), interval(-2.0,2.0)) + @test isequal_interval(round(bareinterval(-1.9,2.2)), bareinterval(-2.0,2.0)) - @test isequal_interval(round(interval(-1.0,2.2)), interval(-1.0,2.0)) + @test isequal_interval(round(bareinterval(-1.0,2.2)), bareinterval(-1.0,2.0)) - @test isequal_interval(round(interval(1.5,2.1)), interval(2.0,2.0)) + @test isequal_interval(round(bareinterval(1.5,2.1)), bareinterval(2.0,2.0)) - @test isequal_interval(round(interval(-1.5,2.0)), interval(-2.0,2.0)) + @test isequal_interval(round(bareinterval(-1.5,2.0)), bareinterval(-2.0,2.0)) - @test isequal_interval(round(interval(-1.1,-0.5)), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.5)), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.9,2.5)), interval(-2.0,2.0)) + @test isequal_interval(round(bareinterval(-1.9,2.5)), bareinterval(-2.0,2.0)) - @test isequal_interval(round(interval(0.0,2.5)), interval(0.0,2.0)) + @test isequal_interval(round(bareinterval(0.0,2.5)), bareinterval(0.0,2.0)) - @test isequal_interval(round(interval(-0.0,2.5)), interval(0.0,2.0)) + @test isequal_interval(round(bareinterval(-0.0,2.5)), bareinterval(0.0,2.0)) - @test isequal_interval(round(interval(-1.5,2.5)), interval(-2.0,2.0)) + @test isequal_interval(round(bareinterval(-1.5,2.5)), bareinterval(-2.0,2.0)) - @test isequal_interval(round(interval(-1.5,Inf)), interval(-2.0,Inf)) + @test isequal_interval(round(bareinterval(-1.5,Inf)), bareinterval(-2.0,Inf)) - @test isequal_interval(round(interval(-Inf,2.2)), interval(-Inf,2.0)) + @test isequal_interval(round(bareinterval(-Inf,2.2)), bareinterval(-Inf,2.0)) end @testset "minimal_round_ties_to_even_dec_test" begin - @test isequal_interval(round(DecoratedInterval(interval(1.1,2.1), com)), DecoratedInterval(interval(1.0,2.0), def)) + @test isequal_interval(round(Interval(bareinterval(1.1,2.1), IntervalArithmetic.com)), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(-1.1,2.0), trv)), DecoratedInterval(interval(-1.0,2.0), trv)) + @test isequal_interval(round(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.trv)), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(round(DecoratedInterval(interval(-1.6,-1.5), com)), DecoratedInterval(interval(-2.0,-2.0), dac)) + @test isequal_interval(round(Interval(bareinterval(-1.6,-1.5), IntervalArithmetic.com)), Interval(bareinterval(-2.0,-2.0), IntervalArithmetic.dac)) - @test isequal_interval(round(DecoratedInterval(interval(-1.6,-1.4), com)), DecoratedInterval(interval(-2.0,-1.0), def)) + @test isequal_interval(round(Interval(bareinterval(-1.6,-1.4), IntervalArithmetic.com)), Interval(bareinterval(-2.0,-1.0), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(-1.5,Inf), dac)), DecoratedInterval(interval(-2.0,Inf), def)) + @test isequal_interval(round(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(-2.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(-Inf,2.2), trv)), DecoratedInterval(interval(-Inf,2.0), trv)) + @test isequal_interval(round(Interval(bareinterval(-Inf,2.2), IntervalArithmetic.trv)), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.trv)) end @testset "minimal_round_ties_to_away_test" begin - @test isequal_interval(round(emptyinterval(), RoundNearestTiesAway), emptyinterval()) + @test isequal_interval(round(emptyinterval(BareInterval{Float64}), RoundNearestTiesAway), emptyinterval(BareInterval{Float64})) - @test isequal_interval(round(entireinterval(), RoundNearestTiesAway), entireinterval()) + @test isequal_interval(round(entireinterval(BareInterval{Float64}), RoundNearestTiesAway), entireinterval(BareInterval{Float64})) - @test isequal_interval(round(interval(1.1,2.1), RoundNearestTiesAway), interval(1.0,2.0)) + @test isequal_interval(round(bareinterval(1.1,2.1), RoundNearestTiesAway), bareinterval(1.0,2.0)) - @test isequal_interval(round(interval(-1.1,2.0), RoundNearestTiesAway), interval(-1.0,2.0)) + @test isequal_interval(round(bareinterval(-1.1,2.0), RoundNearestTiesAway), bareinterval(-1.0,2.0)) - @test isequal_interval(round(interval(-1.1,0.0), RoundNearestTiesAway), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,0.0), RoundNearestTiesAway), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.1,-0.0), RoundNearestTiesAway), interval(-1.0,-0.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.0), RoundNearestTiesAway), bareinterval(-1.0,-0.0)) - @test isequal_interval(round(interval(-1.1,-0.4), RoundNearestTiesAway), interval(-1.0,0.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.4), RoundNearestTiesAway), bareinterval(-1.0,0.0)) - @test isequal_interval(round(interval(-1.9,2.2), RoundNearestTiesAway), interval(-2.0,2.0)) + @test isequal_interval(round(bareinterval(-1.9,2.2), RoundNearestTiesAway), bareinterval(-2.0,2.0)) - @test isequal_interval(round(interval(-1.0,2.2), RoundNearestTiesAway), interval(-1.0,2.0)) + @test isequal_interval(round(bareinterval(-1.0,2.2), RoundNearestTiesAway), bareinterval(-1.0,2.0)) - @test isequal_interval(round(interval(0.5,2.1), RoundNearestTiesAway), interval(1.0,2.0)) + @test isequal_interval(round(bareinterval(0.5,2.1), RoundNearestTiesAway), bareinterval(1.0,2.0)) - @test isequal_interval(round(interval(-2.5,2.0), RoundNearestTiesAway), interval(-3.0,2.0)) + @test isequal_interval(round(bareinterval(-2.5,2.0), RoundNearestTiesAway), bareinterval(-3.0,2.0)) - @test isequal_interval(round(interval(-1.1,-0.5), RoundNearestTiesAway), interval(-1.0,-1.0)) + @test isequal_interval(round(bareinterval(-1.1,-0.5), RoundNearestTiesAway), bareinterval(-1.0,-1.0)) - @test isequal_interval(round(interval(-1.9,2.5), RoundNearestTiesAway), interval(-2.0,3.0)) + @test isequal_interval(round(bareinterval(-1.9,2.5), RoundNearestTiesAway), bareinterval(-2.0,3.0)) - @test isequal_interval(round(interval(-1.5,2.5), RoundNearestTiesAway), interval(-2.0,3.0)) + @test isequal_interval(round(bareinterval(-1.5,2.5), RoundNearestTiesAway), bareinterval(-2.0,3.0)) - @test isequal_interval(round(interval(0.0,2.5), RoundNearestTiesAway), interval(0.0,3.0)) + @test isequal_interval(round(bareinterval(0.0,2.5), RoundNearestTiesAway), bareinterval(0.0,3.0)) - @test isequal_interval(round(interval(-0.0,2.5), RoundNearestTiesAway), interval(0.0,3.0)) + @test isequal_interval(round(bareinterval(-0.0,2.5), RoundNearestTiesAway), bareinterval(0.0,3.0)) - @test isequal_interval(round(interval(-1.5,Inf), RoundNearestTiesAway), interval(-2.0,Inf)) + @test isequal_interval(round(bareinterval(-1.5,Inf), RoundNearestTiesAway), bareinterval(-2.0,Inf)) - @test isequal_interval(round(interval(-Inf,2.2), RoundNearestTiesAway), interval(-Inf,2.0)) + @test isequal_interval(round(bareinterval(-Inf,2.2), RoundNearestTiesAway), bareinterval(-Inf,2.0)) end @testset "minimal_round_ties_to_away_dec_test" begin - @test isequal_interval(round(DecoratedInterval(interval(1.1,2.1), com), RoundNearestTiesAway), DecoratedInterval(interval(1.0,2.0), def)) + @test isequal_interval(round(Interval(bareinterval(1.1,2.1), IntervalArithmetic.com), RoundNearestTiesAway), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(-1.9,2.2), com), RoundNearestTiesAway), DecoratedInterval(interval(-2.0,2.0), def)) + @test isequal_interval(round(Interval(bareinterval(-1.9,2.2), IntervalArithmetic.com), RoundNearestTiesAway), Interval(bareinterval(-2.0,2.0), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(1.9,2.2), com), RoundNearestTiesAway), DecoratedInterval(interval(2.0,2.0), com)) + @test isequal_interval(round(Interval(bareinterval(1.9,2.2), IntervalArithmetic.com), RoundNearestTiesAway), Interval(bareinterval(2.0,2.0), IntervalArithmetic.com)) - @test isequal_interval(round(DecoratedInterval(interval(-1.0,2.2), trv), RoundNearestTiesAway), DecoratedInterval(interval(-1.0,2.0), trv)) + @test isequal_interval(round(Interval(bareinterval(-1.0,2.2), IntervalArithmetic.trv), RoundNearestTiesAway), Interval(bareinterval(-1.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(round(DecoratedInterval(interval(2.5,2.6), com), RoundNearestTiesAway), DecoratedInterval(interval(3.0,3.0), dac)) + @test isequal_interval(round(Interval(bareinterval(2.5,2.6), IntervalArithmetic.com), RoundNearestTiesAway), Interval(bareinterval(3.0,3.0), IntervalArithmetic.dac)) - @test isequal_interval(round(DecoratedInterval(interval(-1.5,Inf), dac), RoundNearestTiesAway), DecoratedInterval(interval(-2.0,Inf), def)) + @test isequal_interval(round(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.dac), RoundNearestTiesAway), Interval(bareinterval(-2.0,Inf), IntervalArithmetic.def)) - @test isequal_interval(round(DecoratedInterval(interval(-Inf,2.2), def), RoundNearestTiesAway), DecoratedInterval(interval(-Inf,2.0), def)) + @test isequal_interval(round(Interval(bareinterval(-Inf,2.2), IntervalArithmetic.def), RoundNearestTiesAway), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.def)) end @testset "minimal_abs_test" begin - @test isequal_interval(abs(emptyinterval()), emptyinterval()) + @test isequal_interval(abs(emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs(entireinterval()), interval(0.0,Inf)) + @test isequal_interval(abs(entireinterval(BareInterval{Float64})), bareinterval(0.0,Inf)) - @test isequal_interval(abs(interval(1.1,2.1)), interval(1.1,2.1)) + @test isequal_interval(abs(bareinterval(1.1,2.1)), bareinterval(1.1,2.1)) - @test isequal_interval(abs(interval(-1.1,2.0)), interval(0.0,2.0)) + @test isequal_interval(abs(bareinterval(-1.1,2.0)), bareinterval(0.0,2.0)) - @test isequal_interval(abs(interval(-1.1,0.0)), interval(0.0,1.1)) + @test isequal_interval(abs(bareinterval(-1.1,0.0)), bareinterval(0.0,1.1)) - @test isequal_interval(abs(interval(-1.1,-0.0)), interval(0.0,1.1)) + @test isequal_interval(abs(bareinterval(-1.1,-0.0)), bareinterval(0.0,1.1)) - @test isequal_interval(abs(interval(-1.1,-0.4)), interval(0.4,1.1)) + @test isequal_interval(abs(bareinterval(-1.1,-0.4)), bareinterval(0.4,1.1)) - @test isequal_interval(abs(interval(-1.9,0.2)), interval(0.0,1.9)) + @test isequal_interval(abs(bareinterval(-1.9,0.2)), bareinterval(0.0,1.9)) - @test isequal_interval(abs(interval(0.0,0.2)), interval(0.0,0.2)) + @test isequal_interval(abs(bareinterval(0.0,0.2)), bareinterval(0.0,0.2)) - @test isequal_interval(abs(interval(-0.0,0.2)), interval(0.0,0.2)) + @test isequal_interval(abs(bareinterval(-0.0,0.2)), bareinterval(0.0,0.2)) - @test isequal_interval(abs(interval(-1.5,Inf)), interval(0.0,Inf)) + @test isequal_interval(abs(bareinterval(-1.5,Inf)), bareinterval(0.0,Inf)) - @test isequal_interval(abs(interval(-Inf,-2.2)), interval(2.2,Inf)) + @test isequal_interval(abs(bareinterval(-Inf,-2.2)), bareinterval(2.2,Inf)) end @testset "minimal_abs_dec_test" begin - @test isequal_interval(abs(DecoratedInterval(interval(-1.1,2.0), com)), DecoratedInterval(interval(0.0,2.0), com)) + @test isequal_interval(abs(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.com)), Interval(bareinterval(0.0,2.0), IntervalArithmetic.com)) - @test isequal_interval(abs(DecoratedInterval(interval(-1.1,0.0), dac)), DecoratedInterval(interval(0.0,1.1), dac)) + @test isequal_interval(abs(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.1), IntervalArithmetic.dac)) - @test isequal_interval(abs(DecoratedInterval(interval(-1.1,-0.0), def)), DecoratedInterval(interval(0.0,1.1), def)) + @test isequal_interval(abs(Interval(bareinterval(-1.1,-0.0), IntervalArithmetic.def)), Interval(bareinterval(0.0,1.1), IntervalArithmetic.def)) - @test isequal_interval(abs(DecoratedInterval(interval(-1.1,-0.4), trv)), DecoratedInterval(interval(0.4,1.1), trv)) + @test isequal_interval(abs(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.trv)), Interval(bareinterval(0.4,1.1), IntervalArithmetic.trv)) - @test isequal_interval(abs(DecoratedInterval(interval(-1.9,0.2), dac)), DecoratedInterval(interval(0.0,1.9), dac)) + @test isequal_interval(abs(Interval(bareinterval(-1.9,0.2), IntervalArithmetic.dac)), Interval(bareinterval(0.0,1.9), IntervalArithmetic.dac)) - @test isequal_interval(abs(DecoratedInterval(interval(0.0,0.2), def)), DecoratedInterval(interval(0.0,0.2), def)) + @test isequal_interval(abs(Interval(bareinterval(0.0,0.2), IntervalArithmetic.def)), Interval(bareinterval(0.0,0.2), IntervalArithmetic.def)) - @test isequal_interval(abs(DecoratedInterval(interval(-0.0,0.2), com)), DecoratedInterval(interval(0.0,0.2), com)) + @test isequal_interval(abs(Interval(bareinterval(-0.0,0.2), IntervalArithmetic.com)), Interval(bareinterval(0.0,0.2), IntervalArithmetic.com)) - @test isequal_interval(abs(DecoratedInterval(interval(-1.5,Inf), dac)), DecoratedInterval(interval(0.0,Inf), dac)) + @test isequal_interval(abs(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.dac)), Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac)) end @testset "minimal_min_test" begin - @test isequal_interval(min(emptyinterval(), interval(1.0,2.0)), emptyinterval()) + @test isequal_interval(min(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(min(interval(1.0,2.0), emptyinterval()), emptyinterval()) + @test isequal_interval(min(bareinterval(1.0,2.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(min(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(min(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(min(entireinterval(), interval(1.0,2.0)), interval(-Inf,2.0)) + @test isequal_interval(min(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0)), bareinterval(-Inf,2.0)) - @test isequal_interval(min(interval(1.0,2.0), entireinterval()), interval(-Inf,2.0)) + @test isequal_interval(min(bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})), bareinterval(-Inf,2.0)) - @test isequal_interval(min(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(min(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(min(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(min(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(min(interval(1.0,5.0), interval(2.0,4.0)), interval(1.0,4.0)) + @test isequal_interval(min(bareinterval(1.0,5.0), bareinterval(2.0,4.0)), bareinterval(1.0,4.0)) - @test isequal_interval(min(interval(0.0,5.0), interval(2.0,4.0)), interval(0.0,4.0)) + @test isequal_interval(min(bareinterval(0.0,5.0), bareinterval(2.0,4.0)), bareinterval(0.0,4.0)) - @test isequal_interval(min(interval(-0.0,5.0), interval(2.0,4.0)), interval(0.0,4.0)) + @test isequal_interval(min(bareinterval(-0.0,5.0), bareinterval(2.0,4.0)), bareinterval(0.0,4.0)) - @test isequal_interval(min(interval(1.0,5.0), interval(2.0,8.0)), interval(1.0,5.0)) + @test isequal_interval(min(bareinterval(1.0,5.0), bareinterval(2.0,8.0)), bareinterval(1.0,5.0)) - @test isequal_interval(min(interval(1.0,5.0), entireinterval()), interval(-Inf,5.0)) + @test isequal_interval(min(bareinterval(1.0,5.0), entireinterval(BareInterval{Float64})), bareinterval(-Inf,5.0)) - @test isequal_interval(min(interval(-7.0,-5.0), interval(2.0,4.0)), interval(-7.0,-5.0)) + @test isequal_interval(min(bareinterval(-7.0,-5.0), bareinterval(2.0,4.0)), bareinterval(-7.0,-5.0)) - @test isequal_interval(min(interval(-7.0,0.0), interval(2.0,4.0)), interval(-7.0,0.0)) + @test isequal_interval(min(bareinterval(-7.0,0.0), bareinterval(2.0,4.0)), bareinterval(-7.0,0.0)) - @test isequal_interval(min(interval(-7.0,-0.0), interval(2.0,4.0)), interval(-7.0,0.0)) + @test isequal_interval(min(bareinterval(-7.0,-0.0), bareinterval(2.0,4.0)), bareinterval(-7.0,0.0)) end @testset "minimal_min_dec_test" begin - @test isequal_interval(min(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(1.0,2.0), com)), DecoratedInterval(interval(-Inf,2.0), dac)) + @test isequal_interval(min(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)), Interval(bareinterval(-Inf,2.0), IntervalArithmetic.dac)) - @test isequal_interval(min(DecoratedInterval(interval(-7.0,-5.0), trv), DecoratedInterval(interval(2.0,4.0), def)), DecoratedInterval(interval(-7.0,-5.0), trv)) + @test isequal_interval(min(Interval(bareinterval(-7.0,-5.0), IntervalArithmetic.trv), Interval(bareinterval(2.0,4.0), IntervalArithmetic.def)), Interval(bareinterval(-7.0,-5.0), IntervalArithmetic.trv)) - @test isequal_interval(min(DecoratedInterval(interval(-7.0,0.0), dac), DecoratedInterval(interval(2.0,4.0), def)), DecoratedInterval(interval(-7.0,0.0), def)) + @test isequal_interval(min(Interval(bareinterval(-7.0,0.0), IntervalArithmetic.dac), Interval(bareinterval(2.0,4.0), IntervalArithmetic.def)), Interval(bareinterval(-7.0,0.0), IntervalArithmetic.def)) - @test isequal_interval(min(DecoratedInterval(interval(-7.0,-0.0), com), DecoratedInterval(interval(2.0,4.0), com)), DecoratedInterval(interval(-7.0,0.0), com)) + @test isequal_interval(min(Interval(bareinterval(-7.0,-0.0), IntervalArithmetic.com), Interval(bareinterval(2.0,4.0), IntervalArithmetic.com)), Interval(bareinterval(-7.0,0.0), IntervalArithmetic.com)) end @testset "minimal_max_test" begin - @test isequal_interval(max(emptyinterval(), interval(1.0,2.0)), emptyinterval()) + @test isequal_interval(max(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(max(interval(1.0,2.0), emptyinterval()), emptyinterval()) + @test isequal_interval(max(bareinterval(1.0,2.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(max(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(max(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(max(entireinterval(), interval(1.0,2.0)), interval(1.0,Inf)) + @test isequal_interval(max(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0)), bareinterval(1.0,Inf)) - @test isequal_interval(max(interval(1.0,2.0), entireinterval()), interval(1.0,Inf)) + @test isequal_interval(max(bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})), bareinterval(1.0,Inf)) - @test isequal_interval(max(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(max(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(max(emptyinterval(), entireinterval()), emptyinterval()) + @test isequal_interval(max(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(max(interval(1.0,5.0), interval(2.0,4.0)), interval(2.0,5.0)) + @test isequal_interval(max(bareinterval(1.0,5.0), bareinterval(2.0,4.0)), bareinterval(2.0,5.0)) - @test isequal_interval(max(interval(1.0,5.0), interval(2.0,8.0)), interval(2.0,8.0)) + @test isequal_interval(max(bareinterval(1.0,5.0), bareinterval(2.0,8.0)), bareinterval(2.0,8.0)) - @test isequal_interval(max(interval(-1.0,5.0), entireinterval()), interval(-1.0,Inf)) + @test isequal_interval(max(bareinterval(-1.0,5.0), entireinterval(BareInterval{Float64})), bareinterval(-1.0,Inf)) - @test isequal_interval(max(interval(-7.0,-5.0), interval(2.0,4.0)), interval(2.0,4.0)) + @test isequal_interval(max(bareinterval(-7.0,-5.0), bareinterval(2.0,4.0)), bareinterval(2.0,4.0)) - @test isequal_interval(max(interval(-7.0,-5.0), interval(0.0,4.0)), interval(0.0,4.0)) + @test isequal_interval(max(bareinterval(-7.0,-5.0), bareinterval(0.0,4.0)), bareinterval(0.0,4.0)) - @test isequal_interval(max(interval(-7.0,-5.0), interval(-0.0,4.0)), interval(0.0,4.0)) + @test isequal_interval(max(bareinterval(-7.0,-5.0), bareinterval(-0.0,4.0)), bareinterval(0.0,4.0)) - @test isequal_interval(max(interval(-7.0,-5.0), interval(-2.0,0.0)), interval(-2.0,0.0)) + @test isequal_interval(max(bareinterval(-7.0,-5.0), bareinterval(-2.0,0.0)), bareinterval(-2.0,0.0)) - @test isequal_interval(max(interval(-7.0,-5.0), interval(-2.0,-0.0)), interval(-2.0,0.0)) + @test isequal_interval(max(bareinterval(-7.0,-5.0), bareinterval(-2.0,-0.0)), bareinterval(-2.0,0.0)) end @testset "minimal_max_dec_test" begin - @test isequal_interval(max(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(1.0,2.0), com)), DecoratedInterval(interval(1.0,Inf), dac)) + @test isequal_interval(max(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)), Interval(bareinterval(1.0,Inf), IntervalArithmetic.dac)) - @test isequal_interval(max(DecoratedInterval(interval(-7.0,-5.0), trv), DecoratedInterval(interval(2.0,4.0), def)), DecoratedInterval(interval(2.0,4.0), trv)) + @test isequal_interval(max(Interval(bareinterval(-7.0,-5.0), IntervalArithmetic.trv), Interval(bareinterval(2.0,4.0), IntervalArithmetic.def)), Interval(bareinterval(2.0,4.0), IntervalArithmetic.trv)) - @test isequal_interval(max(DecoratedInterval(interval(-7.0,5.0), dac), DecoratedInterval(interval(2.0,4.0), def)), DecoratedInterval(interval(2.0,5.0), def)) + @test isequal_interval(max(Interval(bareinterval(-7.0,5.0), IntervalArithmetic.dac), Interval(bareinterval(2.0,4.0), IntervalArithmetic.def)), Interval(bareinterval(2.0,5.0), IntervalArithmetic.def)) - @test isequal_interval(max(DecoratedInterval(interval(3.0,3.5), com), DecoratedInterval(interval(2.0,4.0), com)), DecoratedInterval(interval(3.0,4.0), com)) + @test isequal_interval(max(Interval(bareinterval(3.0,3.5), IntervalArithmetic.com), Interval(bareinterval(2.0,4.0), IntervalArithmetic.com)), Interval(bareinterval(3.0,4.0), IntervalArithmetic.com)) end diff --git a/test/test_ITF1788/libieeep1788_mul_rev.jl b/test/test_ITF1788/libieeep1788_mul_rev.jl index 8815e0943..059b4f6a9 100644 --- a/test/test_ITF1788/libieeep1788_mul_rev.jl +++ b/test/test_ITF1788/libieeep1788_mul_rev.jl @@ -1,701 +1,701 @@ @testset "minimal_mulRevToPair_test" begin - @test isequal_interval(mul_rev_to_pair(emptyinterval(), interval(1.0, 2.0))[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(emptyinterval(), interval(1.0, 2.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(emptyinterval(BareInterval{Float64}), bareinterval(1.0, 2.0))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(emptyinterval(BareInterval{Float64}), bareinterval(1.0, 2.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(1.0, 2.0), emptyinterval())[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(interval(1.0, 2.0), emptyinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(1.0, 2.0), emptyinterval(BareInterval{Float64}))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(1.0, 2.0), emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(emptyinterval(), emptyinterval())[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(emptyinterval(), emptyinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, -0.4))[1], interval(0x1.999999999999AP-3, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, -0.4))[1], bareinterval(0x1.999999999999AP-3, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, -0.4))[1], interval(0x1.999999999999AP-3, Inf)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, -0.4))[1], bareinterval(0x1.999999999999AP-3, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, -0.4))[1], interval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, -0.4))[2], interval(0x1.999999999999AP-3, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, -0.4))[2], bareinterval(0x1.999999999999AP-3, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, -0.4))[1], interval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, -0.4))[1], interval(-0x1.A400000000001P+7, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, -0.4))[1], bareinterval(-0x1.A400000000001P+7, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, -0.4))[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, -0.4))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, -0.4))[1], interval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, -0.4))[1], bareinterval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, -0.4))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, -0.4))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, -0.4))[1], interval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, -0.4))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, -0x1.745D1745D1745P-2)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, -0.4))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, -0.4))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, -0.4))[2], interval(0x1.999999999999AP-3, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, -0.4))[2], bareinterval(0x1.999999999999AP-3, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, -0.4))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, -0.4))[1], interval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, -0.4))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, -0.4))[1], bareinterval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, -0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, -0.4))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, -0.4))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, -0.4))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, -0.4))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, 0.0))[1], interval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, 0.0))[1], bareinterval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, 0.0))[1], interval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, 0.0))[1], bareinterval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, 0.0))[1], interval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, 0.0))[1], bareinterval(0.0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, 0.0))[1], interval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, 0.0))[1], bareinterval(-0x1.A400000000001P+7, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, 0.12))[1], interval(-0x1.3333333333333P+0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, 0.12))[1], bareinterval(-0x1.3333333333333P+0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, 0.12))[1], interval(-0x1.A400000000001P+7 , 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, 0.12))[1], bareinterval(-0x1.A400000000001P+7 , 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, 0.12))[1], interval(-0x1.3333333333333P+0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, 0.12))[1], bareinterval(-0x1.3333333333333P+0, 0x1.5P+4)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, 0.12))[1], interval(-0x1.A400000000001P+7 , 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, 0.12))[1], bareinterval(-0x1.A400000000001P+7 , 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-2.1, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-2.1, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, 0.12))[1], interval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, 0.12))[1], bareinterval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, 0.12))[1], interval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, 0.12))[1], bareinterval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, 0.12))[1], interval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, 0.12))[1], bareinterval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, 0.12))[1], interval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, 0.12))[1], bareinterval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, 0.12))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.12))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.01, 0.12))[1], interval(-0x1.3333333333333P+0, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.01, 0.12))[1], bareinterval(-0x1.3333333333333P+0, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.01, 0.12))[1], interval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.01, 0.12))[1], interval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.01, 0.12))[2], interval(0x1.29E4129E4129DP-7, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.01, 0.12))[2], bareinterval(0x1.29E4129E4129DP-7, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.01, 0.12))[1], interval(0x1.29E4129E4129DP-7, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.01, 0.12))[1], bareinterval(0x1.29E4129E4129DP-7, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.01, 0.12))[1], interval(0x1.29E4129E4129DP-7, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.01, 0.12))[1], bareinterval(0x1.29E4129E4129DP-7, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.01, 0.12))[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.01, 0.12))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.01, 0.12))[1], interval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.01, 0.12))[1], bareinterval(-0x1.3333333333333P+0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.01, 0.12))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.01, 0.12))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.01, 0.12))[2], interval(0x1.29E4129E4129DP-7, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.01, 0.12))[2], bareinterval(0x1.29E4129E4129DP-7, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.01, 0.12))[1], interval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.01, 0.12))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-8)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.01, 0.12))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.01, 0.12))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.01, 0.12))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.01, 0.12))[1], interval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.01, 0.12))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.01, 0.12))[1], bareinterval(0.0, 0x1.8P+3)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.01, 0.12))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.01, 0.12))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.01, 0.12))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.01, 0.12))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.01, 0.12))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, 0.0))[1], interval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, 0.0))[1], bareinterval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, 0.0))[1], interval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, 0.0))[1], bareinterval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, 0.0))[1], interval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, 0.0))[1], bareinterval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, 0.0))[1], interval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, 0.0))[1], bareinterval(0.0, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, -0.1))[1], interval(0x1.999999999999AP-5, Inf)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, -0.1))[1], bareinterval(0x1.999999999999AP-5, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, -0.1))[1], interval(0x1.999999999999AP-5 , Inf)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, -0.1))[1], bareinterval(0x1.999999999999AP-5 , Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, -0.1))[1], interval(-Inf , -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, -0.1))[2], interval(0x1.999999999999AP-5 , Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf , -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, -0.1))[2], bareinterval(0x1.999999999999AP-5 , Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, -0.1))[1], interval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, -0.1))[1], interval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, -0.1))[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, -0.1))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, -0.1))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, -0.1))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, -0.1))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, -0.1))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, -0.1))[1], interval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, -0.1))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, -0x1.745D1745D1745P-4)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, -0.1))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, -0.1))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, -0.1))[2], interval(0x1.999999999999AP-5 , Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, -0.1))[2], bareinterval(0x1.999999999999AP-5 , Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, -0.1))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, -0.1))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, -0.1))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, -0.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, -0.1))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, -0.1))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -0.1))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, -0.1))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, 0.0))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, 0.0))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, 0.0))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, 0.0))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, 0.0))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, 0.0))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, 0.0))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, 0.0))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, 0.0))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, 0.0))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.0))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, 0.3))[1], interval(-0x1.8P+1, Inf)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, 0.3))[1], bareinterval(-0x1.8P+1, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, 0.3))[1], interval(-Inf, 0x1.EP+4)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, 0.3))[1], bareinterval(-Inf, 0x1.EP+4)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, 0.3))[1], interval(-0x1.8P+1, Inf)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, 0.3))[1], bareinterval(-0x1.8P+1, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, 0.3))[1], interval(-Inf, 0x1.EP+4)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, 0.3))[1], bareinterval(-Inf, 0x1.EP+4)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, 0.3))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-Inf, 0.3))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.3))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.3))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-0.21, Inf))[1], interval(-Inf , 0x1.0CCCCCCCCCCCDP+1)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-0.21, Inf))[1], bareinterval(-Inf , 0x1.0CCCCCCCCCCCDP+1)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-0.21, Inf))[1], interval(-0x1.5P+4, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-0.21, Inf))[1], bareinterval(-0x1.5P+4, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-0.21, Inf))[1], interval(-Inf, 0x1.0CCCCCCCCCCCDP+1)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-0.21, Inf))[1], bareinterval(-Inf, 0x1.0CCCCCCCCCCCDP+1)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-0.21, Inf))[1], interval(-0x1.5P+4, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-0.21, Inf))[1], bareinterval(-0x1.5P+4, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(-0.21, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(-0.21, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-0.21, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(-0.21, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, Inf))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, Inf))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, Inf))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, Inf))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, Inf))[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.0, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, Inf))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.0, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.04, Inf))[1], interval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.04, Inf))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.04, Inf))[1], interval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.04, Inf))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.04, Inf))[1], interval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), interval(0.04, Inf))[2], interval(0x1.29E4129E4129DP-5, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.04, Inf))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), bareinterval(0.04, Inf))[2], bareinterval(0x1.29E4129E4129DP-5, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.04, Inf))[1], interval(0x1.29E4129E4129DP-5, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.04, Inf))[1], bareinterval(0x1.29E4129E4129DP-5, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.04, Inf))[1], interval(0x1.29E4129E4129DP-5, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.04, Inf))[1], bareinterval(0x1.29E4129E4129DP-5, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.04, Inf))[1], emptyinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.04, Inf))[1], emptyinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.04, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.04, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.04, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.04, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.04, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), interval(0.04, Inf))[2], interval(0x1.29E4129E4129DP-5, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.04, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), bareinterval(0.04, Inf))[2], bareinterval(0x1.29E4129E4129DP-5, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.04, Inf))[1], interval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), interval(0.04, Inf))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.04, Inf))[1], bareinterval(-Inf, -0x1.47AE147AE147BP-6)) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), bareinterval(0.04, Inf))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.04, Inf))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.04, Inf))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.04, Inf))[1], interval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), interval(0.04, Inf))[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.04, Inf))[1], bareinterval(0.0, Inf)) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), bareinterval(0.04, Inf))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.04, Inf))[1], interval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(), interval(0.04, Inf))[2], interval(0.0, Inf)) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.04, Inf))[1], bareinterval(-Inf, 0.0)) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), bareinterval(0.04, Inf))[2], bareinterval(0.0, Inf)) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, -0.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, -0.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 0.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 0.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, 1.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, 1.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 1.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 1.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.01, 1.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, 1.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, 0.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, -0.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, -0.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 0.0), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 0.0), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-Inf, 1.1), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-Inf, 1.1), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(-2.0, Inf), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(-2.0, Inf), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.0, Inf), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.0, Inf), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.0, Inf), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(interval(0.01, Inf), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(interval(0.01, Inf), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(bareinterval(0.01, Inf), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_to_pair(entireinterval(), entireinterval())[1], entireinterval()) && isequal_interval(mul_rev_to_pair(entireinterval(), entireinterval())[2], emptyinterval()) + @test isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}))[1], entireinterval(BareInterval{Float64})) && isequal_interval(mul_rev_to_pair(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) end @testset "minimal_mulRevToPair_dec_test" begin - @test isnai(mul_rev_to_pair(nai(), DecoratedInterval(interval(1.0,2.0), def))[1]) && isnai(mul_rev_to_pair(nai(), DecoratedInterval(interval(1.0,2.0), def))[2]) + @test isnai(mul_rev_to_pair(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def))[1]) && isnai(mul_rev_to_pair(nai(), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def))[2]) - @test isnai(mul_rev_to_pair(DecoratedInterval(interval(1.0,2.0), com), nai())[1]) && isnai(mul_rev_to_pair(DecoratedInterval(interval(1.0,2.0), com), nai())[2]) + @test isnai(mul_rev_to_pair(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), nai())[1]) && isnai(mul_rev_to_pair(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), nai())[2]) @test isnai(mul_rev_to_pair(nai(), nai())[1]) && isnai(mul_rev_to_pair(nai(), nai())[2]) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0, 2.0), def))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0, 2.0), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0, 2.0), IntervalArithmetic.def))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0, 2.0), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(1.0, 2.0), com), DecoratedInterval(emptyinterval(), trv))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(1.0, 2.0), com), DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(1.0, 2.0), IntervalArithmetic.com), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(-2.1, -0.4), com))[1], DecoratedInterval(interval(0x1.999999999999AP-3, 0x1.5P+4), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(-2.1, -0.4), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[1], Interval(bareinterval(0x1.999999999999AP-3, 0x1.5P+4), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-2.1, -0.4), com))[1], DecoratedInterval(interval(0x1.999999999999AP-3, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-2.1, -0.4), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[1], Interval(bareinterval(0x1.999999999999AP-3, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(-2.1, -0.4), dac))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-2), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(-2.1, -0.4), dac))[2], DecoratedInterval(interval(0x1.999999999999AP-3, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-2), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.999999999999AP-3, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), trv), DecoratedInterval(interval(-2.1, -0.4), def))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-2), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), trv), DecoratedInterval(interval(-2.1, -0.4), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.trv), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-2), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.trv), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(-2.1, -0.4), com))[1], DecoratedInterval(interval(-0x1.A400000000001P+7, -0x1.745D1745D1745P-2), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(-2.1, -0.4), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[1], Interval(bareinterval(-0x1.A400000000001P+7, -0x1.745D1745D1745P-2), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-2.1, -0.4), def))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-2.1, -0.4), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[1], DecoratedInterval(interval(0.0, 0x1.5P+4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, 0x1.5P+4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), def), DecoratedInterval(interval(-2.1, -0.4), com))[1], DecoratedInterval(interval(0.0, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), def), DecoratedInterval(interval(-2.1, -0.4), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), trv), DecoratedInterval(interval(-2.1, -0.4), def))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-2), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), trv), DecoratedInterval(interval(-2.1, -0.4), def))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.trv), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-2), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.trv), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[2], DecoratedInterval(interval(0x1.999999999999AP-3, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.999999999999AP-3, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), def), DecoratedInterval(interval(-2.1, -0.4), com))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), def), DecoratedInterval(interval(-2.1, -0.4), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), def), DecoratedInterval(interval(-2.1, -0.4), def))[1], DecoratedInterval(interval(-0x1.A400000000001P+7, 0.0), def)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), def), DecoratedInterval(interval(-2.1, -0.4), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[1], Interval(bareinterval(-0x1.A400000000001P+7, 0.0), IntervalArithmetic.def)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.1, -0.4), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.1, -0.4), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(interval(0.0, 0x1.5P+4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0x1.5P+4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(interval(-0x1.A400000000001P+7, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(-0x1.A400000000001P+7, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(interval(0.0, 0x1.5P+4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0x1.5P+4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(interval(-0x1.A400000000001P+7, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(-0x1.A400000000001P+7, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.1, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-2.1, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-2.1, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, 0x1.5P+4), def)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.3333333333333P+0, 0x1.5P+4), IntervalArithmetic.def)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(interval(-0x1.A400000000001P+7 , 0x1.8P+3), def)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.A400000000001P+7 , 0x1.8P+3), IntervalArithmetic.def)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, 0x1.5P+4), def)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.3333333333333P+0, 0x1.5P+4), IntervalArithmetic.def)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(interval(-0x1.A400000000001P+7 , 0x1.8P+3), def)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.A400000000001P+7 , 0x1.8P+3), IntervalArithmetic.def)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-2.1, 0.12), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-2.1, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(bareinterval(-2.1, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, 0.0), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(bareinterval(-0x1.3333333333333P+0, 0.0), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(interval(0.0, 0x1.8P+3), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0x1.8P+3), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(bareinterval(-0x1.3333333333333P+0, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(interval(0.0, 0x1.8P+3), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0x1.8P+3), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 0.12), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 0.12), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.12), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, -0x1.47AE147AE147BP-8), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.3333333333333P+0, -0x1.47AE147AE147BP-8), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-8), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-8), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-8), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(interval(0x1.29E4129E4129DP-7, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-8), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.29E4129E4129DP-7, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(0x1.29E4129E4129DP-7, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.29E4129E4129DP-7, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(0x1.29E4129E4129DP-7, 0x1.8P+3), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.29E4129E4129DP-7, 0x1.8P+3), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-0x1.3333333333333P+0, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.3333333333333P+0, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(interval(0x1.29E4129E4129DP-7, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.29E4129E4129DP-7, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-8), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-8), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(0.0, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(0.0, 0x1.8P+3), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, 0x1.8P+3), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.01, 0.12), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.01, 0.12), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.01, 0.12), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(interval(0.0, 0.0), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(interval(0.0, 0.0), com)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), com), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(interval(0.0, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(interval(0.0, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 0.0), com))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, 0.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, 0.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(0x1.999999999999AP-5, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.999999999999AP-5, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(0x1.999999999999AP-5 , Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.999999999999AP-5 , Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf , -0x1.745D1745D1745P-4), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(interval(0x1.999999999999AP-5 , Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf , -0x1.745D1745D1745P-4), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.999999999999AP-5 , Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-4), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-4), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(0.0, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, -0x1.745D1745D1745P-4), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.745D1745D1745P-4), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(interval(0x1.999999999999AP-5 , Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.999999999999AP-5 , Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, -0.1), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, 0.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(interval(-0x1.8P+1, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.8P+1, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(interval(-Inf, 0x1.EP+4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0x1.EP+4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(interval(-0x1.8P+1, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.8P+1, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(interval(-Inf, 0x1.EP+4), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0x1.EP+4), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-Inf, 0.3), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-Inf, 0.3), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(interval(-Inf , 0x1.0CCCCCCCCCCCDP+1), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf , 0x1.0CCCCCCCCCCCDP+1), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(interval(-0x1.5P+4, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.5P+4, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0x1.0CCCCCCCCCCCDP+1), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0x1.0CCCCCCCCCCCDP+1), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(interval(-0x1.5P+4, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-0x1.5P+4, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-0.21, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(-0.21, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(-0.21, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, Inf), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.0, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-6), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-6), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-6), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-6), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-6), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(interval(0x1.29E4129E4129DP-5, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-6), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.29E4129E4129DP-5, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(0x1.29E4129E4129DP-5, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.29E4129E4129DP-5, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(0x1.29E4129E4129DP-5, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0x1.29E4129E4129DP-5, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(emptyinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(interval(0x1.29E4129E4129DP-5, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(0x1.29E4129E4129DP-5, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, -0x1.47AE147AE147BP-6), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, -0x1.47AE147AE147BP-6), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(0.0, Inf), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(0.0, Inf), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.04, Inf), dac))[1], DecoratedInterval(interval(-Inf, 0.0), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(interval(0.04, Inf), dac))[2], DecoratedInterval(interval(0.0, Inf), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[1], Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(bareinterval(0.04, Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0, Inf), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, -0.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 0.0), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, 1.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 1.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, 0.0), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, -0.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 0.0), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 0.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-Inf, 1.1), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-Inf, 1.1), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(-2.0, Inf), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(-2.0, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.0, Inf), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.0, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), dac)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(interval(0.01, Inf), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) && isequal_interval(mul_rev_to_pair(Interval(bareinterval(0.01, Inf), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(entireinterval(), dac))[1], DecoratedInterval(entireinterval(), trv)) && isequal_interval(mul_rev_to_pair(DecoratedInterval(entireinterval(), dac), DecoratedInterval(entireinterval(), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[1], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) && isequal_interval(mul_rev_to_pair(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end diff --git a/test/test_ITF1788/libieeep1788_num.jl b/test/test_ITF1788/libieeep1788_num.jl index f5ce089a7..13bfc2a9d 100644 --- a/test/test_ITF1788/libieeep1788_num.jl +++ b/test/test_ITF1788/libieeep1788_num.jl @@ -1,6 +1,6 @@ @testset "minimal_inf_test" begin - @test inf(emptyinterval()) === +Inf + @test inf(emptyinterval(BareInterval{Float64})) === +Inf @test inf(interval(-Inf,+Inf)) === -Inf @@ -34,39 +34,39 @@ end @test isnan(inf(nai())) - @test inf(DecoratedInterval(emptyinterval(), trv)) === +Inf + @test inf(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) === +Inf - @test inf(DecoratedInterval(interval(-Inf,+Inf), def)) === -Inf + @test inf(Interval(interval(-Inf,+Inf), IntervalArithmetic.def)) === -Inf - @test inf(DecoratedInterval(interval(1.0,2.0), com)) === 1.0 + @test inf(Interval(interval(1.0,2.0), IntervalArithmetic.com)) === 1.0 - @test inf(DecoratedInterval(interval(-3.0,-2.0), trv)) === -3.0 + @test inf(Interval(interval(-3.0,-2.0), IntervalArithmetic.trv)) === -3.0 - @test inf(DecoratedInterval(interval(-Inf,2.0), dac)) === -Inf + @test inf(Interval(interval(-Inf,2.0), IntervalArithmetic.dac)) === -Inf - @test inf(DecoratedInterval(interval(-Inf,0.0), def)) === -Inf + @test inf(Interval(interval(-Inf,0.0), IntervalArithmetic.def)) === -Inf - @test inf(DecoratedInterval(interval(-Inf,-0.0), trv)) === -Inf + @test inf(Interval(interval(-Inf,-0.0), IntervalArithmetic.trv)) === -Inf - @test inf(DecoratedInterval(interval(-2.0,Inf), trv)) === -2.0 + @test inf(Interval(interval(-2.0,Inf), IntervalArithmetic.trv)) === -2.0 - @test inf(DecoratedInterval(interval(0.0,Inf), def)) === -0.0 + @test inf(Interval(interval(0.0,Inf), IntervalArithmetic.def)) === -0.0 - @test inf(DecoratedInterval(interval(-0.0,Inf), trv)) === -0.0 + @test inf(Interval(interval(-0.0,Inf), IntervalArithmetic.trv)) === -0.0 - @test inf(DecoratedInterval(interval(-0.0,0.0), dac)) === -0.0 + @test inf(Interval(interval(-0.0,0.0), IntervalArithmetic.dac)) === -0.0 - @test inf(DecoratedInterval(interval(0.0,-0.0), trv)) === -0.0 + @test inf(Interval(interval(0.0,-0.0), IntervalArithmetic.trv)) === -0.0 - @test inf(DecoratedInterval(interval(0.0,0.0), trv)) === -0.0 + @test inf(Interval(interval(0.0,0.0), IntervalArithmetic.trv)) === -0.0 - @test inf(DecoratedInterval(interval(-0.0,-0.0), trv)) === -0.0 + @test inf(Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) === -0.0 end @testset "minimal_sup_test" begin - @test sup(emptyinterval()) === -Inf + @test sup(emptyinterval(BareInterval{Float64})) === -Inf @test sup(interval(-Inf,+Inf)) === +Inf @@ -100,39 +100,39 @@ end @test isnan(sup(nai())) - @test sup(DecoratedInterval(emptyinterval(), trv)) === -Inf + @test sup(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) === -Inf - @test sup(DecoratedInterval(interval(-Inf,+Inf), def)) === +Inf + @test sup(Interval(interval(-Inf,+Inf), IntervalArithmetic.def)) === +Inf - @test sup(DecoratedInterval(interval(1.0,2.0), com)) === 2.0 + @test sup(Interval(interval(1.0,2.0), IntervalArithmetic.com)) === 2.0 - @test sup(DecoratedInterval(interval(-3.0,-2.0), trv)) === -2.0 + @test sup(Interval(interval(-3.0,-2.0), IntervalArithmetic.trv)) === -2.0 - @test sup(DecoratedInterval(interval(-Inf,2.0), dac)) === 2.0 + @test sup(Interval(interval(-Inf,2.0), IntervalArithmetic.dac)) === 2.0 - @test sup(DecoratedInterval(interval(-Inf,0.0), def)) === 0.0 + @test sup(Interval(interval(-Inf,0.0), IntervalArithmetic.def)) === 0.0 - @test sup(DecoratedInterval(interval(-Inf,-0.0), trv)) === 0.0 + @test sup(Interval(interval(-Inf,-0.0), IntervalArithmetic.trv)) === 0.0 - @test sup(DecoratedInterval(interval(-2.0,Inf), trv)) === Inf + @test sup(Interval(interval(-2.0,Inf), IntervalArithmetic.trv)) === Inf - @test sup(DecoratedInterval(interval(0.0,Inf), def)) === Inf + @test sup(Interval(interval(0.0,Inf), IntervalArithmetic.def)) === Inf - @test sup(DecoratedInterval(interval(-0.0,Inf), trv)) === Inf + @test sup(Interval(interval(-0.0,Inf), IntervalArithmetic.trv)) === Inf - @test sup(DecoratedInterval(interval(-0.0,0.0), dac)) === +0.0 + @test sup(Interval(interval(-0.0,0.0), IntervalArithmetic.dac)) === +0.0 - @test sup(DecoratedInterval(interval(0.0,-0.0), trv)) === +0.0 + @test sup(Interval(interval(0.0,-0.0), IntervalArithmetic.trv)) === +0.0 - @test sup(DecoratedInterval(interval(0.0,0.0), trv)) === +0.0 + @test sup(Interval(interval(0.0,0.0), IntervalArithmetic.trv)) === +0.0 - @test sup(DecoratedInterval(interval(-0.0,-0.0), trv)) === +0.0 + @test sup(Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) === +0.0 end @testset "minimal_mid_test" begin - @test isnan(mid(emptyinterval())) + @test isnan(mid(emptyinterval(BareInterval{Float64}))) @test mid(interval(-Inf,+Inf)) === 0.0 @@ -160,31 +160,31 @@ end @testset "minimal_mid_dec_test" begin - @test isnan(mid(DecoratedInterval(emptyinterval(), trv))) + @test isnan(mid(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))) @test isnan(mid(nai())) - @test mid(DecoratedInterval(interval(-Inf,+Inf), def)) === 0.0 + @test mid(Interval(interval(-Inf,+Inf), IntervalArithmetic.def)) === 0.0 - @test mid(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,+0x1.FFFFFFFFFFFFFp1023), trv)) === 0.0 + @test mid(Interval(interval(-0x1.FFFFFFFFFFFFFp1023,+0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.trv)) === 0.0 - @test mid(DecoratedInterval(interval(0.0,2.0), com)) === 1.0 + @test mid(Interval(interval(0.0,2.0), IntervalArithmetic.com)) === 1.0 - @test mid(DecoratedInterval(interval(2.0,2.0), dac)) === 2.0 + @test mid(Interval(interval(2.0,2.0), IntervalArithmetic.dac)) === 2.0 - @test mid(DecoratedInterval(interval(-2.0,2.0), trv)) === 0.0 + @test mid(Interval(interval(-2.0,2.0), IntervalArithmetic.trv)) === 0.0 - @test mid(DecoratedInterval(interval(0.0,Inf), trv)) === 0x1.FFFFFFFFFFFFFp1023 + @test mid(Interval(interval(0.0,Inf), IntervalArithmetic.trv)) === 0x1.FFFFFFFFFFFFFp1023 - @test mid(DecoratedInterval(interval(-Inf,1.2), trv)) === -0x1.FFFFFFFFFFFFFp1023 + @test mid(Interval(interval(-Inf,1.2), IntervalArithmetic.trv)) === -0x1.FFFFFFFFFFFFFp1023 - @test mid(DecoratedInterval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), trv)) === 0.0 + @test mid(Interval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), IntervalArithmetic.trv)) === 0.0 - @test mid(DecoratedInterval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), trv)) === 0.0 + @test mid(Interval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), IntervalArithmetic.trv)) === 0.0 - @test mid(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), trv)) === 0x1.7FFFFFFFFFFFFP+1023 + @test mid(Interval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), IntervalArithmetic.trv)) === 0x1.7FFFFFFFFFFFFP+1023 - @test mid(DecoratedInterval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), trv)) === 0x0.0000000000002P-1022 + @test mid(Interval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), IntervalArithmetic.trv)) === 0x0.0000000000002P-1022 end @@ -194,7 +194,7 @@ end @test radius(interval(2.0,2.0)) === 0.0 - @test isnan(radius(emptyinterval())) + @test isnan(radius(emptyinterval(BareInterval{Float64}))) @test radius(interval(-Inf,+Inf)) === Inf @@ -212,31 +212,31 @@ end @testset "minimal_rad_dec_test" begin - @test radius(DecoratedInterval(interval(0.0,2.0), trv)) === 1.0 + @test radius(Interval(interval(0.0,2.0), IntervalArithmetic.trv)) === 1.0 - @test radius(DecoratedInterval(interval(2.0,2.0), com)) === 0.0 + @test radius(Interval(interval(2.0,2.0), IntervalArithmetic.com)) === 0.0 - @test isnan(radius(DecoratedInterval(emptyinterval(), trv))) + @test isnan(radius(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))) @test isnan(radius(nai())) - @test radius(DecoratedInterval(interval(-Inf,+Inf), trv)) === Inf + @test radius(Interval(interval(-Inf,+Inf), IntervalArithmetic.trv)) === Inf - @test radius(DecoratedInterval(interval(0.0,Inf), def)) === Inf + @test radius(Interval(interval(0.0,Inf), IntervalArithmetic.def)) === Inf - @test radius(DecoratedInterval(interval(-Inf, 1.2), trv)) === Inf + @test radius(Interval(interval(-Inf, 1.2), IntervalArithmetic.trv)) === Inf - @test radius(DecoratedInterval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), trv)) === 0x0.0000000000002P-1022 + @test radius(Interval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), IntervalArithmetic.trv)) === 0x0.0000000000002P-1022 - @test radius(DecoratedInterval(interval(0x0.0000000000001P-1022,0x0.0000000000002P-1022), trv)) === 0x0.0000000000001P-1022 + @test radius(Interval(interval(0x0.0000000000001P-1022,0x0.0000000000002P-1022), IntervalArithmetic.trv)) === 0x0.0000000000001P-1022 - @test radius(DecoratedInterval(interval(0x1P+0,0x1.0000000000003P+0), trv)) === 0x1P-51 + @test radius(Interval(interval(0x1P+0,0x1.0000000000003P+0), IntervalArithmetic.trv)) === 0x1P-51 end @testset "minimal_mid_rad_test" begin - @test isnan(midradius(emptyinterval())[1]) && isnan(midradius(emptyinterval())[2]) + @test isnan(midradius(emptyinterval(BareInterval{Float64}))[1]) && isnan(midradius(emptyinterval(BareInterval{Float64}))[2]) @test midradius(interval(-Inf,Inf))[1] === 0.0 && midradius(interval(-Inf,Inf))[2] === Inf @@ -264,31 +264,31 @@ end @testset "minimal_mid_rad_dec_test" begin - @test isnan(midradius(emptyinterval())[1]) && isnan(midradius(emptyinterval())[2]) + @test isnan(midradius(emptyinterval(BareInterval{Float64}))[1]) && isnan(midradius(emptyinterval(BareInterval{Float64}))[2]) @test isnan(midradius(nai())[1]) && isnan(midradius(nai())[2]) - @test midradius(DecoratedInterval(interval(-Inf,Inf), def))[1] === 0.0 && midradius(DecoratedInterval(interval(-Inf,Inf), def))[2] === Inf + @test midradius(Interval(interval(-Inf,Inf), IntervalArithmetic.def))[1] === 0.0 && midradius(Interval(interval(-Inf,Inf), IntervalArithmetic.def))[2] === Inf - @test midradius(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFP+1023,0x1.FFFFFFFFFFFFFP+1023), trv))[1] === 0.0 && midradius(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFP+1023,0x1.FFFFFFFFFFFFFP+1023), trv))[2] === 0x1.FFFFFFFFFFFFFP+1023 + @test midradius(Interval(interval(-0x1.FFFFFFFFFFFFFP+1023,0x1.FFFFFFFFFFFFFP+1023), IntervalArithmetic.trv))[1] === 0.0 && midradius(Interval(interval(-0x1.FFFFFFFFFFFFFP+1023,0x1.FFFFFFFFFFFFFP+1023), IntervalArithmetic.trv))[2] === 0x1.FFFFFFFFFFFFFP+1023 - @test midradius(DecoratedInterval(interval(0.0,2.0), com))[1] === 1.0 && midradius(DecoratedInterval(interval(0.0,2.0), com))[2] === 1.0 + @test midradius(Interval(interval(0.0,2.0), IntervalArithmetic.com))[1] === 1.0 && midradius(Interval(interval(0.0,2.0), IntervalArithmetic.com))[2] === 1.0 - @test midradius(DecoratedInterval(interval(2.0,2.0), dac))[1] === 2.0 && midradius(DecoratedInterval(interval(2.0,2.0), dac))[2] === 0.0 + @test midradius(Interval(interval(2.0,2.0), IntervalArithmetic.dac))[1] === 2.0 && midradius(Interval(interval(2.0,2.0), IntervalArithmetic.dac))[2] === 0.0 - @test midradius(DecoratedInterval(interval(-2.0,2.0), trv))[1] === 0.0 && midradius(DecoratedInterval(interval(-2.0,2.0), trv))[2] === 2.0 + @test midradius(Interval(interval(-2.0,2.0), IntervalArithmetic.trv))[1] === 0.0 && midradius(Interval(interval(-2.0,2.0), IntervalArithmetic.trv))[2] === 2.0 - @test midradius(DecoratedInterval(interval(0.0,Inf), trv))[1] === 0x1.FFFFFFFFFFFFFP+1023 && midradius(DecoratedInterval(interval(0.0,Inf), trv))[2] === Inf + @test midradius(Interval(interval(0.0,Inf), IntervalArithmetic.trv))[1] === 0x1.FFFFFFFFFFFFFP+1023 && midradius(Interval(interval(0.0,Inf), IntervalArithmetic.trv))[2] === Inf - @test midradius(DecoratedInterval(interval(-Inf, 1.2), trv))[1] === -0x1.FFFFFFFFFFFFFP+1023 && midradius(DecoratedInterval(interval(-Inf, 1.2), trv))[2] === Inf + @test midradius(Interval(interval(-Inf, 1.2), IntervalArithmetic.trv))[1] === -0x1.FFFFFFFFFFFFFP+1023 && midradius(Interval(interval(-Inf, 1.2), IntervalArithmetic.trv))[2] === Inf - @test midradius(DecoratedInterval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), trv))[1] === 0.0 && midradius(DecoratedInterval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), trv))[2] === 0x0.0000000000002P-1022 + @test midradius(Interval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), IntervalArithmetic.trv))[1] === 0.0 && midradius(Interval(interval(-0x0.0000000000002P-1022,0x0.0000000000001P-1022), IntervalArithmetic.trv))[2] === 0x0.0000000000002P-1022 - @test midradius(DecoratedInterval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), trv))[1] === 0.0 && midradius(DecoratedInterval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), trv))[2] === 0x0.0000000000002P-1022 + @test midradius(Interval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), IntervalArithmetic.trv))[1] === 0.0 && midradius(Interval(interval(-0x0.0000000000001P-1022,0x0.0000000000002P-1022), IntervalArithmetic.trv))[2] === 0x0.0000000000002P-1022 - @test midradius(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), trv))[1] === 0x1.7FFFFFFFFFFFFP+1023 && midradius(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), trv))[2] === 0x1.0p+1022 + @test midradius(Interval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), IntervalArithmetic.trv))[1] === 0x1.7FFFFFFFFFFFFP+1023 && midradius(Interval(interval(0x1.FFFFFFFFFFFFFP+1022,0x1.FFFFFFFFFFFFFP+1023), IntervalArithmetic.trv))[2] === 0x1.0p+1022 - @test midradius(DecoratedInterval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), trv))[1] === 0x0.0000000000002P-1022 && midradius(DecoratedInterval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), trv))[2] === 0x0.0000000000001P-1022 + @test midradius(Interval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), IntervalArithmetic.trv))[1] === 0x0.0000000000002P-1022 && midradius(Interval(interval(0x0.0000000000001P-1022,0x0.0000000000003P-1022), IntervalArithmetic.trv))[2] === 0x0.0000000000001P-1022 end @@ -304,7 +304,7 @@ end @test diam(interval(-Inf,+Inf)) === Inf - @test isnan(diam(emptyinterval())) + @test isnan(diam(emptyinterval(BareInterval{Float64}))) @test diam(interval(0x1P+0,0x1.0000000000001P+0)) === 0x1P-52 @@ -314,23 +314,23 @@ end @testset "minimal_wid_dec_test" begin - @test diam(DecoratedInterval(interval(2.0,2.0), com)) === 0.0 + @test diam(Interval(interval(2.0,2.0), IntervalArithmetic.com)) === 0.0 - @test diam(DecoratedInterval(interval(1.0,2.0), trv)) === 1.0 + @test diam(Interval(interval(1.0,2.0), IntervalArithmetic.trv)) === 1.0 - @test diam(DecoratedInterval(interval(1.0,Inf), trv)) === Inf + @test diam(Interval(interval(1.0,Inf), IntervalArithmetic.trv)) === Inf - @test diam(DecoratedInterval(interval(-Inf,2.0), def)) === Inf + @test diam(Interval(interval(-Inf,2.0), IntervalArithmetic.def)) === Inf - @test diam(DecoratedInterval(interval(-Inf,+Inf), trv)) === Inf + @test diam(Interval(interval(-Inf,+Inf), IntervalArithmetic.trv)) === Inf - @test isnan(diam(DecoratedInterval(emptyinterval(), trv))) + @test isnan(diam(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))) @test isnan(diam(nai())) - @test diam(DecoratedInterval(interval(0x1P+0,0x1.0000000000001P+0), trv)) === 0x1P-52 + @test diam(Interval(interval(0x1P+0,0x1.0000000000001P+0), IntervalArithmetic.trv)) === 0x1P-52 - @test diam(DecoratedInterval(interval(0x1P-1022,0x1.0000000000001P-1022), trv)) === 0x0.0000000000001P-1022 + @test diam(Interval(interval(0x1P-1022,0x1.0000000000001P-1022), IntervalArithmetic.trv)) === 0x0.0000000000001P-1022 end @@ -346,7 +346,7 @@ end @test mag(interval(-Inf,+Inf)) === Inf - @test isnan(mag(emptyinterval())) + @test isnan(mag(emptyinterval(BareInterval{Float64}))) @test mag(interval(-0.0,0.0)) === 0.0 @@ -356,23 +356,23 @@ end @testset "minimal_mag_dec_test" begin - @test mag(DecoratedInterval(interval(1.0,2.0), com)) === 2.0 + @test mag(Interval(interval(1.0,2.0), IntervalArithmetic.com)) === 2.0 - @test mag(DecoratedInterval(interval(-4.0,2.0), trv)) === 4.0 + @test mag(Interval(interval(-4.0,2.0), IntervalArithmetic.trv)) === 4.0 - @test mag(DecoratedInterval(interval(-Inf,2.0), trv)) === Inf + @test mag(Interval(interval(-Inf,2.0), IntervalArithmetic.trv)) === Inf - @test mag(DecoratedInterval(interval(1.0,Inf), def)) === Inf + @test mag(Interval(interval(1.0,Inf), IntervalArithmetic.def)) === Inf - @test mag(DecoratedInterval(interval(-Inf,+Inf), trv)) === Inf + @test mag(Interval(interval(-Inf,+Inf), IntervalArithmetic.trv)) === Inf - @test isnan(mag(DecoratedInterval(emptyinterval(), trv))) + @test isnan(mag(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))) @test isnan(mag(nai())) - @test mag(DecoratedInterval(interval(-0.0,0.0), trv)) === 0.0 + @test mag(Interval(interval(-0.0,0.0), IntervalArithmetic.trv)) === 0.0 - @test mag(DecoratedInterval(interval(-0.0,-0.0), trv)) === 0.0 + @test mag(Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) === 0.0 end @@ -394,7 +394,7 @@ end @test mig(interval(-Inf,+Inf)) === 0.0 - @test isnan(mig(emptyinterval())) + @test isnan(mig(emptyinterval(BareInterval{Float64}))) @test mig(interval(-0.0,0.0)) === 0.0 @@ -404,28 +404,28 @@ end @testset "minimal_mig_dec_test" begin - @test mig(DecoratedInterval(interval(1.0,2.0), com)) === 1.0 + @test mig(Interval(interval(1.0,2.0), IntervalArithmetic.com)) === 1.0 - @test mig(DecoratedInterval(interval(-4.0,2.0), trv)) === 0.0 + @test mig(Interval(interval(-4.0,2.0), IntervalArithmetic.trv)) === 0.0 - @test mig(DecoratedInterval(interval(-4.0,-2.0), trv)) === 2.0 + @test mig(Interval(interval(-4.0,-2.0), IntervalArithmetic.trv)) === 2.0 - @test mig(DecoratedInterval(interval(-Inf,2.0), def)) === 0.0 + @test mig(Interval(interval(-Inf,2.0), IntervalArithmetic.def)) === 0.0 - @test mig(DecoratedInterval(interval(-Inf,-2.0), trv)) === 2.0 + @test mig(Interval(interval(-Inf,-2.0), IntervalArithmetic.trv)) === 2.0 - @test mig(DecoratedInterval(interval(-1.0,Inf), trv)) === 0.0 + @test mig(Interval(interval(-1.0,Inf), IntervalArithmetic.trv)) === 0.0 - @test mig(DecoratedInterval(interval(1.0,Inf), trv)) === 1.0 + @test mig(Interval(interval(1.0,Inf), IntervalArithmetic.trv)) === 1.0 - @test mig(DecoratedInterval(interval(-Inf,+Inf), trv)) === 0.0 + @test mig(Interval(interval(-Inf,+Inf), IntervalArithmetic.trv)) === 0.0 - @test isnan(mig(DecoratedInterval(emptyinterval(), trv))) + @test isnan(mig(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))) @test isnan(mig(nai())) - @test mig(DecoratedInterval(interval(-0.0,0.0), trv)) === 0.0 + @test mig(Interval(interval(-0.0,0.0), IntervalArithmetic.trv)) === 0.0 - @test mig(DecoratedInterval(interval(-0.0,-0.0), trv)) === 0.0 + @test mig(Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) === 0.0 end diff --git a/test/test_ITF1788/libieeep1788_overlap.jl b/test/test_ITF1788/libieeep1788_overlap.jl index 1442d06b9..87755e83f 100644 --- a/test/test_ITF1788/libieeep1788_overlap.jl +++ b/test/test_ITF1788/libieeep1788_overlap.jl @@ -1,85 +1,84 @@ @testset "minimal_overlap_test" begin - @test overlap(emptyinterval(), emptyinterval()) === Overlap.both_empty - @test overlap(emptyinterval(), interval(1.0,2.0)) === Overlap.first_empty - @test overlap(interval(1.0,2.0), emptyinterval()) === Overlap.second_empty - @test overlap(interval(-Inf,2.0), interval(3.0,Inf)) === Overlap.before - @test overlap(interval(-Inf,2.0), interval(3.0,4.0)) === Overlap.before - @test overlap(interval(2.0,2.0), interval(3.0,4.0)) === Overlap.before - @test overlap(interval(1.0,2.0), interval(3.0,4.0)) === Overlap.before - @test overlap(interval(1.0,2.0), interval(3.0,3.0)) === Overlap.before - @test overlap(interval(2.0,2.0), interval(3.0,3.0)) === Overlap.before - @test overlap(interval(2.0,2.0), interval(3.0,Inf)) === Overlap.before - @test overlap(interval(-Inf,2.0), interval(2.0,3.0)) === Overlap.meets - @test overlap(interval(1.0,2.0), interval(2.0,3.0)) === Overlap.meets - @test overlap(interval(1.0,2.0), interval(2.0,Inf)) === Overlap.meets - @test overlap(interval(1.0,2.0), interval(1.5,2.5)) === Overlap.overlaps - @test overlap(interval(1.0,2.0), interval(1.0,Inf)) === Overlap.starts - @test overlap(interval(1.0,2.0), interval(1.0,3.0)) === Overlap.starts - @test overlap(interval(1.0,1.0), interval(1.0,3.0)) === Overlap.starts - @test overlap(interval(1.0,2.0), entireinterval()) === Overlap.contained_by - @test overlap(interval(1.0,2.0), interval(-Inf,3.0)) === Overlap.contained_by - @test overlap(interval(1.0,2.0), interval(0.0,3.0)) === Overlap.contained_by - @test overlap(interval(2.0,2.0), interval(0.0,3.0)) === Overlap.contained_by - @test overlap(interval(2.0,2.0), interval(0.0,Inf)) === Overlap.contained_by - @test overlap(interval(1.0,2.0), interval(-Inf,2.0)) === Overlap.finishes - @test overlap(interval(1.0,2.0), interval(0.0,2.0)) === Overlap.finishes - @test overlap(interval(2.0,2.0), interval(0.0,2.0)) === Overlap.finishes - @test overlap(interval(1.0,2.0), interval(1.0,2.0)) === Overlap.equals - @test overlap(interval(1.0,1.0), interval(1.0,1.0)) === Overlap.equals - @test overlap(interval(-Inf,1.0), interval(-Inf,1.0)) === Overlap.equals - @test overlap(entireinterval(), entireinterval()) === Overlap.equals - @test overlap(interval(3.0,4.0), interval(2.0,2.0)) === Overlap.after - @test overlap(interval(3.0,4.0), interval(1.0,2.0)) === Overlap.after - @test overlap(interval(3.0,3.0), interval(1.0,2.0)) === Overlap.after - @test overlap(interval(3.0,3.0), interval(2.0,2.0)) === Overlap.after - @test overlap(interval(3.0,Inf), interval(2.0,2.0)) === Overlap.after - @test overlap(interval(2.0,3.0), interval(1.0,2.0)) === Overlap.met_by - @test overlap(interval(2.0,3.0), interval(-Inf,2.0)) === Overlap.met_by - @test overlap(interval(1.5,2.5), interval(1.0,2.0)) === Overlap.overlapped_by - @test overlap(interval(1.5,2.5), interval(-Inf,2.0)) === Overlap.overlapped_by - @test overlap(interval(1.0,Inf), interval(1.0,2.0)) === Overlap.started_by - @test overlap(interval(1.0,3.0), interval(1.0,2.0)) === Overlap.started_by - @test overlap(interval(1.0,3.0), interval(1.0,1.0)) === Overlap.started_by - @test overlap(interval(-Inf,3.0), interval(1.0,2.0)) === Overlap.contains - @test overlap(entireinterval(), interval(1.0,2.0)) === Overlap.contains - @test overlap(interval(0.0,3.0), interval(1.0,2.0)) === Overlap.contains - @test overlap(interval(0.0,3.0), interval(2.0,2.0)) === Overlap.contains - @test overlap(interval(-Inf,2.0), interval(1.0,2.0)) === Overlap.finished_by - @test overlap(interval(0.0,2.0), interval(1.0,2.0)) === Overlap.finished_by - @test overlap(interval(0.0,2.0), interval(2.0,2.0)) === Overlap.finished_by + @test overlap(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === Overlap.both_empty + @test overlap(emptyinterval(BareInterval{Float64}), bareinterval(1.0,2.0)) === Overlap.first_empty + @test overlap(bareinterval(1.0,2.0), emptyinterval(BareInterval{Float64})) === Overlap.second_empty + @test overlap(bareinterval(-Inf,2.0), bareinterval(3.0,Inf)) === Overlap.before + @test overlap(bareinterval(-Inf,2.0), bareinterval(3.0,4.0)) === Overlap.before + @test overlap(bareinterval(2.0,2.0), bareinterval(3.0,4.0)) === Overlap.before + @test overlap(bareinterval(1.0,2.0), bareinterval(3.0,4.0)) === Overlap.before + @test overlap(bareinterval(1.0,2.0), bareinterval(3.0,3.0)) === Overlap.before + @test overlap(bareinterval(2.0,2.0), bareinterval(3.0,3.0)) === Overlap.before + @test overlap(bareinterval(2.0,2.0), bareinterval(3.0,Inf)) === Overlap.before + @test overlap(bareinterval(-Inf,2.0), bareinterval(2.0,3.0)) === Overlap.meets + @test overlap(bareinterval(1.0,2.0), bareinterval(2.0,3.0)) === Overlap.meets + @test overlap(bareinterval(1.0,2.0), bareinterval(2.0,Inf)) === Overlap.meets + @test overlap(bareinterval(1.0,2.0), bareinterval(1.5,2.5)) === Overlap.overlaps + @test overlap(bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === Overlap.starts + @test overlap(bareinterval(1.0,2.0), bareinterval(1.0,3.0)) === Overlap.starts + @test overlap(bareinterval(1.0,1.0), bareinterval(1.0,3.0)) === Overlap.starts + @test overlap(bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === Overlap.contained_by + @test overlap(bareinterval(1.0,2.0), bareinterval(-Inf,3.0)) === Overlap.contained_by + @test overlap(bareinterval(1.0,2.0), bareinterval(0.0,3.0)) === Overlap.contained_by + @test overlap(bareinterval(2.0,2.0), bareinterval(0.0,3.0)) === Overlap.contained_by + @test overlap(bareinterval(2.0,2.0), bareinterval(0.0,Inf)) === Overlap.contained_by + @test overlap(bareinterval(1.0,2.0), bareinterval(-Inf,2.0)) === Overlap.finishes + @test overlap(bareinterval(1.0,2.0), bareinterval(0.0,2.0)) === Overlap.finishes + @test overlap(bareinterval(2.0,2.0), bareinterval(0.0,2.0)) === Overlap.finishes + @test overlap(bareinterval(1.0,2.0), bareinterval(1.0,2.0)) === Overlap.equals + @test overlap(bareinterval(1.0,1.0), bareinterval(1.0,1.0)) === Overlap.equals + @test overlap(bareinterval(-Inf,1.0), bareinterval(-Inf,1.0)) === Overlap.equals + @test overlap(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === Overlap.equals + @test overlap(bareinterval(3.0,4.0), bareinterval(2.0,2.0)) === Overlap.after + @test overlap(bareinterval(3.0,4.0), bareinterval(1.0,2.0)) === Overlap.after + @test overlap(bareinterval(3.0,3.0), bareinterval(1.0,2.0)) === Overlap.after + @test overlap(bareinterval(3.0,3.0), bareinterval(2.0,2.0)) === Overlap.after + @test overlap(bareinterval(3.0,Inf), bareinterval(2.0,2.0)) === Overlap.after + @test overlap(bareinterval(2.0,3.0), bareinterval(1.0,2.0)) === Overlap.met_by + @test overlap(bareinterval(2.0,3.0), bareinterval(-Inf,2.0)) === Overlap.met_by + @test overlap(bareinterval(1.5,2.5), bareinterval(1.0,2.0)) === Overlap.overlapped_by + @test overlap(bareinterval(1.5,2.5), bareinterval(-Inf,2.0)) === Overlap.overlapped_by + @test overlap(bareinterval(1.0,Inf), bareinterval(1.0,2.0)) === Overlap.started_by + @test overlap(bareinterval(1.0,3.0), bareinterval(1.0,2.0)) === Overlap.started_by + @test overlap(bareinterval(1.0,3.0), bareinterval(1.0,1.0)) === Overlap.started_by + @test overlap(bareinterval(-Inf,3.0), bareinterval(1.0,2.0)) === Overlap.contains + @test overlap(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0)) === Overlap.contains + @test overlap(bareinterval(0.0,3.0), bareinterval(1.0,2.0)) === Overlap.contains + @test overlap(bareinterval(0.0,3.0), bareinterval(2.0,2.0)) === Overlap.contains + @test overlap(bareinterval(-Inf,2.0), bareinterval(1.0,2.0)) === Overlap.finished_by + @test overlap(bareinterval(0.0,2.0), bareinterval(1.0,2.0)) === Overlap.finished_by + @test overlap(bareinterval(0.0,2.0), bareinterval(2.0,2.0)) === Overlap.finished_by end @testset "minimal_overlap_dec_test" begin - @test overlap(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)) === Overlap.both_empty - @test overlap(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,2.0), com)) === Overlap.first_empty - @test overlap(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(emptyinterval(), trv)) === Overlap.second_empty - @test overlap(DecoratedInterval(interval(2.0,2.0), def), DecoratedInterval(interval(3.0,4.0), def)) === Overlap.before - @test overlap(DecoratedInterval(interval(1.0,2.0), dac), DecoratedInterval(interval(3.0,4.0), com)) === Overlap.before - @test overlap(DecoratedInterval(interval(1.0,2.0), com), DecoratedInterval(interval(3.0,3.0), trv)) === Overlap.before - @test overlap(DecoratedInterval(interval(2.0,2.0), trv), DecoratedInterval(interval(3.0,3.0), def)) === Overlap.before - @test overlap(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(2.0,3.0), def)) === Overlap.meets - @test overlap(DecoratedInterval(interval(1.0,2.0), dac), DecoratedInterval(interval(1.5,2.5), def)) === Overlap.overlaps - @test overlap(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(1.0,3.0), com)) === Overlap.starts - @test overlap(DecoratedInterval(interval(1.0,1.0), trv), DecoratedInterval(interval(1.0,3.0), def)) === Overlap.starts - @test overlap(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(0.0,3.0), dac)) === Overlap.contained_by - @test overlap(DecoratedInterval(interval(2.0,2.0), trv), DecoratedInterval(interval(0.0,3.0), def)) === Overlap.contained_by - @test overlap(DecoratedInterval(interval(1.0,2.0), trv), DecoratedInterval(interval(0.0,2.0), com)) === Overlap.finishes - @test overlap(DecoratedInterval(interval(2.0,2.0), def), DecoratedInterval(interval(0.0,2.0), dac)) === Overlap.finishes - @test overlap(DecoratedInterval(interval(1.0,2.0), def), DecoratedInterval(interval(1.0,2.0), def)) === Overlap.equals - @test overlap(DecoratedInterval(interval(1.0,1.0), dac), DecoratedInterval(interval(1.0,1.0), dac)) === Overlap.equals - @test overlap(DecoratedInterval(interval(3.0,4.0), trv), DecoratedInterval(interval(2.0,2.0), trv)) === Overlap.after - @test overlap(DecoratedInterval(interval(3.0,4.0), def), DecoratedInterval(interval(1.0,2.0), def)) === Overlap.after - @test overlap(DecoratedInterval(interval(3.0,3.0), com), DecoratedInterval(interval(1.0,2.0), dac)) === Overlap.after - @test overlap(DecoratedInterval(interval(3.0,3.0), def), DecoratedInterval(interval(2.0,2.0), trv)) === Overlap.after - @test overlap(DecoratedInterval(interval(2.0,3.0), def), DecoratedInterval(interval(1.0,2.0), trv)) === Overlap.met_by - @test overlap(DecoratedInterval(interval(1.5,2.5), com), DecoratedInterval(interval(1.0,2.0), com)) === Overlap.overlapped_by - @test overlap(DecoratedInterval(interval(1.0,3.0), dac), DecoratedInterval(interval(1.0,2.0), def)) === Overlap.started_by - @test overlap(DecoratedInterval(interval(1.0,3.0), com), DecoratedInterval(interval(1.0,1.0), dac)) === Overlap.started_by - @test overlap(DecoratedInterval(interval(0.0,3.0), com), DecoratedInterval(interval(1.0,2.0), dac)) === Overlap.contains - @test overlap(DecoratedInterval(interval(0.0,3.0), com), DecoratedInterval(interval(2.0,2.0), def)) === Overlap.contains - @test overlap(DecoratedInterval(interval(0.0,2.0), def), DecoratedInterval(interval(1.0,2.0), trv)) === Overlap.finished_by - @test overlap(DecoratedInterval(interval(0.0,2.0), dac), DecoratedInterval(interval(2.0,2.0), def)) === Overlap.finished_by + @test overlap(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) === Overlap.both_empty + @test overlap(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) === Overlap.first_empty + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) === Overlap.second_empty + @test overlap(Interval(bareinterval(2.0,2.0), IntervalArithmetic.def), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)) === Overlap.before + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.dac), Interval(bareinterval(3.0,4.0), IntervalArithmetic.com)) === Overlap.before + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.com), Interval(bareinterval(3.0,3.0), IntervalArithmetic.trv)) === Overlap.before + @test overlap(Interval(bareinterval(2.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(3.0,3.0), IntervalArithmetic.def)) === Overlap.before + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(2.0,3.0), IntervalArithmetic.def)) === Overlap.meets + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.dac), Interval(bareinterval(1.5,2.5), IntervalArithmetic.def)) === Overlap.overlaps + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(1.0,3.0), IntervalArithmetic.com)) === Overlap.starts + @test overlap(Interval(bareinterval(1.0,1.0), IntervalArithmetic.trv), Interval(bareinterval(1.0,3.0), IntervalArithmetic.def)) === Overlap.starts + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(0.0,3.0), IntervalArithmetic.dac)) === Overlap.contained_by + @test overlap(Interval(bareinterval(2.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,3.0), IntervalArithmetic.def)) === Overlap.contained_by + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv), Interval(bareinterval(0.0,2.0), IntervalArithmetic.com)) === Overlap.finishes + @test overlap(Interval(bareinterval(2.0,2.0), IntervalArithmetic.def), Interval(bareinterval(0.0,2.0), IntervalArithmetic.dac)) === Overlap.finishes + @test overlap(Interval(bareinterval(1.0,2.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) === Overlap.equals + @test overlap(Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac)) === Overlap.equals + @test overlap(Interval(bareinterval(3.0,4.0), IntervalArithmetic.trv), Interval(bareinterval(2.0,2.0), IntervalArithmetic.trv)) === Overlap.after + @test overlap(Interval(bareinterval(3.0,4.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) === Overlap.after + @test overlap(Interval(bareinterval(3.0,3.0), IntervalArithmetic.com), Interval(bareinterval(1.0,2.0), IntervalArithmetic.dac)) === Overlap.after + @test overlap(Interval(bareinterval(3.0,3.0), IntervalArithmetic.def), Interval(bareinterval(2.0,2.0), IntervalArithmetic.trv)) === Overlap.after + @test overlap(Interval(bareinterval(2.0,3.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) === Overlap.met_by + @test overlap(Interval(bareinterval(1.5,2.5), IntervalArithmetic.com), Interval(bareinterval(1.0,2.0), IntervalArithmetic.com)) === Overlap.overlapped_by + @test overlap(Interval(bareinterval(1.0,3.0), IntervalArithmetic.dac), Interval(bareinterval(1.0,2.0), IntervalArithmetic.def)) === Overlap.started_by + @test overlap(Interval(bareinterval(1.0,3.0), IntervalArithmetic.com), Interval(bareinterval(1.0,1.0), IntervalArithmetic.dac)) === Overlap.started_by + @test overlap(Interval(bareinterval(0.0,3.0), IntervalArithmetic.com), Interval(bareinterval(1.0,2.0), IntervalArithmetic.dac)) === Overlap.contains + @test overlap(Interval(bareinterval(0.0,3.0), IntervalArithmetic.com), Interval(bareinterval(2.0,2.0), IntervalArithmetic.def)) === Overlap.contains + @test overlap(Interval(bareinterval(0.0,2.0), IntervalArithmetic.def), Interval(bareinterval(1.0,2.0), IntervalArithmetic.trv)) === Overlap.finished_by + @test overlap(Interval(bareinterval(0.0,2.0), IntervalArithmetic.dac), Interval(bareinterval(2.0,2.0), IntervalArithmetic.def)) === Overlap.finished_by end - diff --git a/test/test_ITF1788/libieeep1788_rec_bool.jl b/test/test_ITF1788/libieeep1788_rec_bool.jl index 9d3349580..f539db58b 100644 --- a/test/test_ITF1788/libieeep1788_rec_bool.jl +++ b/test/test_ITF1788/libieeep1788_rec_bool.jl @@ -16,9 +16,9 @@ @test iscommon(interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023)) == true - @test iscommon(entireinterval()) == false + @test iscommon(entireinterval(BareInterval{Float64})) == false - @test iscommon(emptyinterval()) == false + @test iscommon(emptyinterval(BareInterval{Float64})) == false @test iscommon(interval(-Inf, 0.0)) == false @@ -28,47 +28,47 @@ end @testset "minimal_is_common_interval_dec_test" begin - @test iscommon(DecoratedInterval(interval(-27.0,-27.0), com)) == true + @test iscommon(Interval(interval(-27.0,-27.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(-27.0, 0.0), com)) == true + @test iscommon(Interval(interval(-27.0, 0.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(0.0,0.0), com)) == true + @test iscommon(Interval(interval(0.0,0.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(-0.0,-0.0), com)) == true + @test iscommon(Interval(interval(-0.0,-0.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(-0.0,0.0), com)) == true + @test iscommon(Interval(interval(-0.0,0.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(0.0,-0.0), com)) == true + @test iscommon(Interval(interval(0.0,-0.0), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(5.0, 12.4), com)) == true + @test iscommon(Interval(interval(5.0, 12.4), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), com)) == true + @test iscommon(Interval(interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com)) == true - @test iscommon(DecoratedInterval(interval(-27.0,-27.0), trv)) == true + @test iscommon(Interval(interval(-27.0,-27.0), IntervalArithmetic.trv)) == true - @test iscommon(DecoratedInterval(interval(-27.0, 0.0), def)) == true + @test iscommon(Interval(interval(-27.0, 0.0), IntervalArithmetic.def)) == true - @test iscommon(DecoratedInterval(interval(0.0,0.0), dac)) == true + @test iscommon(Interval(interval(0.0,0.0), IntervalArithmetic.dac)) == true - @test iscommon(DecoratedInterval(interval(-0.0,-0.0), trv)) == true + @test iscommon(Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) == true - @test iscommon(DecoratedInterval(interval(-0.0,0.0), def)) == true + @test iscommon(Interval(interval(-0.0,0.0), IntervalArithmetic.def)) == true - @test iscommon(DecoratedInterval(interval(0.0,-0.0), dac)) == true + @test iscommon(Interval(interval(0.0,-0.0), IntervalArithmetic.dac)) == true - @test iscommon(DecoratedInterval(interval(5.0, 12.4), def)) == true + @test iscommon(Interval(interval(5.0, 12.4), IntervalArithmetic.def)) == true - @test iscommon(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), trv)) == true + @test iscommon(Interval(interval(-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.trv)) == true - @test iscommon(DecoratedInterval(entireinterval(), dac)) == false + @test iscommon(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) == false @test iscommon(nai()) == false - @test iscommon(DecoratedInterval(emptyinterval(), trv)) == false + @test iscommon(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test iscommon(DecoratedInterval(interval(-Inf, 0.0), trv)) == false + @test iscommon(Interval(interval(-Inf, 0.0), IntervalArithmetic.trv)) == false - @test iscommon(DecoratedInterval(interval(0.0, Inf), def)) == false + @test iscommon(Interval(interval(0.0, Inf), IntervalArithmetic.def)) == false end @@ -90,9 +90,9 @@ end @test isthin(interval(0.0, -0.0)) == true - @test isthin(emptyinterval()) == false + @test isthin(emptyinterval(BareInterval{Float64})) == false - @test isthin(entireinterval()) == false + @test isthin(entireinterval(BareInterval{Float64})) == false @test isthin(interval(-1.0, 0.0)) == false @@ -108,37 +108,37 @@ end @testset "minimal_is_singleton_dec_test" begin - @test isthin(DecoratedInterval(interval(-27.0,-27.0), def)) == true + @test isthin(Interval(interval(-27.0,-27.0), IntervalArithmetic.def)) == true - @test isthin(DecoratedInterval(interval(-2.0, -2.0), trv)) == true + @test isthin(Interval(interval(-2.0, -2.0), IntervalArithmetic.trv)) == true - @test isthin(DecoratedInterval(interval(12.0,12.0), dac)) == true + @test isthin(Interval(interval(12.0,12.0), IntervalArithmetic.dac)) == true - @test isthin(DecoratedInterval(interval(17.1, 17.1), com)) == true + @test isthin(Interval(interval(17.1, 17.1), IntervalArithmetic.com)) == true - @test isthin(DecoratedInterval(interval(-0.0,-0.0), def)) == true + @test isthin(Interval(interval(-0.0,-0.0), IntervalArithmetic.def)) == true - @test isthin(DecoratedInterval(interval(0.0,0.0), com)) == true + @test isthin(Interval(interval(0.0,0.0), IntervalArithmetic.com)) == true - @test isthin(DecoratedInterval(interval(-0.0, 0.0), def)) == true + @test isthin(Interval(interval(-0.0, 0.0), IntervalArithmetic.def)) == true - @test isthin(DecoratedInterval(interval(0.0, -0.0), dac)) == true + @test isthin(Interval(interval(0.0, -0.0), IntervalArithmetic.dac)) == true - @test isthin(DecoratedInterval(emptyinterval(), trv)) == false + @test isthin(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test isthin(nai()) == false - @test isthin(DecoratedInterval(entireinterval(), def)) == false + @test isthin(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) == false - @test isthin(DecoratedInterval(interval(-1.0, 0.0), dac)) == false + @test isthin(Interval(interval(-1.0, 0.0), IntervalArithmetic.dac)) == false - @test isthin(DecoratedInterval(interval(-1.0, -0.5), com)) == false + @test isthin(Interval(interval(-1.0, -0.5), IntervalArithmetic.com)) == false - @test isthin(DecoratedInterval(interval(1.0, 2.0), def)) == false + @test isthin(Interval(interval(1.0, 2.0), IntervalArithmetic.def)) == false - @test isthin(DecoratedInterval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), dac)) == false + @test isthin(Interval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac)) == false - @test isthin(DecoratedInterval(interval(-1.0,Inf), trv)) == false + @test isthin(Interval(interval(-1.0,Inf), IntervalArithmetic.trv)) == false end @@ -168,21 +168,21 @@ end @test in_interval(12.4, interval(5.0, 12.4)) == true - @test in_interval(0.0, entireinterval()) == true + @test in_interval(0.0, entireinterval(BareInterval{Float64})) == true - @test in_interval(5.0, entireinterval()) == true + @test in_interval(5.0, entireinterval(BareInterval{Float64})) == true - @test in_interval(6.3, entireinterval()) == true + @test in_interval(6.3, entireinterval(BareInterval{Float64})) == true - @test in_interval(12.4, entireinterval()) == true + @test in_interval(12.4, entireinterval(BareInterval{Float64})) == true - @test in_interval(0x1.FFFFFFFFFFFFFp1023, entireinterval()) == true + @test in_interval(0x1.FFFFFFFFFFFFFp1023, entireinterval(BareInterval{Float64})) == true - @test in_interval(-0x1.FFFFFFFFFFFFFp1023, entireinterval()) == true + @test in_interval(-0x1.FFFFFFFFFFFFFp1023, entireinterval(BareInterval{Float64})) == true - @test in_interval(0x1.0p-1022, entireinterval()) == true + @test in_interval(0x1.0p-1022, entireinterval(BareInterval{Float64})) == true - @test in_interval(-0x1.0p-1022, entireinterval()) == true + @test in_interval(-0x1.0p-1022, entireinterval(BareInterval{Float64})) == true @test in_interval(-71.0, interval(-27.0, 0.0)) == false @@ -198,104 +198,104 @@ end @test in_interval(-6.3, interval(5.0, 12.4)) == false - @test in_interval(0.0, emptyinterval()) == false + @test in_interval(0.0, emptyinterval(BareInterval{Float64})) == false - @test in_interval(-4535.3, emptyinterval()) == false + @test in_interval(-4535.3, emptyinterval(BareInterval{Float64})) == false - @test in_interval(-Inf, emptyinterval()) == false + @test in_interval(-Inf, emptyinterval(BareInterval{Float64})) == false - @test in_interval(Inf, emptyinterval()) == false + @test in_interval(Inf, emptyinterval(BareInterval{Float64})) == false - @test in_interval(NaN, emptyinterval()) == false + @test in_interval(NaN, emptyinterval(BareInterval{Float64})) == false - @test in_interval(-Inf, entireinterval()) == false + @test in_interval(-Inf, entireinterval(BareInterval{Float64})) == false - @test in_interval(Inf, entireinterval()) == false + @test in_interval(Inf, entireinterval(BareInterval{Float64})) == false - @test in_interval(NaN, entireinterval()) == false + @test in_interval(NaN, entireinterval(BareInterval{Float64})) == false end @testset "minimal_is_member_dec_test" begin - @test in_interval(-27.0, DecoratedInterval(interval(-27.0,-27.0), trv)) == true + @test in_interval(-27.0, Interval(interval(-27.0,-27.0), IntervalArithmetic.trv)) == true - @test in_interval(-27.0, DecoratedInterval(interval(-27.0, 0.0), def)) == true + @test in_interval(-27.0, Interval(interval(-27.0, 0.0), IntervalArithmetic.def)) == true - @test in_interval(-7.0, DecoratedInterval(interval(-27.0, 0.0), dac)) == true + @test in_interval(-7.0, Interval(interval(-27.0, 0.0), IntervalArithmetic.dac)) == true - @test in_interval(0.0, DecoratedInterval(interval(-27.0, 0.0), com)) == true + @test in_interval(0.0, Interval(interval(-27.0, 0.0), IntervalArithmetic.com)) == true - @test in_interval(-0.0, DecoratedInterval(interval(0.0,0.0), trv)) == true + @test in_interval(-0.0, Interval(interval(0.0,0.0), IntervalArithmetic.trv)) == true - @test in_interval(0.0, DecoratedInterval(interval(0.0,0.0), def)) == true + @test in_interval(0.0, Interval(interval(0.0,0.0), IntervalArithmetic.def)) == true - @test in_interval(0.0, DecoratedInterval(interval(-0.0,-0.0), dac)) == true + @test in_interval(0.0, Interval(interval(-0.0,-0.0), IntervalArithmetic.dac)) == true - @test in_interval(0.0, DecoratedInterval(interval(-0.0,0.0), com)) == true + @test in_interval(0.0, Interval(interval(-0.0,0.0), IntervalArithmetic.com)) == true - @test in_interval(0.0, DecoratedInterval(interval(0.0,-0.0), trv)) == true + @test in_interval(0.0, Interval(interval(0.0,-0.0), IntervalArithmetic.trv)) == true - @test in_interval(5.0, DecoratedInterval(interval(5.0, 12.4), def)) == true + @test in_interval(5.0, Interval(interval(5.0, 12.4), IntervalArithmetic.def)) == true - @test in_interval(6.3, DecoratedInterval(interval(5.0, 12.4), dac)) == true + @test in_interval(6.3, Interval(interval(5.0, 12.4), IntervalArithmetic.dac)) == true - @test in_interval(12.4, DecoratedInterval(interval(5.0, 12.4), com)) == true + @test in_interval(12.4, Interval(interval(5.0, 12.4), IntervalArithmetic.com)) == true - @test in_interval(0.0, DecoratedInterval(entireinterval(), trv)) == true + @test in_interval(0.0, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test in_interval(5.0, DecoratedInterval(entireinterval(), def)) == true + @test in_interval(5.0, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) == true - @test in_interval(6.3, DecoratedInterval(entireinterval(), dac)) == true + @test in_interval(6.3, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) == true - @test in_interval(12.4, DecoratedInterval(entireinterval(), trv)) == true + @test in_interval(12.4, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test in_interval(0x1.FFFFFFFFFFFFFp1023, DecoratedInterval(entireinterval(), def)) == true + @test in_interval(0x1.FFFFFFFFFFFFFp1023, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) == true - @test in_interval(-0x1.FFFFFFFFFFFFFp1023, DecoratedInterval(entireinterval(), dac)) == true + @test in_interval(-0x1.FFFFFFFFFFFFFp1023, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) == true - @test in_interval(0x1.0p-1022, DecoratedInterval(entireinterval(), trv)) == true + @test in_interval(0x1.0p-1022, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == true - @test in_interval(-0x1.0p-1022, DecoratedInterval(entireinterval(), def)) == true + @test in_interval(-0x1.0p-1022, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) == true - @test in_interval(-71.0, DecoratedInterval(interval(-27.0, 0.0), trv)) == false + @test in_interval(-71.0, Interval(interval(-27.0, 0.0), IntervalArithmetic.trv)) == false - @test in_interval(0.1, DecoratedInterval(interval(-27.0, 0.0), def)) == false + @test in_interval(0.1, Interval(interval(-27.0, 0.0), IntervalArithmetic.def)) == false - @test in_interval(-0.01, DecoratedInterval(interval(0.0,0.0), dac)) == false + @test in_interval(-0.01, Interval(interval(0.0,0.0), IntervalArithmetic.dac)) == false - @test in_interval(0.000001, DecoratedInterval(interval(0.0,0.0), com)) == false + @test in_interval(0.000001, Interval(interval(0.0,0.0), IntervalArithmetic.com)) == false - @test in_interval(111110.0, DecoratedInterval(interval(-0.0,-0.0), trv)) == false + @test in_interval(111110.0, Interval(interval(-0.0,-0.0), IntervalArithmetic.trv)) == false - @test in_interval(4.9, DecoratedInterval(interval(5.0, 12.4), def)) == false + @test in_interval(4.9, Interval(interval(5.0, 12.4), IntervalArithmetic.def)) == false - @test in_interval(-6.3, DecoratedInterval(interval(5.0, 12.4), dac)) == false + @test in_interval(-6.3, Interval(interval(5.0, 12.4), IntervalArithmetic.dac)) == false - @test in_interval(0.0, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(0.0, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test in_interval(0.0, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(0.0, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test in_interval(-4535.3, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(-4535.3, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test in_interval(-4535.3, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(-4535.3, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test in_interval(-Inf, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(-Inf, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test in_interval(-Inf, nai()) == false - @test in_interval(Inf, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(Inf, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test in_interval(Inf, nai()) == false - @test in_interval(NaN, DecoratedInterval(emptyinterval(), trv)) == false + @test in_interval(NaN, Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false @test in_interval(NaN, nai()) == false - @test in_interval(-Inf, DecoratedInterval(entireinterval(), trv)) == false + @test in_interval(-Inf, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) == false - @test in_interval(Inf, DecoratedInterval(entireinterval(), def)) == false + @test in_interval(Inf, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def)) == false - @test in_interval(NaN, DecoratedInterval(entireinterval(), dac)) == false + @test in_interval(NaN, Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)) == false end diff --git a/test/test_ITF1788/libieeep1788_reduction.jl b/test/test_ITF1788/libieeep1788_reduction.jl index e8ff50ff6..f15e3f3bd 100755 --- a/test/test_ITF1788/libieeep1788_reduction.jl +++ b/test/test_ITF1788/libieeep1788_reduction.jl @@ -30,17 +30,16 @@ end @testset "minimal_dot_test" begin - @test dot([1.0, 2.0, 3.0], [1.0, 2.0, 3.0]) === 14.0 + @test sum([1.0, 2.0, 3.0] .* [1.0, 2.0, 3.0]) === 14.0 - @test_broken dot([0x10000000000001p0, 0x1p104], [0x0fffffffffffffp0, -1.0]) === -1.0 + @test_broken sum([0x10000000000001p0, 0x1p104] .* [0x0fffffffffffffp0, -1.0]) === -1.0 - @test isnan(dot([1.0, 2.0, NaN, 3.0], [1.0, 2.0, 3.0, 4.0])) + @test isnan(sum([1.0, 2.0, NaN, 3.0] .* [1.0, 2.0, 3.0, 4.0])) - @test isnan(dot([1.0, 2.0, 3.0, 4.0], [1.0, 2.0, NaN, 3.0])) + @test isnan(sum([1.0, 2.0, 3.0, 4.0] .* [1.0, 2.0, NaN, 3.0])) - @test isnan(dot([1.0, 2.0, 0.0, 4.0], [1.0, 2.0, Inf, 3.0])) + @test isnan(sum([1.0, 2.0, 0.0, 4.0] .* [1.0, 2.0, Inf, 3.0])) - @test isnan(dot([1.0, 2.0, -Inf, 4.0], [1.0, 2.0, 0.0, 3.0])) + @test isnan(sum([1.0, 2.0, -Inf, 4.0] .* [1.0, 2.0, 0.0, 3.0])) end - diff --git a/test/test_ITF1788/libieeep1788_rev.jl b/test/test_ITF1788/libieeep1788_rev.jl index 2e63d2fdb..d49a442e5 100644 --- a/test/test_ITF1788/libieeep1788_rev.jl +++ b/test/test_ITF1788/libieeep1788_rev.jl @@ -1,948 +1,948 @@ @testset "minimal_sqr_rev_test" begin - @test isequal_interval(sqr_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(sqr_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqr_rev(interval(-10.0,-1.0))[2], emptyinterval()) + @test isequal_interval(sqr_rev(bareinterval(-10.0,-1.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqr_rev(interval(0.0,Inf))[2], entireinterval()) + @test isequal_interval(sqr_rev(bareinterval(0.0,Inf))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(sqr_rev(interval(0.0,1.0))[2], interval(-1.0,1.0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,1.0))[2], bareinterval(-1.0,1.0)) - @test isequal_interval(sqr_rev(interval(-0.5,1.0))[2], interval(-1.0,1.0)) + @test isequal_interval(sqr_rev(bareinterval(-0.5,1.0))[2], bareinterval(-1.0,1.0)) - @test isequal_interval(sqr_rev(interval(-1000.0,1.0))[2], interval(-1.0,1.0)) + @test isequal_interval(sqr_rev(bareinterval(-1000.0,1.0))[2], bareinterval(-1.0,1.0)) - @test isequal_interval(sqr_rev(interval(0.0,25.0))[2], interval(-5.0,5.0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,25.0))[2], bareinterval(-5.0,5.0)) - @test isequal_interval(sqr_rev(interval(-1.0,25.0))[2], interval(-5.0,5.0)) + @test isequal_interval(sqr_rev(bareinterval(-1.0,25.0))[2], bareinterval(-5.0,5.0)) - @test isequal_interval(sqr_rev(interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7))[2], interval(-0x1.999999999999BP-4,0x1.999999999999BP-4)) + @test isequal_interval(sqr_rev(bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7))[2], bareinterval(-0x1.999999999999BP-4,0x1.999999999999BP-4)) - @test isequal_interval(sqr_rev(interval(0.0,0x1.FFFFFFFFFFFE1P+1))[2], interval(-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,0x1.FFFFFFFFFFFE1P+1))[2], bareinterval(-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0)) end @testset "minimal_sqr_rev_bin_test" begin - @test isequal_interval(sqr_rev(emptyinterval(), interval(-5.0,1.0))[2], emptyinterval()) + @test isequal_interval(sqr_rev(emptyinterval(BareInterval{Float64}), bareinterval(-5.0,1.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqr_rev(interval(-10.0,-1.0), interval(-5.0,1.0))[2], emptyinterval()) + @test isequal_interval(sqr_rev(bareinterval(-10.0,-1.0), bareinterval(-5.0,1.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sqr_rev(interval(0.0,Inf), interval(-5.0,1.0))[2], interval(-5.0,1.0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,Inf), bareinterval(-5.0,1.0))[2], bareinterval(-5.0,1.0)) - @test isequal_interval(sqr_rev(interval(0.0,1.0), interval(-0.1,1.0))[2], interval(-0.1,1.0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,1.0), bareinterval(-0.1,1.0))[2], bareinterval(-0.1,1.0)) - @test isequal_interval(sqr_rev(interval(-0.5,1.0), interval(-0.1,1.0))[2], interval(-0.1,1.0)) + @test isequal_interval(sqr_rev(bareinterval(-0.5,1.0), bareinterval(-0.1,1.0))[2], bareinterval(-0.1,1.0)) - @test isequal_interval(sqr_rev(interval(-1000.0,1.0), interval(-0.1,1.0))[2], interval(-0.1,1.0)) + @test isequal_interval(sqr_rev(bareinterval(-1000.0,1.0), bareinterval(-0.1,1.0))[2], bareinterval(-0.1,1.0)) - @test isequal_interval(sqr_rev(interval(0.0,25.0), interval(-4.1,6.0))[2], interval(-4.1,5.0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,25.0), bareinterval(-4.1,6.0))[2], bareinterval(-4.1,5.0)) - @test isequal_interval(sqr_rev(interval(-1.0,25.0), interval(-4.1,7.0))[2], interval(-4.1,5.0)) + @test isequal_interval(sqr_rev(bareinterval(-1.0,25.0), bareinterval(-4.1,7.0))[2], bareinterval(-4.1,5.0)) - @test isequal_interval(sqr_rev(interval(1.0,25.0), interval(0.0,7.0))[2], interval(1.0,5.0)) + @test isequal_interval(sqr_rev(bareinterval(1.0,25.0), bareinterval(0.0,7.0))[2], bareinterval(1.0,5.0)) - @test isequal_interval(sqr_rev(interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), interval(-0.1,Inf))[2], interval(-0.1,0x1.999999999999BP-4)) + @test isequal_interval(sqr_rev(bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), bareinterval(-0.1,Inf))[2], bareinterval(-0.1,0x1.999999999999BP-4)) - @test isequal_interval(sqr_rev(interval(0.0,0x1.FFFFFFFFFFFE1P+1), interval(-0.1,Inf))[2], interval(-0.1,0x1.ffffffffffff1p+0)) + @test isequal_interval(sqr_rev(bareinterval(0.0,0x1.FFFFFFFFFFFE1P+1), bareinterval(-0.1,Inf))[2], bareinterval(-0.1,0x1.ffffffffffff1p+0)) end @testset "minimal_sqr_rev_dec_test" begin - @test isequal_interval(sqr_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sqr_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-10.0,-1.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-10.0,-1.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,Inf), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,1.0), def))[2], DecoratedInterval(interval(-1.0,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,1.0), IntervalArithmetic.def))[2], Interval(bareinterval(-1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-0.5,1.0), dac))[2], DecoratedInterval(interval(-1.0,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-0.5,1.0), IntervalArithmetic.dac))[2], Interval(bareinterval(-1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-1000.0,1.0), com))[2], DecoratedInterval(interval(-1.0,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-1000.0,1.0), IntervalArithmetic.com))[2], Interval(bareinterval(-1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,25.0), def))[2], DecoratedInterval(interval(-5.0,5.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,25.0), IntervalArithmetic.def))[2], Interval(bareinterval(-5.0,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-1.0,25.0), dac))[2], DecoratedInterval(interval(-5.0,5.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-1.0,25.0), IntervalArithmetic.dac))[2], Interval(bareinterval(-5.0,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), com))[2], DecoratedInterval(interval(-0x1.999999999999BP-4,0x1.999999999999BP-4), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), IntervalArithmetic.com))[2], Interval(bareinterval(-0x1.999999999999BP-4,0x1.999999999999BP-4), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,0x1.FFFFFFFFFFFE1P+1), def))[2], DecoratedInterval(interval(-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,0x1.FFFFFFFFFFFE1P+1), IntervalArithmetic.def))[2], Interval(bareinterval(-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0), IntervalArithmetic.trv)) end @testset "minimal_sqr_rev_dec_bin_test" begin - @test isequal_interval(sqr_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-5.0,1.0), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sqr_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-10.0,-1.0), com), DecoratedInterval(interval(-5.0,1.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-10.0,-1.0), IntervalArithmetic.com), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,Inf), def), DecoratedInterval(interval(-5.0,1.0), dac))[2], DecoratedInterval(interval(-5.0,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-5.0,1.0), IntervalArithmetic.dac))[2], Interval(bareinterval(-5.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,1.0), dac), DecoratedInterval(interval(-0.1,1.0), def))[2], DecoratedInterval(interval(-0.1,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,1.0), IntervalArithmetic.dac), Interval(bareinterval(-0.1,1.0), IntervalArithmetic.def))[2], Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-0.5,1.0), def), DecoratedInterval(interval(-0.1,1.0), dac))[2], DecoratedInterval(interval(-0.1,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-0.5,1.0), IntervalArithmetic.def), Interval(bareinterval(-0.1,1.0), IntervalArithmetic.dac))[2], Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-1000.0,1.0), com), DecoratedInterval(interval(-0.1,1.0), def))[2], DecoratedInterval(interval(-0.1,1.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-1000.0,1.0), IntervalArithmetic.com), Interval(bareinterval(-0.1,1.0), IntervalArithmetic.def))[2], Interval(bareinterval(-0.1,1.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,25.0), def), DecoratedInterval(interval(-4.1,6.0), com))[2], DecoratedInterval(interval(-4.1,5.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,25.0), IntervalArithmetic.def), Interval(bareinterval(-4.1,6.0), IntervalArithmetic.com))[2], Interval(bareinterval(-4.1,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(-1.0,25.0), dac), DecoratedInterval(interval(-4.1,7.0), def))[2], DecoratedInterval(interval(-4.1,5.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(-1.0,25.0), IntervalArithmetic.dac), Interval(bareinterval(-4.1,7.0), IntervalArithmetic.def))[2], Interval(bareinterval(-4.1,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(1.0,25.0), dac), DecoratedInterval(interval(0.0,7.0), def))[2], DecoratedInterval(interval(1.0,5.0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(1.0,25.0), IntervalArithmetic.dac), Interval(bareinterval(0.0,7.0), IntervalArithmetic.def))[2], Interval(bareinterval(1.0,5.0), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), def), DecoratedInterval(interval(-0.1,Inf), dac))[2], DecoratedInterval(interval(-0.1,0x1.999999999999BP-4), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0x1.47AE147AE147BP-7,0x1.47AE147AE147CP-7), IntervalArithmetic.def), Interval(bareinterval(-0.1,Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(-0.1,0x1.999999999999BP-4), IntervalArithmetic.trv)) - @test isequal_interval(sqr_rev(DecoratedInterval(interval(0.0,0x1.FFFFFFFFFFFE1P+1), dac), DecoratedInterval(interval(-0.1,Inf), dac))[2], DecoratedInterval(interval(-0.1,0x1.ffffffffffff1p+0), trv)) + @test isequal_interval(sqr_rev(Interval(bareinterval(0.0,0x1.FFFFFFFFFFFE1P+1), IntervalArithmetic.dac), Interval(bareinterval(-0.1,Inf), IntervalArithmetic.dac))[2], Interval(bareinterval(-0.1,0x1.ffffffffffff1p+0), IntervalArithmetic.trv)) end @testset "minimal_abs_rev_test" begin - @test isequal_interval(abs_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(abs_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-1.1,-0.4))[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-1.1,-0.4))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(0.0,Inf))[2], entireinterval()) + @test isequal_interval(abs_rev(bareinterval(0.0,Inf))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(1.1,2.1))[2], interval(-2.1,2.1)) + @test isequal_interval(abs_rev(bareinterval(1.1,2.1))[2], bareinterval(-2.1,2.1)) - @test isequal_interval(abs_rev(interval(-1.1,2.0))[2], interval(-2.0,2.0)) + @test isequal_interval(abs_rev(bareinterval(-1.1,2.0))[2], bareinterval(-2.0,2.0)) - @test isequal_interval(abs_rev(interval(-1.1,0.0))[2], interval(0.0,0.0)) + @test isequal_interval(abs_rev(bareinterval(-1.1,0.0))[2], bareinterval(0.0,0.0)) - @test isequal_interval(abs_rev(interval(-1.9,0.2))[2], interval(-0.2,0.2)) + @test isequal_interval(abs_rev(bareinterval(-1.9,0.2))[2], bareinterval(-0.2,0.2)) - @test isequal_interval(abs_rev(interval(0.0,0.2))[2], interval(-0.2,0.2)) + @test isequal_interval(abs_rev(bareinterval(0.0,0.2))[2], bareinterval(-0.2,0.2)) - @test isequal_interval(abs_rev(interval(-1.5,Inf))[2], entireinterval()) + @test isequal_interval(abs_rev(bareinterval(-1.5,Inf))[2], entireinterval(BareInterval{Float64})) end @testset "minimal_abs_rev_bin_test" begin - @test isequal_interval(abs_rev(emptyinterval(), interval(-1.1,5.0))[2], emptyinterval()) + @test isequal_interval(abs_rev(emptyinterval(BareInterval{Float64}), bareinterval(-1.1,5.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(-1.1,-0.4), interval(-1.1,5.0))[2], emptyinterval()) + @test isequal_interval(abs_rev(bareinterval(-1.1,-0.4), bareinterval(-1.1,5.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(abs_rev(interval(0.0,Inf), interval(-1.1,5.0))[2], interval(-1.1,5.0)) + @test isequal_interval(abs_rev(bareinterval(0.0,Inf), bareinterval(-1.1,5.0))[2], bareinterval(-1.1,5.0)) - @test isequal_interval(abs_rev(interval(1.1,2.1), interval(-1.0,5.0))[2], interval(1.1,2.1)) + @test isequal_interval(abs_rev(bareinterval(1.1,2.1), bareinterval(-1.0,5.0))[2], bareinterval(1.1,2.1)) - @test isequal_interval(abs_rev(interval(-1.1,2.0), interval(-1.1,5.0))[2], interval(-1.1,2.0)) + @test isequal_interval(abs_rev(bareinterval(-1.1,2.0), bareinterval(-1.1,5.0))[2], bareinterval(-1.1,2.0)) - @test isequal_interval(abs_rev(interval(-1.1,0.0), interval(-1.1,5.0))[2], interval(0.0,0.0)) + @test isequal_interval(abs_rev(bareinterval(-1.1,0.0), bareinterval(-1.1,5.0))[2], bareinterval(0.0,0.0)) - @test isequal_interval(abs_rev(interval(-1.9,0.2), interval(-1.1,5.0))[2], interval(-0.2,0.2)) + @test isequal_interval(abs_rev(bareinterval(-1.9,0.2), bareinterval(-1.1,5.0))[2], bareinterval(-0.2,0.2)) end @testset "minimal_abs_rev_dec_test" begin - @test isequal_interval(abs_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(abs_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,-0.4), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(0.0,Inf), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(1.1,2.1), com))[2], DecoratedInterval(interval(-2.1,2.1), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(1.1,2.1), IntervalArithmetic.com))[2], Interval(bareinterval(-2.1,2.1), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,2.0), def))[2], DecoratedInterval(interval(-2.0,2.0), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.def))[2], Interval(bareinterval(-2.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,0.0), dac))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.dac))[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.9,0.2), com))[2], DecoratedInterval(interval(-0.2,0.2), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.9,0.2), IntervalArithmetic.com))[2], Interval(bareinterval(-0.2,0.2), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(0.0,0.2), def))[2], DecoratedInterval(interval(-0.2,0.2), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(0.0,0.2), IntervalArithmetic.def))[2], Interval(bareinterval(-0.2,0.2), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.5,Inf), def))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.5,Inf), IntervalArithmetic.def))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_abs_rev_dec_bin_test" begin - @test isequal_interval(abs_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-1.1,5.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(abs_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,-0.4), dac), DecoratedInterval(interval(-1.1,5.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,-0.4), IntervalArithmetic.dac), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(0.0,Inf), def), DecoratedInterval(interval(-1.1,5.0), def))[2], DecoratedInterval(interval(-1.1,5.0), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.def))[2], Interval(bareinterval(-1.1,5.0), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(1.1,2.1), dac), DecoratedInterval(interval(-1.0,5.0), def))[2], DecoratedInterval(interval(1.1,2.1), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(1.1,2.1), IntervalArithmetic.dac), Interval(bareinterval(-1.0,5.0), IntervalArithmetic.def))[2], Interval(bareinterval(1.1,2.1), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,2.0), com), DecoratedInterval(interval(-1.1,5.0), def))[2], DecoratedInterval(interval(-1.1,2.0), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,2.0), IntervalArithmetic.com), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.def))[2], Interval(bareinterval(-1.1,2.0), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.1,0.0), def), DecoratedInterval(interval(-1.1,5.0), def))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.1,0.0), IntervalArithmetic.def), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.def))[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(abs_rev(DecoratedInterval(interval(-1.9,0.2), dac), DecoratedInterval(interval(-1.1,5.0), def))[2], DecoratedInterval(interval(-0.2,0.2), trv)) + @test isequal_interval(abs_rev(Interval(bareinterval(-1.9,0.2), IntervalArithmetic.dac), Interval(bareinterval(-1.1,5.0), IntervalArithmetic.def))[2], Interval(bareinterval(-0.2,0.2), IntervalArithmetic.trv)) end @testset "minimal_pown_rev_test" begin - @test isequal_interval(power_rev(emptyinterval(), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(1.0,1.0), 0)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(1.0,1.0), 0)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-1.0,5.0), 0)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(-1.0,5.0), 0)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-1.0,0.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-1.0,0.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-1.0,-0.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-1.0,-0.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(1.1,10.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(1.1,10.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(emptyinterval(), 1)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), 1)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), 1)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), 1)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), 1)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), 1)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), 1)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(13.1,13.1), 1)[2], interval(13.1,13.1)) + @test isequal_interval(power_rev(bareinterval(13.1,13.1), 1)[2], bareinterval(13.1,13.1)) - @test isequal_interval(power_rev(interval(-7451.145,-7451.145), 1)[2], interval(-7451.145,-7451.145)) + @test isequal_interval(power_rev(bareinterval(-7451.145,-7451.145), 1)[2], bareinterval(-7451.145,-7451.145)) - @test isequal_interval(power_rev(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 1)[2], interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(power_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 1)[2], bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(power_rev(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 1)[2], interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)) + @test isequal_interval(power_rev(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 1)[2], bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023)) - @test isequal_interval(power_rev(interval(0.0,Inf), 1)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), 1)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), 1)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), 1)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), 1)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), 1)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), 1)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), 1)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-324.3,2.5), 1)[2], interval(-324.3,2.5)) + @test isequal_interval(power_rev(bareinterval(-324.3,2.5), 1)[2], bareinterval(-324.3,2.5)) - @test isequal_interval(power_rev(interval(0.01,2.33), 1)[2], interval(0.01,2.33)) + @test isequal_interval(power_rev(bareinterval(0.01,2.33), 1)[2], bareinterval(0.01,2.33)) - @test isequal_interval(power_rev(interval(-1.9,-0.33), 1)[2], interval(-1.9,-0.33)) + @test isequal_interval(power_rev(bareinterval(-1.9,-0.33), 1)[2], bareinterval(-1.9,-0.33)) - @test isequal_interval(power_rev(emptyinterval(), 2)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-5.0,-1.0), 2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-5.0,-1.0), 2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), 2)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), 2)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,Inf), 2)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), 2)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), 2)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), 2)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), 2)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), 2)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7), 2)[2], interval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) + @test isequal_interval(power_rev(bareinterval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7), 2)[2], bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) - @test isequal_interval(power_rev(interval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25), 2)[2], interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) + @test isequal_interval(power_rev(bareinterval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25), 2)[2], bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) - @test isequal_interval(power_rev(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 2)[2], interval(-0x1p+512,0x1p+512)) + @test isequal_interval(power_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 2)[2], bareinterval(-0x1p+512,0x1p+512)) - @test isequal_interval(power_rev(interval(0.0,0x1.9AD27D70A3D72P+16), 2)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(0.0,0x1.9AD27D70A3D72P+16), 2)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(-0.0,0x1.9AD27D70A3D72P+16), 2)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(-0.0,0x1.9AD27D70A3D72P+16), 2)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), 2)[2], interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), 2)[2], bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), 2)[2], interval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) + @test isequal_interval(power_rev(bareinterval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), 2)[2], bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) - @test isequal_interval(power_rev(emptyinterval(), 8)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 8)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), 8)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), 8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), 8)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), 8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,Inf), 8)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), 8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), 8)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), 8)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), 8)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), 8)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29), 8)[2], interval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) + @test isequal_interval(power_rev(bareinterval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29), 8)[2], bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) - @test isequal_interval(power_rev(interval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102), 8)[2], interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) + @test isequal_interval(power_rev(bareinterval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102), 8)[2], bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) - @test isequal_interval(power_rev(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 8)[2], interval(-0x1p+128,0x1p+128)) + @test isequal_interval(power_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 8)[2], bareinterval(-0x1p+128,0x1p+128)) - @test isequal_interval(power_rev(interval(0.0,0x1.A87587109655P+66), 8)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(0.0,0x1.A87587109655P+66), 8)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(-0.0,0x1.A87587109655P+66), 8)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(-0.0,0x1.A87587109655P+66), 8)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9), 8)[2], interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9), 8)[2], bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7), 8)[2], interval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) + @test isequal_interval(power_rev(bareinterval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7), 8)[2], bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) - @test isequal_interval(power_rev(emptyinterval(), 3)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), 3)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), 3)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), 3)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), 3)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), 3)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), 3)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11), 3)[2], interval(0x1.a333333333332p+3,0x1.a333333333334p+3)) + @test isequal_interval(power_rev(bareinterval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11), 3)[2], bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3)) - @test isequal_interval(power_rev(interval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38), 3)[2], interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) + @test isequal_interval(power_rev(bareinterval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38), 3)[2], bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) - @test isequal_interval(power_rev(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 3)[2], interval(0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341)) + @test isequal_interval(power_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 3)[2], bareinterval(0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341)) - @test isequal_interval(power_rev(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 3)[2], interval(-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341)) + @test isequal_interval(power_rev(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 3)[2], bareinterval(-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341)) - @test isequal_interval(power_rev(interval(0.0,Inf), 3)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), 3)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), 3)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), 3)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), 3)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), 3)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), 3)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), 3)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-0x1.0436D2F418938P+25,0x1.F4P+3), 3)[2], interval(-0x1.444cccccccccep+8,0x1.4p+1)) + @test isequal_interval(power_rev(bareinterval(-0x1.0436D2F418938P+25,0x1.F4P+3), 3)[2], bareinterval(-0x1.444cccccccccep+8,0x1.4p+1)) - @test isequal_interval(power_rev(interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), 3)[2], interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), 3)[2], bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), 3)[2], interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) + @test isequal_interval(power_rev(bareinterval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), 3)[2], bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) - @test isequal_interval(power_rev(emptyinterval(), 7)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), 7)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), 7)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), 7)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), 7)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), 7)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), 7)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), 7)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25), 7)[2], interval(0x1.a333333333332p+3,0x1.a333333333334p+3)) + @test isequal_interval(power_rev(bareinterval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25), 7)[2], bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3)) - @test isequal_interval(power_rev(interval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90), 7)[2], interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) + @test isequal_interval(power_rev(bareinterval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90), 7)[2], bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) - @test isequal_interval(power_rev(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 7)[2], interval(0x1.381147622f886p+146,0x1.381147622f887p+146)) + @test isequal_interval(power_rev(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), 7)[2], bareinterval(0x1.381147622f886p+146,0x1.381147622f887p+146)) - @test isequal_interval(power_rev(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 7)[2], interval(-0x1.381147622f887p+146,-0x1.381147622f886p+146)) + @test isequal_interval(power_rev(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), 7)[2], bareinterval(-0x1.381147622f887p+146,-0x1.381147622f886p+146)) - @test isequal_interval(power_rev(interval(0.0,Inf), 7)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), 7)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), 7)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), 7)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), 7)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), 7)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), 7)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), 7)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-0x1.4F109959E6D7FP+58,0x1.312DP+9), 7)[2], interval(-0x1.444cccccccccep+8,0x1.4p+1)) + @test isequal_interval(power_rev(bareinterval(-0x1.4F109959E6D7FP+58,0x1.312DP+9), 7)[2], bareinterval(-0x1.444cccccccccep+8,0x1.4p+1)) - @test isequal_interval(power_rev(interval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8), 7)[2], interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8), 7)[2], bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12), 7)[2], interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) + @test isequal_interval(power_rev(bareinterval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12), 7)[2], bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) - @test isequal_interval(power_rev(emptyinterval(), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), -2)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), -2)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,Inf), -2)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), -2)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,-0.0), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-10.0,0.0), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-10.0,0.0), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-10.0,-0.0), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-10.0,-0.0), -2)[2], emptyinterval(BareInterval{Float64})) - @test_broken isequal_interval(power_rev(interval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8), -2)[2], interval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8), -2)[2], bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) - @test_broken isequal_interval(power_rev(interval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26), -2)[2], interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26), -2)[2], bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) - @test isequal_interval(power_rev(interval(0x0P+0,0x0.0000000000001P-1022), -2)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0x0P+0,0x0.0000000000001P-1022), -2)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.3F0C482C977C9P-17,Inf), -2)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(0x1.3F0C482C977C9P-17,Inf), -2)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(0x1.793D85EF38E47P-3,0x1.388P+13), -2)[2], interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.793D85EF38E47P-3,0x1.388P+13), -2)[2], bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), -2)[2], interval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) + @test isequal_interval(power_rev(bareinterval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), -2)[2], bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) - @test isequal_interval(power_rev(emptyinterval(), -8)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), -8)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), -8)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), -8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,Inf), -8)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), -8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), -8)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), -8)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,-0.0), -8)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), -8)[2], emptyinterval(BareInterval{Float64})) - @test_broken isequal_interval(power_rev(interval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30), -8)[2], interval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30), -8)[2], bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3)) - @test_broken isequal_interval(power_rev(interval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103), -8)[2], interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103), -8)[2], bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12)) - @test isequal_interval(power_rev(interval(0x0P+0,0x0.0000000000001P-1022), -8)[2], entireinterval()) + @test isequal_interval(power_rev(bareinterval(0x0P+0,0x0.0000000000001P-1022), -8)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.34CC3764D1E0CP-67,Inf), -8)[2], interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) + @test isequal_interval(power_rev(bareinterval(0x1.34CC3764D1E0CP-67,Inf), -8)[2], bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8)) - @test isequal_interval(power_rev(interval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53), -8)[2], interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53), -8)[2], bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12), -8)[2], interval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) + @test isequal_interval(power_rev(bareinterval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12), -8)[2], bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0)) - @test isequal_interval(power_rev(emptyinterval(), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), -1)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), -1)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,-0.0), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4), -1)[2], interval(0x1.a333333333332p+3,0x1.a333333333335p+3)) + @test isequal_interval(power_rev(bareinterval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4), -1)[2], bareinterval(0x1.a333333333332p+3,0x1.a333333333335p+3)) - @test isequal_interval(power_rev(interval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13), -1)[2], interval(-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12)) + @test isequal_interval(power_rev(bareinterval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13), -1)[2], bareinterval(-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12)) - @test isequal_interval(power_rev(interval(0x0.4P-1022,0x0.4000000000001P-1022), -1)[2], interval(0x1.ffffffffffff8p+1023,Inf)) + @test isequal_interval(power_rev(bareinterval(0x0.4P-1022,0x0.4000000000001P-1022), -1)[2], bareinterval(0x1.ffffffffffff8p+1023,Inf)) - @test isequal_interval(power_rev(interval(-0x0.4000000000001P-1022,-0x0.4P-1022), -1)[2], interval(-Inf,-0x1.ffffffffffff8p+1023)) + @test isequal_interval(power_rev(bareinterval(-0x0.4000000000001P-1022,-0x0.4P-1022), -1)[2], bareinterval(-Inf,-0x1.ffffffffffff8p+1023)) - @test isequal_interval(power_rev(interval(0.0,Inf), -1)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), -1)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), -1)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), -1)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), -1)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), -1)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), -1)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), -1)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(0x1.B77C278DBBE13P-2,0x1.9P+6), -1)[2], interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.B77C278DBBE13P-2,0x1.9P+6), -1)[2], bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1), -1)[2], interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) + @test isequal_interval(power_rev(bareinterval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1), -1)[2], bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) - @test isequal_interval(power_rev(emptyinterval(), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), -3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), -3)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), -3)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), -3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,-0.0), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), -3)[2], emptyinterval(BareInterval{Float64})) - @test_broken isequal_interval(power_rev(interval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12), -3)[2], interval(0x1.a333333333332p+3,0x1.a333333333334p+3)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12), -3)[2], bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3)) - @test_broken isequal_interval(power_rev(interval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39), -3)[2], interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) + @test_broken isequal_interval(power_rev(bareinterval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39), -3)[2], bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) - @test isequal_interval(power_rev(interval(0x0P+0,0x0.0000000000001P-1022), -3)[2], interval(0x1p+358,Inf)) + @test isequal_interval(power_rev(bareinterval(0x0P+0,0x0.0000000000001P-1022), -3)[2], bareinterval(0x1p+358,Inf)) - @test isequal_interval(power_rev(interval(-0x0.0000000000001P-1022,-0x0P+0), -3)[2], interval(-Inf,-0x1p+358)) + @test isequal_interval(power_rev(bareinterval(-0x0.0000000000001P-1022,-0x0P+0), -3)[2], bareinterval(-Inf,-0x1p+358)) - @test isequal_interval(power_rev(interval(0.0,Inf), -3)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), -3)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), -3)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), -3)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), -3)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), -3)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), -3)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), -3)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(0x1.43CFBA61AACABP-4,0x1.E848P+19), -3)[2], interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.43CFBA61AACABP-4,0x1.E848P+19), -3)[2], bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3), -3)[2], interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) + @test isequal_interval(power_rev(bareinterval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3), -3)[2], bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) - @test isequal_interval(power_rev(emptyinterval(), -7)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), -7)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), -7)[2], entireinterval()) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), -7)[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,0.0), -7)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), -7)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-0.0,-0.0), -7)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), -7)[2], emptyinterval(BareInterval{Float64})) - @test_broken isequal_interval(power_rev(interval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26), -7)[2], interval(0x1.a333333333332p+3,0x1.a333333333334p+3)) + @test_broken isequal_interval(power_rev(bareinterval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26), -7)[2], bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3)) - @test_broken isequal_interval(power_rev(interval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91), -7)[2], interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) + @test_broken isequal_interval(power_rev(bareinterval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91), -7)[2], bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12)) - @test isequal_interval(power_rev(interval(0x0P+0,0x0.0000000000001P-1022), -7)[2], interval(0x1.588cea3f093bcp+153,Inf)) + @test isequal_interval(power_rev(bareinterval(0x0P+0,0x0.0000000000001P-1022), -7)[2], bareinterval(0x1.588cea3f093bcp+153,Inf)) - @test isequal_interval(power_rev(interval(-0x0.0000000000001P-1022,-0x0P+0), -7)[2], interval(-Inf,-0x1.588cea3f093bcp+153)) + @test isequal_interval(power_rev(bareinterval(-0x0.0000000000001P-1022,-0x0P+0), -7)[2], bareinterval(-Inf,-0x1.588cea3f093bcp+153)) - @test isequal_interval(power_rev(interval(0.0,Inf), -7)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), -7)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-0.0,Inf), -7)[2], interval(0.0,Inf)) + @test isequal_interval(power_rev(bareinterval(-0.0,Inf), -7)[2], bareinterval(0.0,Inf)) - @test isequal_interval(power_rev(interval(-Inf,0.0), -7)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), -7)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(-Inf,-0.0), -7)[2], interval(-Inf,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), -7)[2], bareinterval(-Inf,0.0)) - @test isequal_interval(power_rev(interval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46), -7)[2], interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46), -7)[2], bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7), -7)[2], interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) + @test isequal_interval(power_rev(bareinterval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7), -7)[2], bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2)) end @testset "minimal_pown_rev_bin_test" begin - @test isequal_interval(power_rev(emptyinterval(), interval(1.0,1.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(1.0,1.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(1.0,1.0), interval(1.0,1.0), 0)[2], interval(1.0,1.0)) + @test isequal_interval(power_rev(bareinterval(1.0,1.0), bareinterval(1.0,1.0), 0)[2], bareinterval(1.0,1.0)) - @test isequal_interval(power_rev(interval(-1.0,5.0), interval(-51.0,12.0), 0)[2], interval(-51.0,12.0)) + @test isequal_interval(power_rev(bareinterval(-1.0,5.0), bareinterval(-51.0,12.0), 0)[2], bareinterval(-51.0,12.0)) - @test isequal_interval(power_rev(interval(-1.0,0.0), interval(5.0,10.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-1.0,0.0), bareinterval(5.0,10.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-1.0,-0.0), interval(-1.0,1.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-1.0,-0.0), bareinterval(-1.0,1.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(1.1,10.0), interval(1.0,41.0), 0)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(1.1,10.0), bareinterval(1.0,41.0), 0)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(emptyinterval(), interval(0.0,100.1), 1)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(0.0,100.1), 1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), interval(-5.1,10.0), 1)[2], interval(-5.1,10.0)) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), bareinterval(-5.1,10.0), 1)[2], bareinterval(-5.1,10.0)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(-10.0,5.1), 1)[2], interval(0.0,0.0)) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(-10.0,5.1), 1)[2], bareinterval(0.0,0.0)) - @test isequal_interval(power_rev(interval(-0.0,-0.0), interval(1.0,5.0), 1)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-0.0,-0.0), bareinterval(1.0,5.0), 1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(emptyinterval(), interval(5.0,17.1), 2)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(5.0,17.1), 2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-5.0,-1.0), interval(5.0,17.1), 2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-5.0,-1.0), bareinterval(5.0,17.1), 2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), interval(5.6,27.544), 2)[2], interval(5.6,27.544)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), bareinterval(5.6,27.544), 2)[2], bareinterval(5.6,27.544)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(1.0,2.0), 2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(1.0,2.0), 2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), interval(1.0,Inf), 2)[2], interval(1.0,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), bareinterval(1.0,Inf), 2)[2], bareinterval(1.0,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), interval(-Inf,-1.0), 2)[2], interval(-0x1.e666666666667p+0,-1.0)) + @test isequal_interval(power_rev(bareinterval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), bareinterval(-Inf,-1.0), 2)[2], bareinterval(-0x1.e666666666667p+0,-1.0)) - @test isequal_interval(power_rev(emptyinterval(), interval(-23.0,-1.0), 3)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(-23.0,-1.0), 3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), interval(-23.0,-1.0), 3)[2], interval(-23.0,-1.0)) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), bareinterval(-23.0,-1.0), 3)[2], bareinterval(-23.0,-1.0)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(1.0,2.0), 3)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(1.0,2.0), 3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), interval(1.0,Inf), 3)[2], interval(1.0,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), bareinterval(1.0,Inf), 3)[2], bareinterval(1.0,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), interval(-Inf,-1.0), 3)[2], interval(-0x1.e666666666667p+0,-1.0)) + @test isequal_interval(power_rev(bareinterval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), bareinterval(-Inf,-1.0), 3)[2], bareinterval(-0x1.e666666666667p+0,-1.0)) - @test isequal_interval(power_rev(emptyinterval(), interval(-3.0,17.3), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(-3.0,17.3), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0.0,Inf), interval(-5.1,-0.1), -2)[2], interval(-5.1,-0.1)) + @test isequal_interval(power_rev(bareinterval(0.0,Inf), bareinterval(-5.1,-0.1), -2)[2], bareinterval(-5.1,-0.1)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(27.2,55.1), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(27.2,55.1), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.3F0C482C977C9P-17,Inf), interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), -2)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0x1.3F0C482C977C9P-17,Inf), bareinterval(-Inf,-0x1.FFFFFFFFFFFFFp1023), -2)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(0x1.793D85EF38E47P-3,0x1.388P+13), interval(1.0,Inf), -2)[2], interval(1.0,0x1.2a3d70a3d70a5p+1)) + @test isequal_interval(power_rev(bareinterval(0x1.793D85EF38E47P-3,0x1.388P+13), bareinterval(1.0,Inf), -2)[2], bareinterval(1.0,0x1.2a3d70a3d70a5p+1)) - @test isequal_interval(power_rev(interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), interval(-Inf,-1.0), -2)[2], interval(-0x1.e666666666667p+0,-1.0)) + @test isequal_interval(power_rev(bareinterval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), bareinterval(-Inf,-1.0), -2)[2], bareinterval(-0x1.e666666666667p+0,-1.0)) - @test isequal_interval(power_rev(emptyinterval(), interval(-5.1,55.5), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(-5.1,55.5), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), interval(-5.1,55.5), -1)[2], interval(-5.1,55.5)) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), bareinterval(-5.1,55.5), -1)[2], bareinterval(-5.1,55.5)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(-5.1,55.5), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(-5.1,55.5), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-Inf,-0.0), interval(-1.0,1.0), -1)[2], interval(-1.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), bareinterval(-1.0,1.0), -1)[2], bareinterval(-1.0,0.0)) - @test isequal_interval(power_rev(interval(0x1.B77C278DBBE13P-2,0x1.9P+6), interval(-1.0,0.0), -1)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0x1.B77C278DBBE13P-2,0x1.9P+6), bareinterval(-1.0,0.0), -1)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(emptyinterval(), interval(-5.1,55.5), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(emptyinterval(BareInterval{Float64}), bareinterval(-5.1,55.5), -3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(entireinterval(), interval(-5.1,55.5), -3)[2], interval(-5.1,55.5)) + @test isequal_interval(power_rev(entireinterval(BareInterval{Float64}), bareinterval(-5.1,55.5), -3)[2], bareinterval(-5.1,55.5)) - @test isequal_interval(power_rev(interval(0.0,0.0), interval(-5.1,55.5), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(0.0,0.0), bareinterval(-5.1,55.5), -3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-Inf,0.0), interval(5.1,55.5), -3)[2], emptyinterval()) + @test isequal_interval(power_rev(bareinterval(-Inf,0.0), bareinterval(5.1,55.5), -3)[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(power_rev(interval(-Inf,-0.0), interval(-32.0,1.1), -3)[2], interval(-32.0,0.0)) + @test isequal_interval(power_rev(bareinterval(-Inf,-0.0), bareinterval(-32.0,1.1), -3)[2], bareinterval(-32.0,0.0)) end @testset "minimal_pown_rev_dec_test" begin - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(1.0,1.0), com), 0)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(1.0,1.0), IntervalArithmetic.com), 0)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,5.0), dac), 0)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-1.0,5.0), IntervalArithmetic.dac), 0)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,0.0), def), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-1.0,0.0), IntervalArithmetic.def), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,-0.0), dac), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-1.0,-0.0), IntervalArithmetic.dac), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(1.1,10.0), com), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(1.1,10.0), IntervalArithmetic.com), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), 1)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), 1)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), com), 1)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), 1)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), 1)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), 1)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(13.1,13.1), def), 1)[2], DecoratedInterval(interval(13.1,13.1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(13.1,13.1), IntervalArithmetic.def), 1)[2], Interval(bareinterval(13.1,13.1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-7451.145,-7451.145), dac), 1)[2], DecoratedInterval(interval(-7451.145,-7451.145), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-7451.145,-7451.145), IntervalArithmetic.dac), 1)[2], Interval(bareinterval(-7451.145,-7451.145), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), 1)[2], DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), 1)[2], Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), com), 1)[2], DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), 1)[2], Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), 1)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), 1)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), 1)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), 1)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), def), 1)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def), 1)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), 1)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), 1)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-324.3,2.5), dac), 1)[2], DecoratedInterval(interval(-324.3,2.5), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-324.3,2.5), IntervalArithmetic.dac), 1)[2], Interval(bareinterval(-324.3,2.5), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.01,2.33), com), 1)[2], DecoratedInterval(interval(0.01,2.33), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.01,2.33), IntervalArithmetic.com), 1)[2], Interval(bareinterval(0.01,2.33), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.9,-0.33), def), 1)[2], DecoratedInterval(interval(-1.9,-0.33), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-1.9,-0.33), IntervalArithmetic.def), 1)[2], Interval(bareinterval(-1.9,-0.33), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), 2)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), 2)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), def), 2)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def), 2)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), com), 2)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), 2)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), 2)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), 2)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7), def), 2)[2], DecoratedInterval(interval(-0x1.a333333333334p+3,0x1.a333333333334p+3), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.573851EB851EBP+7,0x1.573851EB851ECP+7), IntervalArithmetic.def), 2)[2], Interval(bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25), def), 2)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.A794A4E7CFAADP+25,0x1.A794A4E7CFAAEP+25), IntervalArithmetic.def), 2)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac), 2)[2], DecoratedInterval(interval(-0x1p+512,0x1p+512), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac), 2)[2], Interval(bareinterval(-0x1p+512,0x1p+512), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0x1.9AD27D70A3D72P+16), dac), 2)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0x1.9AD27D70A3D72P+16), IntervalArithmetic.dac), 2)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,0x1.9AD27D70A3D72P+16), def), 2)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,0x1.9AD27D70A3D72P+16), IntervalArithmetic.def), 2)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), com), 2)[2], DecoratedInterval(interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), IntervalArithmetic.com), 2)[2], Interval(bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), def), 2)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,0x1.e666666666667p+0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), IntervalArithmetic.def), 2)[2], Interval(bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 8)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 8)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), 8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), 8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), 8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), 8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), 8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), 8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), 8)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.def), 8)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), 8)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), 8)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29), com), 8)[2], DecoratedInterval(interval(-0x1.a333333333334p+3,0x1.a333333333334p+3), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.9D8FD495853F5P+29,0x1.9D8FD495853F6P+29), IntervalArithmetic.com), 8)[2], Interval(bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102), dac), 8)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.DFB1BB622E70DP+102,0x1.DFB1BB622E70EP+102), IntervalArithmetic.dac), 8)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), def), 8)[2], DecoratedInterval(interval(-0x1p+128,0x1p+128), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.def), 8)[2], Interval(bareinterval(-0x1p+128,0x1p+128), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0x1.A87587109655P+66), dac), 8)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0x1.A87587109655P+66), IntervalArithmetic.dac), 8)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,0x1.A87587109655P+66), def), 8)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,0x1.A87587109655P+66), IntervalArithmetic.def), 8)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9), com), 8)[2], DecoratedInterval(interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.CD2B297D889BDP-54,0x1.B253D9F33CE4DP+9), IntervalArithmetic.com), 8)[2], Interval(bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7), dac), 8)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,0x1.e666666666667p+0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.26F1FCDD502A3P-13,0x1.53ABD7BFC4FC6P+7), IntervalArithmetic.dac), 8)[2], Interval(bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), 3)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), 3)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), dac), 3)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac), 3)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), def), 3)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.def), 3)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11), com), 3)[2], DecoratedInterval(interval(0x1.a333333333332p+3,0x1.a333333333334p+3), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.1902E978D4FDEP+11,0x1.1902E978D4FDFP+11), IntervalArithmetic.com), 3)[2], Interval(bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38), def), 3)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.81460637B9A3DP+38,-0x1.81460637B9A3CP+38), IntervalArithmetic.def), 3)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), dac), 3)[2], DecoratedInterval(interval(0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac), 3)[2], Interval(bareinterval(0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), com), 3)[2], DecoratedInterval(interval(-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), 3)[2], Interval(bareinterval(-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), def), 3)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def), 3)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), def), 3)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def), 3)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), dac), 3)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.dac), 3)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), 3)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), 3)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.0436D2F418938P+25,0x1.F4P+3), com), 3)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.4p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.0436D2F418938P+25,0x1.F4P+3), IntervalArithmetic.com), 3)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.4p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), dac), 3)[2], DecoratedInterval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), IntervalArithmetic.dac), 3)[2], Interval(bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), def), 3)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), IntervalArithmetic.def), 3)[2], Interval(bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), 7)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), 7)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), 7)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), 7)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), com), 7)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), 7)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), 7)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), 7)[2], Interval(bareinterval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25), def), 7)[2], DecoratedInterval(interval(0x1.a333333333332p+3,0x1.a333333333334p+3), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.F91D1B185493BP+25,0x1.F91D1B185493CP+25), IntervalArithmetic.def), 7)[2], Interval(bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90), dac), 7)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.07B1DA32F9B59P+90,-0x1.07B1DA32F9B58P+90), IntervalArithmetic.dac), 7)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), com), 7)[2], DecoratedInterval(interval(0x1.381147622f886p+146,0x1.381147622f887p+146), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.com), 7)[2], Interval(bareinterval(0x1.381147622f886p+146,0x1.381147622f887p+146), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), def), 7)[2], DecoratedInterval(interval(-0x1.381147622f887p+146,-0x1.381147622f886p+146), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.def), 7)[2], Interval(bareinterval(-0x1.381147622f887p+146,-0x1.381147622f886p+146), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), 7)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), 7)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), 7)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), 7)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), def), 7)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def), 7)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), 7)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), 7)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.4F109959E6D7FP+58,0x1.312DP+9), dac), 7)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.4p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.4F109959E6D7FP+58,0x1.312DP+9), IntervalArithmetic.dac), 7)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.4p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8), com), 7)[2], DecoratedInterval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.6849B86A12B9BP-47,0x1.74D0373C76313P+8), IntervalArithmetic.com), 7)[2], Interval(bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12), def), 7)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.658C775099757P+6,-0x1.BEE30301BF47AP-12), IntervalArithmetic.def), 7)[2], Interval(bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), -2)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), -2)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), -2)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), -2)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.def), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), com), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.com), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-10.0,0.0), dac), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-10.0,0.0), IntervalArithmetic.dac), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-10.0,-0.0), def), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-10.0,-0.0), IntervalArithmetic.def), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8), dac), -2)[2], DecoratedInterval(interval(-0x1.a333333333334p+3,0x1.a333333333334p+3), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.7DE3A077D1568P-8,0x1.7DE3A077D1569P-8), IntervalArithmetic.dac), -2)[2], Interval(bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26), def), -2)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.3570290CD6E14P-26,0x1.3570290CD6E15P-26), IntervalArithmetic.def), -2)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x0P+0,0x0.0000000000001P-1022), com), -2)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x0P+0,0x0.0000000000001P-1022), IntervalArithmetic.com), -2)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.3F0C482C977C9P-17,Inf), dac), -2)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.3F0C482C977C9P-17,Inf), IntervalArithmetic.dac), -2)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.793D85EF38E47P-3,0x1.388P+13), def), -2)[2], DecoratedInterval(interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.793D85EF38E47P-3,0x1.388P+13), IntervalArithmetic.def), -2)[2], Interval(bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), com), -2)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,0x1.e666666666667p+0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), IntervalArithmetic.com), -2)[2], Interval(bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), -8)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), -8)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), def), -8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.def), -8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), -8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), -8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), -8)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.def), -8)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), -8)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), -8)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30), com), -8)[2], DecoratedInterval(interval(-0x1.a333333333334p+3,0x1.a333333333334p+3), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.3CEF39247CA6DP-30,0x1.3CEF39247CA6EP-30), IntervalArithmetic.com), -8)[2], Interval(bareinterval(-0x1.a333333333334p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103), def), -8)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.113D9EF0A99ACP-103,0x1.113D9EF0A99ADP-103), IntervalArithmetic.def), -8)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x0P+0,0x0.0000000000001P-1022), dac), -8)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x0P+0,0x0.0000000000001P-1022), IntervalArithmetic.dac), -8)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.34CC3764D1E0CP-67,Inf), def), -8)[2], DecoratedInterval(interval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.34CC3764D1E0CP-67,Inf), IntervalArithmetic.def), -8)[2], Interval(bareinterval(-0x1.444cccccccccep+8,0x1.444cccccccccep+8), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53), com), -8)[2], DecoratedInterval(interval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.2DC80DB11AB7CP-10,0x1.1C37937E08P+53), IntervalArithmetic.com), -8)[2], Interval(bareinterval(-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12), def), -8)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,0x1.e666666666667p+0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.81E104E61630DP-8,0x1.BC64F21560E34P+12), IntervalArithmetic.def), -8)[2], Interval(bareinterval(-0x1.e666666666667p+0,0x1.e666666666667p+0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), -1)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), -1)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), dac), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.dac), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4), def), -1)[2], DecoratedInterval(interval(0x1.a333333333332p+3,0x1.a333333333335p+3), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.38ABF82EE6986P-4,0x1.38ABF82EE6987P-4), IntervalArithmetic.def), -1)[2], Interval(bareinterval(0x1.a333333333332p+3,0x1.a333333333335p+3), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13), dac), -1)[2], DecoratedInterval(interval(-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.197422C9048BFP-13,-0x1.197422C9048BEP-13), IntervalArithmetic.dac), -1)[2], Interval(bareinterval(-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x0.4P-1022,0x0.4000000000001P-1022), dac), -1)[2], DecoratedInterval(interval(0x1.ffffffffffff8p+1023,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x0.4P-1022,0x0.4000000000001P-1022), IntervalArithmetic.dac), -1)[2], Interval(bareinterval(0x1.ffffffffffff8p+1023,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x0.4000000000001P-1022,-0x0.4P-1022), def), -1)[2], DecoratedInterval(interval(-Inf,-0x1.ffffffffffff8p+1023), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x0.4000000000001P-1022,-0x0.4P-1022), IntervalArithmetic.def), -1)[2], Interval(bareinterval(-Inf,-0x1.ffffffffffff8p+1023), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), -1)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), -1)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), -1)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), -1)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), dac), -1)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.dac), -1)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), -1)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), -1)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.B77C278DBBE13P-2,0x1.9P+6), com), -1)[2], DecoratedInterval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.B77C278DBBE13P-2,0x1.9P+6), IntervalArithmetic.com), -1)[2], Interval(bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1), com), -1)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.83E0F83E0F83EP+1,-0x1.0D79435E50D79P-1), IntervalArithmetic.com), -1)[2], Interval(bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), -3)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), -3)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.def), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), dac), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.dac), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12), com), -3)[2], DecoratedInterval(interval(0x1.a333333333332p+3,0x1.a333333333334p+3), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.D26DF4D8B1831P-12,0x1.D26DF4D8B1832P-12), IntervalArithmetic.com), -3)[2], Interval(bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39), def), -3)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(-0x1.54347DED91B19P-39,-0x1.54347DED91B18P-39), IntervalArithmetic.def), -3)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x0P+0,0x0.0000000000001P-1022), dac), -3)[2], DecoratedInterval(interval(0x1p+358,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x0P+0,0x0.0000000000001P-1022), IntervalArithmetic.dac), -3)[2], Interval(bareinterval(0x1p+358,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x0.0000000000001P-1022,-0x0P+0), def), -3)[2], DecoratedInterval(interval(-Inf,-0x1p+358), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x0.0000000000001P-1022,-0x0P+0), IntervalArithmetic.def), -3)[2], Interval(bareinterval(-Inf,-0x1p+358), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), -3)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), -3)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), dac), -3)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.dac), -3)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), def), -3)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.def), -3)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), -3)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), -3)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.43CFBA61AACABP-4,0x1.E848P+19), com), -3)[2], DecoratedInterval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x1.43CFBA61AACABP-4,0x1.E848P+19), IntervalArithmetic.com), -3)[2], Interval(bareinterval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3), def), -3)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x1.BD393CE9E8E7CP+4,-0x1.2A95F6F7C066CP-3), IntervalArithmetic.def), -3)[2], Interval(bareinterval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), -7)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), -7)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), -7)[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), -7)[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), com), -7)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,0.0), IntervalArithmetic.com), -7)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), def), -7)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,-0.0), IntervalArithmetic.def), -7)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26), dac), -7)[2], DecoratedInterval(interval(0x1.a333333333332p+3,0x1.a333333333334p+3), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(0x1.037D76C912DBCP-26,0x1.037D76C912DBDP-26), IntervalArithmetic.dac), -7)[2], Interval(bareinterval(0x1.a333333333332p+3,0x1.a333333333334p+3), IntervalArithmetic.trv)) - @test_broken isequal_interval(power_rev(DecoratedInterval(interval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91), dac), -7)[2], DecoratedInterval(interval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), trv)) + @test_broken isequal_interval(power_rev(Interval(bareinterval(-0x1.F10F41FB8858FP-91,-0x1.F10F41FB8858EP-91), IntervalArithmetic.dac), -7)[2], Interval(bareinterval(-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x0P+0,0x0.0000000000001P-1022), def), -7)[2], DecoratedInterval(interval(0x1.588cea3f093bcp+153,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0x0P+0,0x0.0000000000001P-1022), IntervalArithmetic.def), -7)[2], Interval(bareinterval(0x1.588cea3f093bcp+153,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x0.0000000000001P-1022,-0x0P+0), def), -7)[2], DecoratedInterval(interval(-Inf,-0x1.588cea3f093bcp+153), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0x0.0000000000001P-1022,-0x0P+0), IntervalArithmetic.def), -7)[2], Interval(bareinterval(-Inf,-0x1.588cea3f093bcp+153), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), -7)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(0.0,Inf), IntervalArithmetic.dac), -7)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,Inf), def), -7)[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-0.0,Inf), IntervalArithmetic.def), -7)[2], Interval(bareinterval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), dac), -7)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,0.0), IntervalArithmetic.dac), -7)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), def), -7)[2], DecoratedInterval(interval(-Inf,0.0), trv)) + @test isequal_interval(power_rev(Interval(bareinterval(-Inf,-0.0), IntervalArithmetic.def), -7)[2], Interval(bareinterval(-Inf,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46), com), -7)[2], DecoratedInterval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.5F934D64162A9P-9,0x1.6BCC41E9P+46), IntervalArithmetic.com), -7)[2], Interval(interval(0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7), com), -7)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), trv)) + @test isequal_interval(power_rev(Interval(interval(-0x1.254CDD3711DDBP+11,-0x1.6E95C4A761E19P-7), IntervalArithmetic.com), -7)[2], Interval(interval(-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2), IntervalArithmetic.trv)) end @testset "minimal_pown_rev_dec_bin_test" begin - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(1.0,1.0), def), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(1.0,1.0), IntervalArithmetic.def), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(1.0,1.0), dac), DecoratedInterval(interval(1.0,1.0), dac), 0)[2], DecoratedInterval(interval(1.0,1.0), trv)) + @test isequal_interval(power_rev(Interval(interval(1.0,1.0), IntervalArithmetic.dac), Interval(interval(1.0,1.0), IntervalArithmetic.dac), 0)[2], Interval(interval(1.0,1.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,5.0), def), DecoratedInterval(interval(-51.0,12.0), dac), 0)[2], DecoratedInterval(interval(-51.0,12.0), trv)) + @test isequal_interval(power_rev(Interval(interval(-1.0,5.0), IntervalArithmetic.def), Interval(interval(-51.0,12.0), IntervalArithmetic.dac), 0)[2], Interval(interval(-51.0,12.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,0.0), com), DecoratedInterval(interval(5.0,10.0), dac), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(-1.0,0.0), IntervalArithmetic.com), Interval(interval(5.0,10.0), IntervalArithmetic.dac), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-1.0,-0.0), dac), DecoratedInterval(interval(-1.0,1.0), def), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(-1.0,-0.0), IntervalArithmetic.dac), Interval(interval(-1.0,1.0), IntervalArithmetic.def), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(1.1,10.0), def), DecoratedInterval(interval(1.0,41.0), dac), 0)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(1.1,10.0), IntervalArithmetic.def), Interval(interval(1.0,41.0), IntervalArithmetic.dac), 0)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0,100.1), dac), 1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(0.0,100.1), IntervalArithmetic.dac), 1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-5.1,10.0), def), 1)[2], DecoratedInterval(interval(-5.1,10.0), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(interval(-5.1,10.0), IntervalArithmetic.def), 1)[2], Interval(interval(-5.1,10.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), com), DecoratedInterval(interval(-10.0,5.1), dac), 1)[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.com), Interval(interval(-10.0,5.1), IntervalArithmetic.dac), 1)[2], Interval(interval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0.0,-0.0), def), DecoratedInterval(interval(1.0,5.0), dac), 1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(-0.0,-0.0), IntervalArithmetic.def), Interval(interval(1.0,5.0), IntervalArithmetic.dac), 1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(5.0,17.1), def), 2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(5.0,17.1), IntervalArithmetic.def), 2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), DecoratedInterval(interval(5.6,27.544), dac), 2)[2], DecoratedInterval(interval(5.6,27.544), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,Inf), IntervalArithmetic.dac), Interval(interval(5.6,27.544), IntervalArithmetic.dac), 2)[2], Interval(interval(5.6,27.544), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), DecoratedInterval(interval(1.0,2.0), def), 2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def), Interval(interval(1.0,2.0), IntervalArithmetic.def), 2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), com), DecoratedInterval(interval(1.0,Inf), def), 2)[2], DecoratedInterval(interval(1.0,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.A36E2EB1C432CP-14,0x1.5B7318FC50482P+2), IntervalArithmetic.com), Interval(interval(1.0,Inf), IntervalArithmetic.def), 2)[2], Interval(interval(1.0,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), dac), DecoratedInterval(interval(-Inf,-1.0), def), 2)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-1.0), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.BE0DED288CE7P-4,0x1.CE147AE147AE1P+1), IntervalArithmetic.dac), Interval(interval(-Inf,-1.0), IntervalArithmetic.def), 2)[2], Interval(interval(-0x1.e666666666667p+0,-1.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-23.0,-1.0), dac), 3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-23.0,-1.0), IntervalArithmetic.dac), 3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-23.0,-1.0), com), 3)[2], DecoratedInterval(interval(-23.0,-1.0), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(interval(-23.0,-1.0), IntervalArithmetic.com), 3)[2], Interval(interval(-23.0,-1.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), DecoratedInterval(interval(1.0,2.0), dac), 3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def), Interval(interval(1.0,2.0), IntervalArithmetic.dac), 3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), com), DecoratedInterval(interval(1.0,Inf), dac), 3)[2], DecoratedInterval(interval(1.0,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.0C6F7A0B5ED8DP-20,0x1.94C75E6362A6P+3), IntervalArithmetic.com), Interval(interval(1.0,Inf), IntervalArithmetic.dac), 3)[2], Interval(interval(1.0,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), com), DecoratedInterval(interval(-Inf,-1.0), dac), 3)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-1.0), trv)) + @test isequal_interval(power_rev(Interval(interval(-0x1.B6F9DB22D0E55P+2,-0x1.266559F6EC5B1P-5), IntervalArithmetic.com), Interval(interval(-Inf,-1.0), IntervalArithmetic.dac), 3)[2], Interval(interval(-0x1.e666666666667p+0,-1.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-3.0,17.3), def), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-3.0,17.3), IntervalArithmetic.def), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,Inf), dac), DecoratedInterval(interval(-5.1,-0.1), dac), -2)[2], DecoratedInterval(interval(-5.1,-0.1), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,Inf), IntervalArithmetic.dac), Interval(interval(-5.1,-0.1), IntervalArithmetic.dac), -2)[2], Interval(interval(-5.1,-0.1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), DecoratedInterval(interval(27.2,55.1), dac), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def), Interval(interval(27.2,55.1), IntervalArithmetic.dac), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.3F0C482C977C9P-17,Inf), def), DecoratedInterval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), dac), -2)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.3F0C482C977C9P-17,Inf), IntervalArithmetic.def), Interval(interval(-Inf,-0x1.FFFFFFFFFFFFFp1023), IntervalArithmetic.dac), -2)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.793D85EF38E47P-3,0x1.388P+13), com), DecoratedInterval(interval(1.0,Inf), dac), -2)[2], DecoratedInterval(interval(1.0,0x1.2a3d70a3d70a5p+1), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.793D85EF38E47P-3,0x1.388P+13), IntervalArithmetic.com), Interval(interval(1.0,Inf), IntervalArithmetic.dac), -2)[2], Interval(interval(1.0,0x1.2a3d70a3d70a5p+1), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), com), DecoratedInterval(interval(-Inf,-1.0), dac), -2)[2], DecoratedInterval(interval(-0x1.e666666666667p+0,-1.0), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.1BA81104F6C8P-2,0x1.25D8FA1F801E1P+3), IntervalArithmetic.com), Interval(interval(-Inf,-1.0), IntervalArithmetic.dac), -2)[2], Interval(interval(-0x1.e666666666667p+0,-1.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-5.1,55.5), def), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-5.1,55.5), IntervalArithmetic.def), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-5.1,55.5), dac), -1)[2], DecoratedInterval(interval(-5.1,55.5), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(interval(-5.1,55.5), IntervalArithmetic.dac), -1)[2], Interval(interval(-5.1,55.5), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), dac), DecoratedInterval(interval(-5.1,55.5), def), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.dac), Interval(interval(-5.1,55.5), IntervalArithmetic.def), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), dac), DecoratedInterval(interval(-1.0,1.0), com), -1)[2], DecoratedInterval(interval(-1.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(interval(-Inf,-0.0), IntervalArithmetic.dac), Interval(interval(-1.0,1.0), IntervalArithmetic.com), -1)[2], Interval(interval(-1.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0x1.B77C278DBBE13P-2,0x1.9P+6), def), DecoratedInterval(interval(-1.0,0.0), dac), -1)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0x1.B77C278DBBE13P-2,0x1.9P+6), IntervalArithmetic.def), Interval(interval(-1.0,0.0), IntervalArithmetic.dac), -1)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-5.1,55.5), dac), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-5.1,55.5), IntervalArithmetic.dac), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-5.1,55.5), def), -3)[2], DecoratedInterval(interval(-5.1,55.5), trv)) + @test isequal_interval(power_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(interval(-5.1,55.5), IntervalArithmetic.def), -3)[2], Interval(interval(-5.1,55.5), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(0.0,0.0), def), DecoratedInterval(interval(-5.1,55.5), def), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def), Interval(interval(-5.1,55.5), IntervalArithmetic.def), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,0.0), dac), DecoratedInterval(interval(5.1,55.5), com), -3)[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(power_rev(Interval(interval(-Inf,0.0), IntervalArithmetic.dac), Interval(interval(5.1,55.5), IntervalArithmetic.com), -3)[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(power_rev(DecoratedInterval(interval(-Inf,-0.0), dac), DecoratedInterval(interval(-32.0,1.1), def), -3)[2], DecoratedInterval(interval(-32.0,0.0), trv)) + @test isequal_interval(power_rev(Interval(interval(-Inf,-0.0), IntervalArithmetic.dac), Interval(interval(-32.0,1.1), IntervalArithmetic.def), -3)[2], Interval(interval(-32.0,0.0), IntervalArithmetic.trv)) end @testset "minimal_sin_rev_test" begin - @test isequal_interval(sin_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(sin_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(-2.0,-1.1))[2], emptyinterval()) + @test isequal_interval(sin_rev(interval(-2.0,-1.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(1.1, 2.0))[2], emptyinterval()) + @test isequal_interval(sin_rev(interval(1.1, 2.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(-1.0,1.0))[2], entireinterval()) + @test isequal_interval(sin_rev(interval(-1.0,1.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(0.0,0.0))[2], entireinterval()) + @test isequal_interval(sin_rev(interval(0.0,0.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval()) + @test isequal_interval(sin_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval(BareInterval{Float64})) end @testset "minimal_sin_rev_bin_test" begin - @test isequal_interval(sin_rev(emptyinterval(), interval(-1.2,12.1))[2], emptyinterval()) + @test isequal_interval(sin_rev(emptyinterval(BareInterval{Float64}), interval(-1.2,12.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(-2.0,-1.1), interval(-5.0, 5.0))[2], emptyinterval()) + @test isequal_interval(sin_rev(interval(-2.0,-1.1), interval(-5.0, 5.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(sin_rev(interval(1.1, 2.0), interval(-5.0, 5.0))[2], emptyinterval()) + @test isequal_interval(sin_rev(interval(1.1, 2.0), interval(-5.0, 5.0))[2], emptyinterval(BareInterval{Float64})) @test isequal_interval(sin_rev(interval(-1.0,1.0), interval(-1.2,12.1))[2], interval(-1.2,12.1)) @test isequal_interval(sin_rev(interval(0.0,0.0), interval(-1.0,1.0))[2], interval(0.0,0.0)) - @test isequal_interval(sin_rev(interval(-0.0,-0.0), interval(2.0,2.5))[2], emptyinterval()) + @test isequal_interval(sin_rev(interval(-0.0,-0.0), interval(2.0,2.5))[2], emptyinterval(BareInterval{Float64})) @test isequal_interval(sin_rev(interval(-0.0,-0.0), interval(3.0,3.5))[2], interval(0x1.921fb54442d18p+1,0x1.921fb54442d19p+1)) - @test isequal_interval(sin_rev(interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0), interval(1.57,1.58, ))[2], interval(0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0)) + @test isequal_interval(sin_rev(interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0), interval(1.57,1.58))[2], interval(0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0)) @test isequal_interval(sin_rev(interval(0.0,0x1P+0), interval(-0.1,1.58))[2], interval(0.0,1.58)) @@ -972,87 +972,87 @@ end @testset "minimal_sin_rev_dec_test" begin - @test isequal_interval(sin_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-2.0,-1.1), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(-2.0,-1.1), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(1.1, 2.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(1.1, 2.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-1.0,1.0), com))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(-1.0,1.0), IntervalArithmetic.com))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0.0,0.0), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(0.0,0.0), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), def))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.def))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_sin_rev_dec_bin_test" begin - @test isequal_interval(sin_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-1.2,12.1), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-1.2,12.1), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-2.0,-1.1), def), DecoratedInterval(interval(-5.0, 5.0), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(-2.0,-1.1), IntervalArithmetic.def), Interval(interval(-5.0, 5.0), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(1.1, 2.0), dac), DecoratedInterval(interval(-5.0, 5.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(1.1, 2.0), IntervalArithmetic.dac), Interval(interval(-5.0, 5.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-1.0,1.0), com), DecoratedInterval(interval(-1.2,12.1), def))[2], DecoratedInterval(interval(-1.2,12.1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-1.0,1.0), IntervalArithmetic.com), Interval(interval(-1.2,12.1), IntervalArithmetic.def))[2], Interval(interval(-1.2,12.1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0.0,0.0), dac), DecoratedInterval(interval(-1.0,1.0), def))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(sin_rev(Interval(interval(0.0,0.0), IntervalArithmetic.dac), Interval(interval(-1.0,1.0), IntervalArithmetic.def))[2], Interval(interval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0.0,-0.0), def), DecoratedInterval(interval(2.0,2.5), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0.0,-0.0), IntervalArithmetic.def), Interval(interval(2.0,2.5), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0.0,-0.0), def), DecoratedInterval(interval(3.0,3.5), dac))[2], DecoratedInterval(interval(0x1.921fb54442d18p+1,0x1.921fb54442d19p+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0.0,-0.0), IntervalArithmetic.def), Interval(interval(3.0,3.5), IntervalArithmetic.dac))[2], Interval(interval(0x1.921fb54442d18p+1,0x1.921fb54442d19p+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0), dac), DecoratedInterval(interval(1.57,1.58), dac))[2], DecoratedInterval(interval(0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0), trv)) + @test isequal_interval(sin_rev(Interval(interval(0x1.FFFFFFFFFFFFFP-1,0x1P+0), IntervalArithmetic.dac), Interval(interval(1.57,1.58), IntervalArithmetic.dac))[2], Interval(interval(0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0.0,0x1P+0), com), DecoratedInterval(interval(-0.1,1.58), dac))[2], DecoratedInterval(interval(0.0,1.58), trv)) + @test isequal_interval(sin_rev(Interval(interval(0.0,0x1P+0), IntervalArithmetic.com), Interval(interval(-0.1,1.58), IntervalArithmetic.dac))[2], Interval(interval(0.0,1.58), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), com), DecoratedInterval(interval(3.14,3.15), def))[2], DecoratedInterval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.com), Interval(interval(3.14,3.15), IntervalArithmetic.def))[2], Interval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), com), DecoratedInterval(interval(3.14,3.15), dac))[2], DecoratedInterval(interval(0x1.921FB54442D18P+1,0x1.921FB54442D1aP+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), IntervalArithmetic.com), Interval(interval(3.14,3.15), IntervalArithmetic.dac))[2], Interval(interval(0x1.921FB54442D18P+1,0x1.921FB54442D1aP+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,0x1.1A62633145C07P-53), dac), DecoratedInterval(interval(3.14,3.15), com))[2], DecoratedInterval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D1aP+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,0x1.1A62633145C07P-53), IntervalArithmetic.dac), Interval(interval(3.14,3.15), IntervalArithmetic.com))[2], Interval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D1aP+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0.0,1.0), def), DecoratedInterval(interval(-0.1,3.15), def))[2], DecoratedInterval(interval(0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(0.0,1.0), IntervalArithmetic.def), Interval(interval(-0.1,3.15), IntervalArithmetic.def))[2], Interval(interval(0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0.0,1.0), dac), DecoratedInterval(interval(-0.1,3.15), com))[2], DecoratedInterval(interval(-0.0,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(0.0,1.0), IntervalArithmetic.dac), Interval(interval(-0.1,3.15), IntervalArithmetic.com))[2], Interval(interval(-0.0,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,1.0), def), DecoratedInterval(interval(-0.1,3.15), def))[2], DecoratedInterval(interval(-0x1.72cece675d1fep-52,0x1.921FB54442D1aP+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,1.0), IntervalArithmetic.def), Interval(interval(-0.1,3.15), IntervalArithmetic.def))[2], Interval(interval(-0x1.72cece675d1fep-52,0x1.921FB54442D1aP+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,1.0), com), DecoratedInterval(interval(0.0,3.15), dac))[2], DecoratedInterval(interval(0.0,0x1.921FB54442D1aP+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,1.0), IntervalArithmetic.com), Interval(interval(0.0,3.15), IntervalArithmetic.dac))[2], Interval(interval(0.0,0x1.921FB54442D1aP+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1P+0), def), DecoratedInterval(interval(3.14,3.15), com))[2], DecoratedInterval(interval(3.14,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(0x1.1A62633145C06P-53,0x1P+0), IntervalArithmetic.def), Interval(interval(3.14,3.15), IntervalArithmetic.com))[2], Interval(interval(3.14,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,0x1P+0), dac), DecoratedInterval(interval(1.57,3.15), com))[2], DecoratedInterval(interval(1.57,0x1.921FB54442D1AP+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,0x1P+0), IntervalArithmetic.dac), Interval(interval(1.57,3.15), IntervalArithmetic.com))[2], Interval(interval(1.57,0x1.921FB54442D1AP+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), com), DecoratedInterval(interval(-Inf,3.15), dac))[2], DecoratedInterval(interval(-Inf,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(sin_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.com), Interval(interval(-Inf,3.15), IntervalArithmetic.dac))[2], Interval(interval(-Inf,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(sin_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), com), DecoratedInterval(interval(3.14,Inf), dac))[2], DecoratedInterval(interval(0x1.921FB54442D18P+1,Inf), trv)) + @test isequal_interval(sin_rev(Interval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), IntervalArithmetic.com), Interval(interval(3.14,Inf), IntervalArithmetic.dac))[2], Interval(interval(0x1.921FB54442D18P+1,Inf), IntervalArithmetic.trv)) end @testset "minimal_cos_rev_test" begin - @test isequal_interval(cos_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(cos_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(-2.0,-1.1))[2], emptyinterval()) + @test isequal_interval(cos_rev(interval(-2.0,-1.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(1.1, 2.0))[2], emptyinterval()) + @test isequal_interval(cos_rev(interval(1.1, 2.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(-1.0,1.0))[2], entireinterval()) + @test isequal_interval(cos_rev(interval(-1.0,1.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(0.0,0.0))[2], entireinterval()) + @test isequal_interval(cos_rev(interval(0.0,0.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval()) + @test isequal_interval(cos_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval(BareInterval{Float64})) end @testset "minimal_cos_rev_bin_test" begin - @test isequal_interval(cos_rev(emptyinterval(), interval(-1.2,12.1))[2], emptyinterval()) + @test isequal_interval(cos_rev(emptyinterval(BareInterval{Float64}), interval(-1.2,12.1))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(-2.0,-1.1), interval(-5.0, 5.0))[2], emptyinterval()) + @test isequal_interval(cos_rev(interval(-2.0,-1.1), interval(-5.0, 5.0))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cos_rev(interval(1.1, 2.0), interval(-5.0, 5.0))[2], emptyinterval()) + @test isequal_interval(cos_rev(interval(1.1, 2.0), interval(-5.0, 5.0))[2], emptyinterval(BareInterval{Float64})) @test isequal_interval(cos_rev(interval(-1.0,1.0), interval(-1.2,12.1))[2], interval(-1.2,12.1)) @@ -1094,85 +1094,85 @@ end @testset "minimal_cos_rev_dec_test" begin - @test isequal_interval(cos_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-2.0,-1.1), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(-2.0,-1.1), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(1.1, 2.0), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(1.1, 2.0), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-1.0,1.0), com))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(-1.0,1.0), IntervalArithmetic.com))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0.0,0.0), def))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_cos_rev_dec_bin_test" begin - @test isequal_interval(cos_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-1.2,12.1), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-1.2,12.1), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-2.0,-1.1), dac), DecoratedInterval(interval(-5.0, 5.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(-2.0,-1.1), IntervalArithmetic.dac), Interval(interval(-5.0, 5.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(1.1, 2.0), dac), DecoratedInterval(interval(-5.0, 5.0), com))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cos_rev(Interval(interval(1.1, 2.0), IntervalArithmetic.dac), Interval(interval(-5.0, 5.0), IntervalArithmetic.com))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-1.0,1.0), dac), DecoratedInterval(interval(-1.2,12.1), def))[2], DecoratedInterval(interval(-1.2,12.1), trv)) + @test isequal_interval(cos_rev(Interval(interval(-1.0,1.0), IntervalArithmetic.dac), Interval(interval(-1.2,12.1), IntervalArithmetic.def))[2], Interval(interval(-1.2,12.1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(1.0,1.0), def), DecoratedInterval(interval(-0.1,0.1), dac))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cos_rev(Interval(interval(1.0,1.0), IntervalArithmetic.def), Interval(interval(-0.1,0.1), IntervalArithmetic.dac))[2], Interval(interval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-1.0,-1.0), com), DecoratedInterval(interval(3.14,3.15), dac))[2], DecoratedInterval(interval(0x1.921fb54442d18p+1,0x1.921fb54442d1ap+1), trv)) + @test isequal_interval(cos_rev(Interval(interval(-1.0,-1.0), IntervalArithmetic.com), Interval(interval(3.14,3.15), IntervalArithmetic.dac))[2], Interval(interval(0x1.921fb54442d18p+1,0x1.921fb54442d1ap+1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54), def), DecoratedInterval(interval(1.57,1.58), def))[2], DecoratedInterval(interval(0x1.921FB54442D17P+0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-54,0x1.1A62633145C07P-54), IntervalArithmetic.def), Interval(interval(1.57,1.58), IntervalArithmetic.def))[2], Interval(interval(0x1.921FB54442D17P+0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53), dac), DecoratedInterval(interval(1.57,1.58), dac))[2], DecoratedInterval(interval(0x1.921FB54442D18P+0,0x1.921FB54442D1AP+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.72CECE675D1FDP-53,-0x1.72CECE675D1FCP-53), IntervalArithmetic.dac), Interval(interval(1.57,1.58), IntervalArithmetic.dac))[2], Interval(interval(0x1.921FB54442D18P+0,0x1.921FB54442D1AP+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54), com), DecoratedInterval(interval(1.57,1.58), dac))[2], DecoratedInterval(interval(0x1.921FB54442D17P+0,0x1.921FB54442D1aP+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.72CECE675D1FDP-53,0x1.1A62633145C07P-54), IntervalArithmetic.com), Interval(interval(1.57,1.58), IntervalArithmetic.dac))[2], Interval(interval(0x1.921FB54442D17P+0,0x1.921FB54442D1aP+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-54,1.0), def), DecoratedInterval(interval(-2.0,2.0), com))[2], DecoratedInterval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-54,1.0), IntervalArithmetic.def), Interval(interval(-2.0,2.0), IntervalArithmetic.com))[2], Interval(interval(-0x1.921FB54442D19P+0, 0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-54,1.0), dac), DecoratedInterval(interval(0.0,2.0), def))[2], DecoratedInterval(interval(0.0,0x1.921FB54442D19P+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-54,1.0), IntervalArithmetic.dac), Interval(interval(0.0,2.0), IntervalArithmetic.def))[2], Interval(interval(0.0,0x1.921FB54442D19P+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-53,1.0), def), DecoratedInterval(interval(-0.1,1.5708), dac))[2], DecoratedInterval(interval(-0.1,0x1.921FB54442D1aP+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.72CECE675D1FDP-53,1.0), IntervalArithmetic.def), Interval(interval(-0.1,1.5708), IntervalArithmetic.dac))[2], Interval(interval(-0.1,0x1.921FB54442D1aP+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), dac), DecoratedInterval(interval(3.14,3.15), def))[2], DecoratedInterval(interval(0x1.921fb52442d18p+1,0x1.921fb56442d1ap+1), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.dac), Interval(interval(3.14,3.15), IntervalArithmetic.def))[2], Interval(interval(0x1.921fb52442d18p+1,0x1.921fb56442d1ap+1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), def), DecoratedInterval(interval(-3.15,-3.14), com))[2], DecoratedInterval(interval(-0x1.921fb56442d1ap+1,-0x1.921fb52442d18p+1), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.def), Interval(interval(-3.15,-3.14), IntervalArithmetic.com))[2], Interval(interval(-0x1.921fb56442d1ap+1,-0x1.921fb52442d18p+1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), def), DecoratedInterval(interval(9.42,9.45), dac))[2], DecoratedInterval(interval(0x1.2d97c7eb321d2p+3,0x1.2d97c7fb321d3p+3), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1P+0,-0x1.FFFFFFFFFFFFFP-1), IntervalArithmetic.def), Interval(interval(9.42,9.45), IntervalArithmetic.dac))[2], Interval(interval(0x1.2d97c7eb321d2p+3,0x1.2d97c7fb321d3p+3), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.87996529F9D92P-1,1.0), dac), DecoratedInterval(interval(-1.0,0.1), def))[2], DecoratedInterval(interval(-0x1.6666666666667p-1,0.1), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.87996529F9D92P-1,1.0), IntervalArithmetic.dac), Interval(interval(-1.0,0.1), IntervalArithmetic.def))[2], Interval(interval(-0x1.6666666666667p-1,0.1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.AA22657537205P-2,0x1.14A280FB5068CP-1), com), DecoratedInterval(interval(0.0,2.1), dac))[2], DecoratedInterval(interval(0x1.fffffffffffffp-1,0x1.0000000000001p+1), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.AA22657537205P-2,0x1.14A280FB5068CP-1), IntervalArithmetic.com), Interval(interval(0.0,2.1), IntervalArithmetic.dac))[2], Interval(interval(0x1.fffffffffffffp-1,0x1.0000000000001p+1), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), com), DecoratedInterval(interval(-Inf,1.58), dac))[2], DecoratedInterval(interval(-Inf,0x1.921FB54442D18P+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.com), Interval(interval(-Inf,1.58), IntervalArithmetic.dac))[2], Interval(interval(-Inf,0x1.921FB54442D18P+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), def), DecoratedInterval(interval(-Inf,1.5), dac))[2], DecoratedInterval(interval(-Inf,-0x1.921FB54442D17P+0), trv)) + @test isequal_interval(cos_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.def), Interval(interval(-Inf,1.5), IntervalArithmetic.dac))[2], Interval(interval(-Inf,-0x1.921FB54442D17P+0), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), dac), DecoratedInterval(interval(-1.58,Inf), dac))[2], DecoratedInterval(interval(-0x1.921fb54442d1ap+0,Inf), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), IntervalArithmetic.dac), Interval(interval(-1.58,Inf), IntervalArithmetic.dac))[2], Interval(interval(-0x1.921fb54442d1ap+0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(cos_rev(DecoratedInterval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), def), DecoratedInterval(interval(-1.5,Inf), dac))[2], DecoratedInterval(interval(0x1.921fb54442d19p+0,Inf), trv)) + @test isequal_interval(cos_rev(Interval(interval(-0x1.72CECE675D1FDP-52,-0x1.72CECE675D1FCP-52), IntervalArithmetic.def), Interval(interval(-1.5,Inf), IntervalArithmetic.dac))[2], Interval(interval(0x1.921fb54442d19p+0,Inf), IntervalArithmetic.trv)) end @testset "minimal_tan_rev_test" begin - @test isequal_interval(tan_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(tan_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(tan_rev(interval(-1.0,1.0))[2], entireinterval()) + @test isequal_interval(tan_rev(interval(-1.0,1.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(tan_rev(interval(-156.0,-12.0))[2], entireinterval()) + @test isequal_interval(tan_rev(interval(-156.0,-12.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(tan_rev(interval(0.0,0.0))[2], entireinterval()) + @test isequal_interval(tan_rev(interval(0.0,0.0))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(tan_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval()) + @test isequal_interval(tan_rev(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53))[2], entireinterval(BareInterval{Float64})) end @testset "minimal_tan_rev_bin_test" begin - @test isequal_interval(tan_rev(emptyinterval(), interval(-1.5708,1.5708))[2], emptyinterval()) + @test isequal_interval(tan_rev(emptyinterval(BareInterval{Float64}), interval(-1.5708,1.5708))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(tan_rev(entireinterval(), interval(-1.5708,1.5708))[2], interval(-1.5708,1.5708)) + @test isequal_interval(tan_rev(entireinterval(BareInterval{Float64}), interval(-1.5708,1.5708))[2], interval(-1.5708,1.5708)) @test isequal_interval(tan_rev(interval(0.0,0.0), interval(-1.5708,1.5708))[2], interval(0.0,0.0)) @@ -1194,49 +1194,49 @@ end @testset "minimal_tan_rev_dec_test" begin - @test isequal_interval(tan_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(tan_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-1.0,1.0), com))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan_rev(Interval(interval(-1.0,1.0), IntervalArithmetic.com))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-156.0,-12.0), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan_rev(Interval(interval(-156.0,-12.0), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(0.0,0.0), def))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan_rev(Interval(interval(0.0,0.0), IntervalArithmetic.def))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), com))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(tan_rev(Interval(interval(0x1.1A62633145C06P-53,0x1.1A62633145C07P-53), IntervalArithmetic.com))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end @testset "minimal_tan_rev_dec_bin_test" begin - @test isequal_interval(tan_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(-1.5708,1.5708), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(tan_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(-1.5708,1.5708), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(entireinterval(), def), DecoratedInterval(interval(-1.5708,1.5708), dac))[2], DecoratedInterval(interval(-1.5708,1.5708), trv)) + @test isequal_interval(tan_rev(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.def), Interval(interval(-1.5708,1.5708), IntervalArithmetic.dac))[2], Interval(interval(-1.5708,1.5708), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(0.0,0.0), com), DecoratedInterval(interval(-1.5708,1.5708), def))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(tan_rev(Interval(interval(0.0,0.0), IntervalArithmetic.com), Interval(interval(-1.5708,1.5708), IntervalArithmetic.def))[2], Interval(interval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53), dac), DecoratedInterval(interval(-1.5708,1.5708), def))[2], DecoratedInterval(interval(-0x1.921fb54442d1bp+0,0x1.921fb54442d19p+0), trv)) + @test isequal_interval(tan_rev(Interval(interval(0x1.D02967C31CDB4P+53,0x1.D02967C31CDB5P+53), IntervalArithmetic.dac), Interval(interval(-1.5708,1.5708), IntervalArithmetic.def))[2], Interval(interval(-0x1.921fb54442d1bp+0,0x1.921fb54442d19p+0), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53), def), DecoratedInterval(interval(3.14,3.15), dac))[2], DecoratedInterval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D19P+1), trv)) + @test isequal_interval(tan_rev(Interval(interval(-0x1.1A62633145C07P-53,-0x1.1A62633145C06P-53), IntervalArithmetic.def), Interval(interval(3.14,3.15), IntervalArithmetic.dac))[2], Interval(interval(0x1.921FB54442D17P+1,0x1.921FB54442D19P+1), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52), com), DecoratedInterval(interval(-3.15,3.15), com))[2], DecoratedInterval(interval(-0x1.921FB54442D19P+1,0x1.921FB54442D1aP+1), trv)) + @test isequal_interval(tan_rev(Interval(interval(0x1.72CECE675D1FCP-52,0x1.72CECE675D1FDP-52), IntervalArithmetic.com), Interval(interval(-3.15,3.15), IntervalArithmetic.com))[2], Interval(interval(-0x1.921FB54442D19P+1,0x1.921FB54442D1aP+1), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), def), DecoratedInterval(interval(-Inf,1.5707965), def))[2], DecoratedInterval(interval(-Inf,0x1.921FB82C2BD7Fp0), trv)) + @test isequal_interval(tan_rev(Interval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), IntervalArithmetic.def), Interval(interval(-Inf,1.5707965), IntervalArithmetic.def))[2], Interval(interval(-Inf,0x1.921FB82C2BD7Fp0), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), com), DecoratedInterval(interval(-1.5707965,Inf), dac))[2], DecoratedInterval(interval(-0x1.921FB82C2BD7Fp0,Inf), trv)) + @test isequal_interval(tan_rev(Interval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), IntervalArithmetic.com), Interval(interval(-1.5707965,Inf), IntervalArithmetic.dac))[2], Interval(interval(-0x1.921FB82C2BD7Fp0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), com), DecoratedInterval(interval(-1.5707965,1.5707965), com))[2], DecoratedInterval(interval(-0x1.921FB82C2BD7Fp0,0x1.921FB82C2BD7Fp0), trv)) + @test isequal_interval(tan_rev(Interval(interval(-0x1.D02967C31p+53,0x1.D02967C31p+53), IntervalArithmetic.com), Interval(interval(-1.5707965,1.5707965), IntervalArithmetic.com))[2], Interval(interval(-0x1.921FB82C2BD7Fp0,0x1.921FB82C2BD7Fp0), IntervalArithmetic.trv)) - @test isequal_interval(tan_rev(DecoratedInterval(interval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53), dac), DecoratedInterval(interval(-1.5707965,1.5707965), def))[2], DecoratedInterval(interval(-1.5707965,1.5707965), trv)) + @test isequal_interval(tan_rev(Interval(interval(-0x1.D02967C31CDB5P+53,0x1.D02967C31CDB5P+53), IntervalArithmetic.dac), Interval(interval(-1.5707965,1.5707965), IntervalArithmetic.def))[2], Interval(interval(-1.5707965,1.5707965), IntervalArithmetic.trv)) end @testset "minimal_cosh_rev_test" begin - @test isequal_interval(cosh_rev(emptyinterval())[2], emptyinterval()) + @test isequal_interval(cosh_rev(emptyinterval(BareInterval{Float64}))[2], emptyinterval(BareInterval{Float64})) - @test isequal_interval(cosh_rev(interval(1.0,Inf))[2], entireinterval()) + @test isequal_interval(cosh_rev(interval(1.0,Inf))[2], entireinterval(BareInterval{Float64})) - @test isequal_interval(cosh_rev(interval(0.0,Inf))[2], entireinterval()) + @test isequal_interval(cosh_rev(interval(0.0,Inf))[2], entireinterval(BareInterval{Float64})) @test isequal_interval(cosh_rev(interval(1.0,1.0))[2], interval(0.0,0.0)) @@ -1246,13 +1246,13 @@ end @testset "minimal_cosh_rev_bin_test" begin - @test isequal_interval(cosh_rev(emptyinterval(), interval(0.0,Inf))[2], emptyinterval()) + @test isequal_interval(cosh_rev(emptyinterval(BareInterval{Float64}), interval(0.0,Inf))[2], emptyinterval(BareInterval{Float64})) @test isequal_interval(cosh_rev(interval(1.0,Inf), interval(0.0,Inf))[2], interval(0.0,Inf)) @test isequal_interval(cosh_rev(interval(0.0,Inf), interval(1.0,2.0))[2], interval(1.0,2.0)) - @test isequal_interval(cosh_rev(interval(1.0,1.0), interval(1.0,Inf))[2], emptyinterval()) + @test isequal_interval(cosh_rev(interval(1.0,1.0), interval(1.0,Inf))[2], emptyinterval(BareInterval{Float64})) @test isequal_interval(cosh_rev(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), interval(-Inf,0.0))[2], interval(-0x1.2C903022DD7ABP+8,-0x1.fffffffffffffp-1)) @@ -1260,383 +1260,383 @@ end @testset "minimal_cosh_rev_dec_test" begin - @test isequal_interval(cosh_rev(DecoratedInterval(emptyinterval(), trv))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cosh_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(1.0,Inf), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cosh_rev(Interval(interval(1.0,Inf), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(0.0,Inf), dac))[2], DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(cosh_rev(Interval(interval(0.0,Inf), IntervalArithmetic.dac))[2], Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(1.0,1.0), def))[2], DecoratedInterval(interval(0.0,0.0), trv)) + @test isequal_interval(cosh_rev(Interval(interval(1.0,1.0), IntervalArithmetic.def))[2], Interval(interval(0.0,0.0), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), com))[2], DecoratedInterval(interval(-0x1.2C903022DD7ABP+8,0x1.2C903022DD7ABP+8), trv)) + @test isequal_interval(cosh_rev(Interval(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), IntervalArithmetic.com))[2], Interval(interval(-0x1.2C903022DD7ABP+8,0x1.2C903022DD7ABP+8), IntervalArithmetic.trv)) end @testset "minimal_cosh_rev_dec_bin_test" begin - @test isequal_interval(cosh_rev(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(interval(0.0,Inf), dac))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cosh_rev(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(interval(0.0,Inf), IntervalArithmetic.dac))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(1.0,Inf), def), DecoratedInterval(interval(0.0,Inf), dac))[2], DecoratedInterval(interval(0.0,Inf), trv)) + @test isequal_interval(cosh_rev(Interval(interval(1.0,Inf), IntervalArithmetic.def), Interval(interval(0.0,Inf), IntervalArithmetic.dac))[2], Interval(interval(0.0,Inf), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(0.0,Inf), def), DecoratedInterval(interval(1.0,2.0), com))[2], DecoratedInterval(interval(1.0,2.0), trv)) + @test isequal_interval(cosh_rev(Interval(interval(0.0,Inf), IntervalArithmetic.def), Interval(interval(1.0,2.0), IntervalArithmetic.com))[2], Interval(interval(1.0,2.0), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(1.0,1.0), dac), DecoratedInterval(interval(1.0,Inf), def))[2], DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(cosh_rev(Interval(interval(1.0,1.0), IntervalArithmetic.dac), Interval(interval(1.0,Inf), IntervalArithmetic.def))[2], Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(cosh_rev(DecoratedInterval(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), com), DecoratedInterval(interval(-Inf,0.0), dac))[2], DecoratedInterval(interval(-0x1.2C903022DD7ABP+8,-0x1.fffffffffffffp-1), trv)) + @test isequal_interval(cosh_rev(Interval(interval(0x1.8B07551D9F55P+0,0x1.89BCA168970C6P+432), IntervalArithmetic.com), Interval(interval(-Inf,0.0), IntervalArithmetic.dac))[2], Interval(interval(-0x1.2C903022DD7ABP+8,-0x1.fffffffffffffp-1), IntervalArithmetic.trv)) end @testset "minimal_mul_rev_test" begin - @test isequal_interval(mul_rev_IEEE1788(emptyinterval(), interval(1.0, 2.0)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(emptyinterval(BareInterval{Float64}), interval(1.0, 2.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(1.0, 2.0), emptyinterval()), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(1.0, 2.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-2.1, -0.4)), interval(0x1.999999999999AP-3, 0x1.5P+4)) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-2.1, -0.4)), interval(0x1.999999999999AP-3, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, -0.4)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, -0.4)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-2.1, -0.4)), interval(-Inf, -0x1.745D1745D1745P-2)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-2.1, -0.4)), interval(-0x1.A400000000001P+7, -0x1.745D1745D1745P-2)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, -0.4)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, -0.4)), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-2.1, -0.4)), interval(0.0, 0x1.5P+4)) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-2.1, -0.4)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, -0.4)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, -0.4)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, -0.4)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, -0.4)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-2.1, -0.4)), interval(-Inf, 0.0)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-2.1, -0.4)), interval(-0x1.A400000000001P+7, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-2.1, -0.4)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-2.1, -0.4)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-2.1, 0.0)), interval(0.0, 0x1.5P+4)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-2.1, 0.0)), interval(-0x1.A400000000001P+7, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-2.1, 0.0)), interval(0.0, 0x1.5P+4)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-2.1, 0.0)), interval(-0x1.A400000000001P+7, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-2.1, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-2.1, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-2.1, 0.12)), interval(-0x1.3333333333333P+0, 0x1.5P+4)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-2.1, 0.12)), interval(-0x1.A400000000001P+7 , 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-2.1, 0.12)), interval(-0x1.3333333333333P+0, 0x1.5P+4)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-2.1, 0.12)), interval(-0x1.A400000000001P+7 , 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-2.1, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-2.1, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(0.0, 0.12)), interval(-0x1.3333333333333P+0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(0.0, 0.12)), interval(0.0, 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(0.0, 0.12)), interval(-0x1.3333333333333P+0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(0.0, 0.12)), interval(0.0, 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(0.0, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(0.0, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(0.01, 0.12)), interval(-0x1.3333333333333P+0, -0x1.47AE147AE147BP-8)) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.01, 0.12)), interval(-Inf, -0x1.47AE147AE147BP-8)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.01, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.01, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.01, 0.12)), interval(0x1.29E4129E4129DP-7, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(0.01, 0.12)), interval(0x1.29E4129E4129DP-7, 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.01, 0.12)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.01, 0.12)), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(0.01, 0.12)), interval(-0x1.3333333333333P+0, 0.0)) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.01, 0.12)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.01, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.01, 0.12)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.01, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.01, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.01, 0.12)), interval(0.0, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(0.01, 0.12)), interval(0.0, 0x1.8P+3)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(0.01, 0.12)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(0.01, 0.12)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(0.0, 0.0)), interval(0.0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(0.0, 0.0)), interval(0.0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(0.0, 0.0)), interval(0.0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(0.0, 0.0)), interval(0.0, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(0.0, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(0.0, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-Inf, -0.1)), interval(0x1.999999999999AP-5, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-Inf, -0.1)), interval(0x1.999999999999AP-5 , Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, -0.1)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, -0.1)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-Inf, -0.1)), interval(-Inf, -0x1.745D1745D1745P-4)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-Inf, -0.1)), interval(-Inf, -0x1.745D1745D1745P-4)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, -0.1)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, -0.1)), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-Inf, -0.1)), interval(0.0, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-Inf, -0.1)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, -0.1)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, -0.1)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, -0.1)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, -0.1)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-Inf, -0.1)), interval(-Inf, 0.0)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-Inf, -0.1)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-Inf, -0.1)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-Inf, -0.1)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-Inf, 0.0)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-Inf, 0.0)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-Inf, 0.0)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-Inf, 0.0)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-Inf, 0.3)), interval(-0x1.8P+1, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-Inf, 0.3)), interval(-Inf, 0x1.EP+4)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-Inf, 0.3)), interval(-0x1.8P+1, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-Inf, 0.3)), interval(-Inf, 0x1.EP+4)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-Inf, 0.3)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-Inf, 0.3)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-0.21, Inf)), interval(-Inf , 0x1.0CCCCCCCCCCCDP+1)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(-0.21, Inf)), interval(-0x1.5P+4, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(-0.21, Inf)), interval(-Inf, 0x1.0CCCCCCCCCCCDP+1)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(-0.21, Inf)), interval(-0x1.5P+4, Inf)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(-0.21, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(-0.21, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(0.0, Inf)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(0.0, Inf)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(0.0, Inf)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(0.0, Inf)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(0.0, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(0.0, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(0.04, Inf)), interval(-Inf, -0x1.47AE147AE147BP-6)) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), interval(0.04, Inf)), interval(-Inf, -0x1.47AE147AE147BP-6)) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.04, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(0.04, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), interval(0.04, Inf)), interval(0x1.29E4129E4129DP-5, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), interval(0.04, Inf)), interval(0x1.29E4129E4129DP-5, Inf)) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.04, Inf)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), interval(0.04, Inf)), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), interval(0.04, Inf)), interval(-Inf, 0.0)) @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), interval(0.04, Inf)), interval(-Inf, 0.0)) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.04, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), interval(0.04, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.04, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), interval(0.04, Inf)), entireinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), interval(0.04, Inf)), interval(0.0, Inf)) @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), interval(0.04, Inf)), interval(0.0, Inf)) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), interval(0.04, Inf)), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), interval(0.04, Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 1.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.01, 1.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, -0.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-Inf, 1.1), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.0, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(0.01, Inf), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(mul_rev_IEEE1788(entireinterval(), entireinterval()), entireinterval()) + @test isequal_interval(mul_rev_IEEE1788(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) end @testset "minimal_mul_rev_ten_test" begin - @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-2.1, -0.4), interval(-2.1, -0.4)), emptyinterval()) + @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, -0.1), interval(-2.1, -0.4), interval(-2.1, -0.4)), emptyinterval(BareInterval{Float64})) @test isequal_interval(mul_rev_IEEE1788(interval(-2.0, 1.1), interval(-2.1, -0.4), interval(-2.1, -0.4)), interval(-2.1, -0.4)) @@ -1650,38 +1650,38 @@ end @testset "minimal_mul_rev_dec_test" begin - @test isnai(mul_rev_IEEE1788(nai(), DecoratedInterval(interval(1.0,2.0), dac))) + @test isnai(mul_rev_IEEE1788(nai(), Interval(interval(1.0,2.0), IntervalArithmetic.dac))) - @test isnai(mul_rev_IEEE1788(DecoratedInterval(interval(1.0,2.0), dac), nai())) + @test isnai(mul_rev_IEEE1788(Interval(interval(1.0,2.0), IntervalArithmetic.dac), nai())) @test isnai(mul_rev_IEEE1788(nai(), nai())) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-2.1, -0.4), dac)), DecoratedInterval(interval(0x1.999999999999AP-3, 0x1.5P+4), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, -0.1), IntervalArithmetic.dac), Interval(interval(-2.1, -0.4), IntervalArithmetic.dac)), Interval(interval(0x1.999999999999AP-3, 0x1.5P+4), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, -0.1), def), DecoratedInterval(interval(-2.1, 0.0), def)), DecoratedInterval(interval(0.0, 0x1.5P+4), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, -0.1), IntervalArithmetic.def), Interval(interval(-2.1, 0.0), IntervalArithmetic.def)), Interval(interval(0.0, 0x1.5P+4), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, -0.1), com), DecoratedInterval(interval(-2.1, 0.12), dac)), DecoratedInterval(interval(-0x1.3333333333333P+0, 0x1.5P+4), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, -0.1), IntervalArithmetic.com), Interval(interval(-2.1, 0.12), IntervalArithmetic.dac)), Interval(interval(-0x1.3333333333333P+0, 0x1.5P+4), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.12), com)), DecoratedInterval(interval(-0x1.3333333333333P+0, 0.0), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-Inf, -0.1), IntervalArithmetic.dac), Interval(interval(0.0, 0.12), IntervalArithmetic.com)), Interval(interval(-0x1.3333333333333P+0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(0.01, 1.1), def), DecoratedInterval(interval(0.01, 0.12), dac)), DecoratedInterval(interval(0x1.29E4129E4129DP-7, 0x1.8P+3), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(0.01, 1.1), IntervalArithmetic.def), Interval(interval(0.01, 0.12), IntervalArithmetic.dac)), Interval(interval(0x1.29E4129E4129DP-7, 0x1.8P+3), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(0.01, 1.1), dac), DecoratedInterval(interval(-Inf, 0.3), def)), DecoratedInterval(interval(-Inf, 0x1.EP+4), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(0.01, 1.1), IntervalArithmetic.dac), Interval(interval(-Inf, 0.3), IntervalArithmetic.def)), Interval(interval(-Inf, 0x1.EP+4), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-Inf, -0.1), trv), DecoratedInterval(interval(-0.21, Inf), dac)), DecoratedInterval(interval(-Inf, 0x1.0CCCCCCCCCCCDP+1), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-Inf, -0.1), IntervalArithmetic.trv), Interval(interval(-0.21, Inf), IntervalArithmetic.dac)), Interval(interval(-Inf, 0x1.0CCCCCCCCCCCDP+1), IntervalArithmetic.trv)) end @testset "minimal_mul_rev_dec_ten_test" begin - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, -0.1), dac), DecoratedInterval(interval(-2.1, -0.4), dac), DecoratedInterval(interval(-2.1, -0.4), dac)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, -0.1), IntervalArithmetic.dac), Interval(interval(-2.1, -0.4), IntervalArithmetic.dac), Interval(interval(-2.1, -0.4), IntervalArithmetic.dac)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, 1.1), def), DecoratedInterval(interval(-2.1, -0.4), com), DecoratedInterval(interval(-2.1, -0.4), com)), DecoratedInterval(interval(-2.1, -0.4), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, 1.1), IntervalArithmetic.def), Interval(interval(-2.1, -0.4), IntervalArithmetic.com), Interval(interval(-2.1, -0.4), IntervalArithmetic.com)), Interval(interval(-2.1, -0.4), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(0.01, 1.1), com), DecoratedInterval(interval(-2.1, 0.0), dac), DecoratedInterval(interval(-2.1, 0.0), dac)), DecoratedInterval(interval(-2.1,0.0), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(0.01, 1.1), IntervalArithmetic.com), Interval(interval(-2.1, 0.0), IntervalArithmetic.dac), Interval(interval(-2.1, 0.0), IntervalArithmetic.dac)), Interval(interval(-2.1,0.0), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-Inf, -0.1), dac), DecoratedInterval(interval(0.0, 0.12), com), DecoratedInterval(interval(0.0, 0.12), com)), DecoratedInterval(interval(0.0, 0.0), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-Inf, -0.1), IntervalArithmetic.dac), Interval(interval(0.0, 0.12), IntervalArithmetic.com), Interval(interval(0.0, 0.12), IntervalArithmetic.com)), Interval(interval(0.0, 0.0), IntervalArithmetic.trv)) - @test isequal_interval(mul_rev_IEEE1788(DecoratedInterval(interval(-2.0, 1.1), def), DecoratedInterval(interval(0.04, Inf), dac), DecoratedInterval(interval(0.04, Inf), dac)), DecoratedInterval(interval(0.04, Inf), trv)) + @test isequal_interval(mul_rev_IEEE1788(Interval(interval(-2.0, 1.1), IntervalArithmetic.def), Interval(interval(0.04, Inf), IntervalArithmetic.dac), Interval(interval(0.04, Inf), IntervalArithmetic.dac)), Interval(interval(0.04, Inf), IntervalArithmetic.trv)) end diff --git a/test/test_ITF1788/libieeep1788_set.jl b/test/test_ITF1788/libieeep1788_set.jl index d5adc7a88..eee6b561c 100644 --- a/test/test_ITF1788/libieeep1788_set.jl +++ b/test/test_ITF1788/libieeep1788_set.jl @@ -1,55 +1,55 @@ @testset "minimal_intersection_test" begin - @test isequal_interval(intersect_interval(interval(1.0,3.0), interval(2.1,4.0)), interval(2.1,3.0)) + @test isequal_interval(intersect_interval(bareinterval(1.0,3.0), bareinterval(2.1,4.0)), bareinterval(2.1,3.0)) - @test isequal_interval(intersect_interval(interval(1.0,3.0), interval(3.0,4.0)), interval(3.0,3.0)) + @test isequal_interval(intersect_interval(bareinterval(1.0,3.0), bareinterval(3.0,4.0)), bareinterval(3.0,3.0)) - @test isequal_interval(intersect_interval(interval(1.0,3.0), emptyinterval()), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(1.0,3.0), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(entireinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(intersect_interval(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(1.0,3.0), entireinterval()), interval(1.0,3.0)) + @test isequal_interval(intersect_interval(bareinterval(1.0,3.0), entireinterval(BareInterval{Float64})), bareinterval(1.0,3.0)) end @testset "minimal_intersection_dec_test" begin - @test isequal_interval(intersect_interval(DecoratedInterval(interval(1.0,3.0), com), DecoratedInterval(interval(2.1,4.0), com)), DecoratedInterval(interval(2.1,3.0), trv)) + @test isequal_interval(intersect_interval(Interval(bareinterval(1.0,3.0), IntervalArithmetic.com), Interval(bareinterval(2.1,4.0), IntervalArithmetic.com)), Interval(bareinterval(2.1,3.0), IntervalArithmetic.trv)) - @test isequal_interval(intersect_interval(DecoratedInterval(interval(1.0,3.0), dac), DecoratedInterval(interval(3.0,4.0), def)), DecoratedInterval(interval(3.0,3.0), trv)) + @test isequal_interval(intersect_interval(Interval(bareinterval(1.0,3.0), IntervalArithmetic.dac), Interval(bareinterval(3.0,4.0), IntervalArithmetic.def)), Interval(bareinterval(3.0,3.0), IntervalArithmetic.trv)) - @test isequal_interval(intersect_interval(DecoratedInterval(interval(1.0,3.0), def), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(intersect_interval(Interval(bareinterval(1.0,3.0), IntervalArithmetic.def), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(intersect_interval(DecoratedInterval(entireinterval(), dac), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(intersect_interval(Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(intersect_interval(DecoratedInterval(interval(1.0,3.0), dac), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(interval(1.0,3.0), trv)) + @test isequal_interval(intersect_interval(Interval(bareinterval(1.0,3.0), IntervalArithmetic.dac), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv)) end @testset "minimal_convex_convexhull_test" begin - @test isequal_interval(hull(interval(1.0,3.0), interval(2.1,4.0)), interval(1.0,4.0)) + @test isequal_interval(hull(bareinterval(1.0,3.0), bareinterval(2.1,4.0)), bareinterval(1.0,4.0)) - @test isequal_interval(hull(interval(1.0,1.0), interval(2.1,4.0)), interval(1.0,4.0)) + @test isequal_interval(hull(bareinterval(1.0,1.0), bareinterval(2.1,4.0)), bareinterval(1.0,4.0)) - @test isequal_interval(hull(interval(1.0,3.0), emptyinterval()), interval(1.0,3.0)) + @test isequal_interval(hull(bareinterval(1.0,3.0), emptyinterval(BareInterval{Float64})), bareinterval(1.0,3.0)) - @test isequal_interval(hull(emptyinterval(), emptyinterval()), emptyinterval()) + @test isequal_interval(hull(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})), emptyinterval(BareInterval{Float64})) - @test isequal_interval(hull(interval(1.0,3.0), entireinterval()), entireinterval()) + @test isequal_interval(hull(bareinterval(1.0,3.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) end @testset "minimal_convex_convexhull_dec_test" begin - @test isequal_interval(hull(DecoratedInterval(interval(1.0,3.0), trv), DecoratedInterval(interval(2.1,4.0), trv)), DecoratedInterval(interval(1.0,4.0), trv)) + @test isequal_interval(hull(Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv), Interval(bareinterval(2.1,4.0), IntervalArithmetic.trv)), Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv)) - @test isequal_interval(hull(DecoratedInterval(interval(1.0,1.0), trv), DecoratedInterval(interval(2.1,4.0), trv)), DecoratedInterval(interval(1.0,4.0), trv)) + @test isequal_interval(hull(Interval(bareinterval(1.0,1.0), IntervalArithmetic.trv), Interval(bareinterval(2.1,4.0), IntervalArithmetic.trv)), Interval(bareinterval(1.0,4.0), IntervalArithmetic.trv)) - @test isequal_interval(hull(DecoratedInterval(interval(1.0,3.0), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(interval(1.0,3.0), trv)) + @test isequal_interval(hull(Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv)) - @test isequal_interval(hull(DecoratedInterval(emptyinterval(), trv), DecoratedInterval(emptyinterval(), trv)), DecoratedInterval(emptyinterval(), trv)) + @test isequal_interval(hull(Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)), Interval(emptyinterval(BareInterval{Float64}), IntervalArithmetic.trv)) - @test isequal_interval(hull(DecoratedInterval(interval(1.0,3.0), trv), DecoratedInterval(entireinterval(), dac)), DecoratedInterval(entireinterval(), trv)) + @test isequal_interval(hull(Interval(bareinterval(1.0,3.0), IntervalArithmetic.trv), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.dac)), Interval(entireinterval(BareInterval{Float64}), IntervalArithmetic.trv)) end diff --git a/test/test_ITF1788/mpfi.jl b/test/test_ITF1788/mpfi.jl index e71593ae6..80a84ac59 100644 --- a/test/test_ITF1788/mpfi.jl +++ b/test/test_ITF1788/mpfi.jl @@ -1,2991 +1,2991 @@ @testset "mpfi_abs" begin - @test isequal_interval(abs(interval(-Inf, -7.0)), interval(+7.0, +Inf)) + @test isequal_interval(abs(bareinterval(-Inf, -7.0)), bareinterval(+7.0, +Inf)) - @test isequal_interval(abs(interval(-Inf, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(abs(bareinterval(-Inf, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(interval(-Inf, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(abs(bareinterval(-Inf, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(interval(-Inf, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(abs(bareinterval(-Inf, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(entireinterval()), interval(0.0, +Inf)) + @test isequal_interval(abs(entireinterval(BareInterval{Float64})), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(abs(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(abs(interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(abs(bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(abs(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(abs(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(abs(bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(abs(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(abs(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(abs(interval(0x123456789p-16, 0x123456799p-16)), interval(0x123456789p-16, 0x123456799p-16)) + @test isequal_interval(abs(bareinterval(0x123456789p-16, 0x123456799p-16)), bareinterval(0x123456789p-16, 0x123456799p-16)) - @test isequal_interval(abs(interval(-0x123456789p-16, 0x123456799p-16)), interval(0.0, 0x123456799p-16)) + @test isequal_interval(abs(bareinterval(-0x123456789p-16, 0x123456799p-16)), bareinterval(0.0, 0x123456799p-16)) end @testset "mpfi_acos" begin - @test isequal_interval(acos(interval(-1.0, 0.0)), interval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-51)) + @test isequal_interval(acos(bareinterval(-1.0, 0.0)), bareinterval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-51)) - @test isequal_interval(acos(interval(0.0, 0.0)), interval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-52)) + @test isequal_interval(acos(bareinterval(0.0, 0.0)), bareinterval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-52)) - @test isequal_interval(acos(interval(0.0, +1.0)), interval(0.0, 0x1921fb54442d19p-52)) + @test isequal_interval(acos(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x1921fb54442d19p-52)) - @test isequal_interval(acos(interval(-1.0, -0.5)), interval(0x10c152382d7365p-51, 0x1921fb54442d19p-51)) + @test isequal_interval(acos(bareinterval(-1.0, -0.5)), bareinterval(0x10c152382d7365p-51, 0x1921fb54442d19p-51)) - @test isequal_interval(acos(interval(-0.75, -0.25)), interval(0x1d2cf5c7c70f0bp-52, 0x4d6749be4edb1p-49)) + @test isequal_interval(acos(bareinterval(-0.75, -0.25)), bareinterval(0x1d2cf5c7c70f0bp-52, 0x4d6749be4edb1p-49)) - @test isequal_interval(acos(interval(-0.5, 0.5)), interval(0x10c152382d7365p-52, 0x860a91c16b9b3p-50)) + @test isequal_interval(acos(bareinterval(-0.5, 0.5)), bareinterval(0x10c152382d7365p-52, 0x860a91c16b9b3p-50)) - @test isequal_interval(acos(interval(0.25, 0.625)), interval(0x1ca94936b98a21p-53, 0x151700e0c14b25p-52)) + @test isequal_interval(acos(bareinterval(0.25, 0.625)), bareinterval(0x1ca94936b98a21p-53, 0x151700e0c14b25p-52)) - @test isequal_interval(acos(interval(-1.0, 1.0)), interval(0.0, 0x1921fb54442d19p-51)) + @test isequal_interval(acos(bareinterval(-1.0, 1.0)), bareinterval(0.0, 0x1921fb54442d19p-51)) end @testset "mpfi_acosh" begin - @test isequal_interval(acosh(interval(+1.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(acosh(bareinterval(+1.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(acosh(interval(+1.5, +Inf)), interval(0x1ecc2caec51609p-53, +Inf)) + @test isequal_interval(acosh(bareinterval(+1.5, +Inf)), bareinterval(0x1ecc2caec51609p-53, +Inf)) - @test isequal_interval(acosh(interval(1.0, 1.5)), interval(0.0, 0xf661657628b05p-52)) + @test isequal_interval(acosh(bareinterval(1.0, 1.5)), bareinterval(0.0, 0xf661657628b05p-52)) - @test isequal_interval(acosh(interval(1.5, 1.5)), interval(0x1ecc2caec51609p-53, 0xf661657628b05p-52)) + @test isequal_interval(acosh(bareinterval(1.5, 1.5)), bareinterval(0x1ecc2caec51609p-53, 0xf661657628b05p-52)) - @test isequal_interval(acosh(interval(2.0, 1000.0)), interval(0x544909c66010dp-50, 0x799d4ba2a13b5p-48)) + @test isequal_interval(acosh(bareinterval(2.0, 1000.0)), bareinterval(0x544909c66010dp-50, 0x799d4ba2a13b5p-48)) end @testset "mpfi_add" begin - @test isequal_interval(+(interval(-Inf, -7.0), interval(-1.0, +8.0)), interval(-Inf, +1.0)) + @test isequal_interval(+(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), bareinterval(-Inf, +1.0)) - @test isequal_interval(+(interval(-Inf, 0.0), interval(+8.0, +Inf)), entireinterval()) + @test isequal_interval(+(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(-Inf, +16.0)) + @test isequal_interval(+(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(-Inf, +16.0)) - @test isequal_interval(+(entireinterval(), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(-Inf, -7.0)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(-Inf, -7.0)) - @test isequal_interval(+(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(-7.0, +8.0)) + @test isequal_interval(+(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(-7.0, +8.0)) - @test isequal_interval(+(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(+(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(+(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(+(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(+8.0, +Inf)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(+8.0, +Inf)) - @test isequal_interval(+(interval(0.0, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(+(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(0.0, +8.0), interval(0.0, +8.0)), interval(0.0, +16.0)) + @test isequal_interval(+(bareinterval(0.0, +8.0), bareinterval(0.0, +8.0)), bareinterval(0.0, +16.0)) - @test isequal_interval(+(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(+(interval(0.0, +Inf), interval(-7.0, +8.0)), interval(-7.0, +Inf)) + @test isequal_interval(+(bareinterval(0.0, +Inf), bareinterval(-7.0, +8.0)), bareinterval(-7.0, +Inf)) - @test isequal_interval(+(interval(-0.375, -0x10187p-256), interval(-0.125, 0x1p-240)), interval(-0x1p-1, -0x187p-256)) + @test isequal_interval(+(bareinterval(-0.375, -0x10187p-256), bareinterval(-0.125, 0x1p-240)), bareinterval(-0x1p-1, -0x187p-256)) - @test isequal_interval(+(interval(-0x1p-300, 0x123456p+28), interval(-0x10000000000000p-93, 0x789abcdp0)), interval(-0x10000000000001p-93, 0x123456789abcdp0)) + @test isequal_interval(+(bareinterval(-0x1p-300, 0x123456p+28), bareinterval(-0x10000000000000p-93, 0x789abcdp0)), bareinterval(-0x10000000000001p-93, 0x123456789abcdp0)) - @test isequal_interval(+(interval(-4.0, +7.0), interval(-0x123456789abcdp-17, 3e300)), interval(-0x123456791abcdp-17, 0x8f596b3002c1bp+947)) + @test isequal_interval(+(bareinterval(-4.0, +7.0), bareinterval(-0x123456789abcdp-17, 3e300)), bareinterval(-0x123456791abcdp-17, 0x8f596b3002c1bp+947)) - @test isequal_interval(+(interval(0x1000100010001p+8, 0x1p+60), interval(0x1000100010001p0, 3.0e300)), interval(+0x1010101010101p+8, 0x8f596b3002c1bp+947)) + @test isequal_interval(+(bareinterval(0x1000100010001p+8, 0x1p+60), bareinterval(0x1000100010001p0, 3.0e300)), bareinterval(+0x1010101010101p+8, 0x8f596b3002c1bp+947)) - @test isequal_interval(+(interval(+4.0, +8.0), interval(-4.0, -2.0)), interval(0.0, +6.0)) + @test isequal_interval(+(bareinterval(+4.0, +8.0), bareinterval(-4.0, -2.0)), bareinterval(0.0, +6.0)) - @test isequal_interval(+(interval(+4.0, +8.0), interval(-9.0, -8.0)), interval(-5.0, 0.0)) + @test isequal_interval(+(bareinterval(+4.0, +8.0), bareinterval(-9.0, -8.0)), bareinterval(-5.0, 0.0)) end @testset "mpfi_add_d" begin - @test isequal_interval(+(interval(-Inf, -7.0), interval(-0x170ef54646d497p-107, -0x170ef54646d497p-107)), interval(-Inf, -7.0)) + @test isequal_interval(+(bareinterval(-Inf, -7.0), bareinterval(-0x170ef54646d497p-107, -0x170ef54646d497p-107)), bareinterval(-Inf, -7.0)) - @test isequal_interval(+(interval(-Inf, -7.0), interval(0.0, 0.0)), interval(-Inf, -7.0)) + @test isequal_interval(+(bareinterval(-Inf, -7.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, -7.0)) - @test isequal_interval(+(interval(-Inf, -7.0), interval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), interval(-Inf, -0x1bffffffffffffp-50)) + @test isequal_interval(+(bareinterval(-Inf, -7.0), bareinterval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), bareinterval(-Inf, -0x1bffffffffffffp-50)) - @test isequal_interval(+(interval(-Inf, 0.0), interval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), interval(-Inf, -8.0e-17)) + @test isequal_interval(+(bareinterval(-Inf, 0.0), bareinterval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), bareinterval(-Inf, -8.0e-17)) - @test isequal_interval(+(interval(-Inf, 0.0), interval(0.0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(+(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(+(interval(-Inf, 0.0), interval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), interval(-Inf, 0x170ef54646d497p-106)) + @test isequal_interval(+(bareinterval(-Inf, 0.0), bareinterval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), bareinterval(-Inf, 0x170ef54646d497p-106)) - @test isequal_interval(+(interval(-Inf, 8.0), interval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), interval(-Inf, -0x16345785d89fff00p0)) + @test isequal_interval(+(bareinterval(-Inf, 8.0), bareinterval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), bareinterval(-Inf, -0x16345785d89fff00p0)) - @test isequal_interval(+(interval(-Inf, 8.0), interval(0.0, 0.0)), interval(-Inf, 8.0)) + @test isequal_interval(+(bareinterval(-Inf, 8.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, 8.0)) - @test isequal_interval(+(interval(-Inf, 8.0), interval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), interval(-Inf, 0x16345785d8a00100p0)) + @test isequal_interval(+(bareinterval(-Inf, 8.0), bareinterval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), bareinterval(-Inf, 0x16345785d8a00100p0)) - @test isequal_interval(+(entireinterval(), interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), interval(0.0e-17, 0.0e-17)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(0.0e-17, 0.0e-17)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(entireinterval(), interval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(+(entireinterval(BareInterval{Float64}), bareinterval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(+(interval(0.0, 0.0), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) - @test isequal_interval(+(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(+(interval(0.0, 0.0), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)) + @test isequal_interval(+(bareinterval(0.0, 0.0), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)) - @test isequal_interval(+(interval(0.0, 8.0), interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), interval(-0x114b37f4b51f71p-107, 8.0)) + @test isequal_interval(+(bareinterval(0.0, 8.0), bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), bareinterval(-0x114b37f4b51f71p-107, 8.0)) - @test isequal_interval(+(interval(0.0, 8.0), interval(0.0, 0.0)), interval(0.0, 8.0)) + @test isequal_interval(+(bareinterval(0.0, 8.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 8.0)) - @test isequal_interval(+(interval(0.0, 8.0), interval(0x114b37f4b51f7p-103, 0x114b37f4b51f7p-103)), interval(0x114b37f4b51f7p-103, 0x10000000000001p-49)) + @test isequal_interval(+(bareinterval(0.0, 8.0), bareinterval(0x114b37f4b51f7p-103, 0x114b37f4b51f7p-103)), bareinterval(0x114b37f4b51f7p-103, 0x10000000000001p-49)) - @test isequal_interval(+(interval(0.0, +Inf), interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), interval(-0x50b45a75f7e81p-104, +Inf)) + @test isequal_interval(+(bareinterval(0.0, +Inf), bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), bareinterval(-0x50b45a75f7e81p-104, +Inf)) - @test isequal_interval(+(interval(0.0, +Inf), interval(0.0, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(+(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(+(interval(0.0, +Inf), interval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), interval(0x142d169d7dfa03p-106, +Inf)) + @test isequal_interval(+(bareinterval(0.0, +Inf), bareinterval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), bareinterval(0x142d169d7dfa03p-106, +Inf)) - @test isequal_interval(+(interval(-32.0, -17.0), interval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47)), interval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) + @test isequal_interval(+(bareinterval(-32.0, -17.0), bareinterval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47)), bareinterval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) - @test isequal_interval(+(interval(-0xfb53d14aa9c2fp-47, -17.0), interval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47)), interval(0.0, 0x7353d14aa9c2fp-47)) + @test isequal_interval(+(bareinterval(-0xfb53d14aa9c2fp-47, -17.0), bareinterval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47)), bareinterval(0.0, 0x7353d14aa9c2fp-47)) - @test isequal_interval(+(interval(-32.0, -0xfb53d14aa9c2fp-48), interval(0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48)), interval(-0x104ac2eb5563d1p-48, 0.0)) + @test isequal_interval(+(bareinterval(-32.0, -0xfb53d14aa9c2fp-48), bareinterval(0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48)), bareinterval(-0x104ac2eb5563d1p-48, 0.0)) - @test isequal_interval(+(interval(0x123456789abcdfp-48, 0x123456789abcdfp-4), interval(3.5, 3.5)), interval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) + @test isequal_interval(+(bareinterval(0x123456789abcdfp-48, 0x123456789abcdfp-4), bareinterval(3.5, 3.5)), bareinterval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) - @test isequal_interval(+(interval(0x123456789abcdfp-56, 0x123456789abcdfp-4), interval(3.5, 3.5)), interval(0x3923456789abcdp-52, 0x123456789abd17p-4)) + @test isequal_interval(+(bareinterval(0x123456789abcdfp-56, 0x123456789abcdfp-4), bareinterval(3.5, 3.5)), bareinterval(0x3923456789abcdp-52, 0x123456789abd17p-4)) - @test isequal_interval(+(interval(-0xffp0, 0x123456789abcdfp-52), interval(256.5, 256.5)), interval(0x18p-4, 0x101a3456789abdp-44)) + @test isequal_interval(+(bareinterval(-0xffp0, 0x123456789abcdfp-52), bareinterval(256.5, 256.5)), bareinterval(0x18p-4, 0x101a3456789abdp-44)) - @test isequal_interval(+(interval(-0x1fffffffffffffp-52, -0x1p-550), interval(4097.5, 4097.5)), interval(0xfff8p-4, 0x10018p-4)) + @test isequal_interval(+(bareinterval(-0x1fffffffffffffp-52, -0x1p-550), bareinterval(4097.5, 4097.5)), bareinterval(0xfff8p-4, 0x10018p-4)) - @test isequal_interval(+(interval(0x123456789abcdfp-48, 0x123456789abcdfp-4), interval(-3.5, -3.5)), interval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) + @test isequal_interval(+(bareinterval(0x123456789abcdfp-48, 0x123456789abcdfp-4), bareinterval(-3.5, -3.5)), bareinterval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) - @test isequal_interval(+(interval(0x123456789abcdfp-56, 0x123456789abcdfp-4), interval(-3.5, -3.5)), interval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) + @test isequal_interval(+(bareinterval(0x123456789abcdfp-56, 0x123456789abcdfp-4), bareinterval(-3.5, -3.5)), bareinterval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) - @test isequal_interval(+(interval(-0xffp0, 0x123456789abcdfp-52), interval(-256.5, -256.5)), interval(-0x1ff8p-4, -0xff5cba9876543p-44)) + @test isequal_interval(+(bareinterval(-0xffp0, 0x123456789abcdfp-52), bareinterval(-256.5, -256.5)), bareinterval(-0x1ff8p-4, -0xff5cba9876543p-44)) - @test isequal_interval(+(interval(-0x1fffffffffffffp-52, -0x1p-550), interval(-4097.5, -4097.5)), interval(-0x10038p-4, -0x10018p-4)) + @test isequal_interval(+(bareinterval(-0x1fffffffffffffp-52, -0x1p-550), bareinterval(-4097.5, -4097.5)), bareinterval(-0x10038p-4, -0x10018p-4)) end @testset "mpfi_asin" begin - @test isequal_interval(asin(interval(-1.0, 0.0)), interval(-0x1921fb54442d19p-52, 0.0)) + @test isequal_interval(asin(bareinterval(-1.0, 0.0)), bareinterval(-0x1921fb54442d19p-52, 0.0)) - @test isequal_interval(asin(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(asin(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(asin(interval(0.0, +1.0)), interval(0.0, 0x1921fb54442d19p-52)) + @test isequal_interval(asin(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x1921fb54442d19p-52)) - @test isequal_interval(asin(interval(-1.0, -0.5)), interval(-0x1921fb54442d19p-52, -0x10c152382d7365p-53)) + @test isequal_interval(asin(bareinterval(-1.0, -0.5)), bareinterval(-0x1921fb54442d19p-52, -0x10c152382d7365p-53)) - @test isequal_interval(asin(interval(-0.75, -0.25)), interval(-0x1b235315c680ddp-53, -0x102be9ce0b87cdp-54)) + @test isequal_interval(asin(bareinterval(-0.75, -0.25)), bareinterval(-0x1b235315c680ddp-53, -0x102be9ce0b87cdp-54)) - @test isequal_interval(asin(interval(-0.5, 0.5)), interval(-0x860a91c16b9b3p-52, 0x860a91c16b9b3p-52)) + @test isequal_interval(asin(bareinterval(-0.5, 0.5)), bareinterval(-0x860a91c16b9b3p-52, 0x860a91c16b9b3p-52)) - @test isequal_interval(asin(interval(0.25, 0.625)), interval(0x102be9ce0b87cdp-54, 0x159aad71ced00fp-53)) + @test isequal_interval(asin(bareinterval(0.25, 0.625)), bareinterval(0x102be9ce0b87cdp-54, 0x159aad71ced00fp-53)) - @test isequal_interval(asin(interval(-1.0, 1.0)), interval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) + @test isequal_interval(asin(bareinterval(-1.0, 1.0)), bareinterval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) end @testset "mpfi_asinh" begin - @test isequal_interval(asinh(interval(-Inf, -7.0)), interval(-Inf, -0x152728c91b5f1dp-51)) + @test isequal_interval(asinh(bareinterval(-Inf, -7.0)), bareinterval(-Inf, -0x152728c91b5f1dp-51)) - @test isequal_interval(asinh(interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(asinh(bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(asinh(interval(-Inf, +8.0)), interval(-Inf, 0x58d8dc657eaf5p-49)) + @test isequal_interval(asinh(bareinterval(-Inf, +8.0)), bareinterval(-Inf, 0x58d8dc657eaf5p-49)) - @test isequal_interval(asinh(entireinterval()), entireinterval()) + @test isequal_interval(asinh(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(asinh(interval(-1.0, 0.0)), interval(-0x1c34366179d427p-53, 0.0)) + @test isequal_interval(asinh(bareinterval(-1.0, 0.0)), bareinterval(-0x1c34366179d427p-53, 0.0)) - @test isequal_interval(asinh(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(asinh(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(asinh(interval(0.0, +1.0)), interval(0.0, 0x1c34366179d427p-53)) + @test isequal_interval(asinh(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x1c34366179d427p-53)) - @test isequal_interval(asinh(interval(0.0, +8.0)), interval(0.0, 0x58d8dc657eaf5p-49)) + @test isequal_interval(asinh(bareinterval(0.0, +8.0)), bareinterval(0.0, 0x58d8dc657eaf5p-49)) - @test isequal_interval(asinh(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(asinh(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(asinh(interval(-6.0, -4.0)), interval(-0x4fbca919fe219p-49, -0x10c1f8a6e80eebp-51)) + @test isequal_interval(asinh(bareinterval(-6.0, -4.0)), bareinterval(-0x4fbca919fe219p-49, -0x10c1f8a6e80eebp-51)) - @test isequal_interval(asinh(interval(-2.0, -0.5)), interval(-0x2e32430627a11p-49, -0x1ecc2caec51609p-54)) + @test isequal_interval(asinh(bareinterval(-2.0, -0.5)), bareinterval(-0x2e32430627a11p-49, -0x1ecc2caec51609p-54)) - @test isequal_interval(asinh(interval(-1.0, -0.5)), interval(-0x1c34366179d427p-53, -0x1ecc2caec51609p-54)) + @test isequal_interval(asinh(bareinterval(-1.0, -0.5)), bareinterval(-0x1c34366179d427p-53, -0x1ecc2caec51609p-54)) - @test isequal_interval(asinh(interval(-0.75, -0.25)), interval(-0x162e42fefa39fp-49, -0xfd67d91ccf31bp-54)) + @test isequal_interval(asinh(bareinterval(-0.75, -0.25)), bareinterval(-0x162e42fefa39fp-49, -0xfd67d91ccf31bp-54)) - @test isequal_interval(asinh(interval(-0.5, 0.5)), interval(-0xf661657628b05p-53, 0xf661657628b05p-53)) + @test isequal_interval(asinh(bareinterval(-0.5, 0.5)), bareinterval(-0xf661657628b05p-53, 0xf661657628b05p-53)) - @test isequal_interval(asinh(interval(0.25, 0.625)), interval(0xfd67d91ccf31bp-54, 0x4b89d40b2fecdp-51)) + @test isequal_interval(asinh(bareinterval(0.25, 0.625)), bareinterval(0xfd67d91ccf31bp-54, 0x4b89d40b2fecdp-51)) - @test isequal_interval(asinh(interval(-1.0, 1.0)), interval(-0x1c34366179d427p-53, 0x1c34366179d427p-53)) + @test isequal_interval(asinh(bareinterval(-1.0, 1.0)), bareinterval(-0x1c34366179d427p-53, 0x1c34366179d427p-53)) - @test isequal_interval(asinh(interval(0.125, 17.0)), interval(0xff5685b4cb4b9p-55, 0xe1be0ba541ef7p-50)) + @test isequal_interval(asinh(bareinterval(0.125, 17.0)), bareinterval(0xff5685b4cb4b9p-55, 0xe1be0ba541ef7p-50)) - @test isequal_interval(asinh(interval(17.0, 42.0)), interval(0x1c37c174a83dedp-51, 0x8dca6976ad6bdp-49)) + @test isequal_interval(asinh(bareinterval(17.0, 42.0)), bareinterval(0x1c37c174a83dedp-51, 0x8dca6976ad6bdp-49)) - @test isequal_interval(asinh(interval(-42.0, 17.0)), interval(-0x8dca6976ad6bdp-49, 0xe1be0ba541ef7p-50)) + @test isequal_interval(asinh(bareinterval(-42.0, 17.0)), bareinterval(-0x8dca6976ad6bdp-49, 0xe1be0ba541ef7p-50)) end @testset "mpfi_atan" begin - @test isequal_interval(atan(interval(-Inf, -7.0)), interval(-0x1921fb54442d19p-52, -0x5b7315eed597fp-50)) + @test isequal_interval(atan(bareinterval(-Inf, -7.0)), bareinterval(-0x1921fb54442d19p-52, -0x5b7315eed597fp-50)) - @test isequal_interval(atan(interval(-Inf, 0.0)), interval(-0x1921fb54442d19p-52, 0.0)) + @test isequal_interval(atan(bareinterval(-Inf, 0.0)), bareinterval(-0x1921fb54442d19p-52, 0.0)) - @test isequal_interval(atan(interval(-Inf, +8.0)), interval(-0x1921fb54442d19p-52, 0xb924fd54cb511p-51)) + @test isequal_interval(atan(bareinterval(-Inf, +8.0)), bareinterval(-0x1921fb54442d19p-52, 0xb924fd54cb511p-51)) - @test isequal_interval(atan(entireinterval()), interval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64})), bareinterval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(interval(-1.0, 0.0)), interval(-0x1921fb54442d19p-53, 0.0)) + @test isequal_interval(atan(bareinterval(-1.0, 0.0)), bareinterval(-0x1921fb54442d19p-53, 0.0)) - @test isequal_interval(atan(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(atan(interval(0.0, +1.0)), interval(0.0, 0x1921fb54442d19p-53)) + @test isequal_interval(atan(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x1921fb54442d19p-53)) - @test isequal_interval(atan(interval(0.0, +8.0)), interval(0.0, 0xb924fd54cb511p-51)) + @test isequal_interval(atan(bareinterval(0.0, +8.0)), bareinterval(0.0, 0xb924fd54cb511p-51)) - @test isequal_interval(atan(interval(0.0, +Inf)), interval(0.0, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(bareinterval(0.0, +Inf)), bareinterval(0.0, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(interval(-6.0, -4.0)), interval(-0x167d8863bc99bdp-52, -0x54da32547a73fp-50)) + @test isequal_interval(atan(bareinterval(-6.0, -4.0)), bareinterval(-0x167d8863bc99bdp-52, -0x54da32547a73fp-50)) - @test isequal_interval(atan(interval(-2.0, -0.5)), interval(-0x11b6e192ebbe45p-52, -0x1dac670561bb4fp-54)) + @test isequal_interval(atan(bareinterval(-2.0, -0.5)), bareinterval(-0x11b6e192ebbe45p-52, -0x1dac670561bb4fp-54)) - @test isequal_interval(atan(interval(-1.0, -0.5)), interval(-0x1921fb54442d19p-53, -0x1dac670561bb4fp-54)) + @test isequal_interval(atan(bareinterval(-1.0, -0.5)), bareinterval(-0x1921fb54442d19p-53, -0x1dac670561bb4fp-54)) - @test isequal_interval(atan(interval(-0.75, -0.25)), interval(-0xa4bc7d1934f71p-52, -0x1f5b75f92c80ddp-55)) + @test isequal_interval(atan(bareinterval(-0.75, -0.25)), bareinterval(-0xa4bc7d1934f71p-52, -0x1f5b75f92c80ddp-55)) - @test isequal_interval(atan(interval(-0.5, 0.5)), interval(-0x1dac670561bb5p-50, 0x1dac670561bb5p-50)) + @test isequal_interval(atan(bareinterval(-0.5, 0.5)), bareinterval(-0x1dac670561bb5p-50, 0x1dac670561bb5p-50)) - @test isequal_interval(atan(interval(0.25, 0.625)), interval(0x1f5b75f92c80ddp-55, 0x47802eaf7bfadp-51)) + @test isequal_interval(atan(bareinterval(0.25, 0.625)), bareinterval(0x1f5b75f92c80ddp-55, 0x47802eaf7bfadp-51)) - @test isequal_interval(atan(interval(-1.0, 1.0)), interval(-0x1921fb54442d19p-53, 0x1921fb54442d19p-53)) + @test isequal_interval(atan(bareinterval(-1.0, 1.0)), bareinterval(-0x1921fb54442d19p-53, 0x1921fb54442d19p-53)) - @test isequal_interval(atan(interval(0.125, 17.0)), interval(0x1fd5ba9aac2f6dp-56, 0x1831516233f561p-52)) + @test isequal_interval(atan(bareinterval(0.125, 17.0)), bareinterval(0x1fd5ba9aac2f6dp-56, 0x1831516233f561p-52)) - @test isequal_interval(atan(interval(17.0, 42.0)), interval(0xc18a8b119fabp-47, 0x18c079f3350d27p-52)) + @test isequal_interval(atan(bareinterval(17.0, 42.0)), bareinterval(0xc18a8b119fabp-47, 0x18c079f3350d27p-52)) - @test isequal_interval(atan(interval(-42.0, 17.0)), interval(-0x18c079f3350d27p-52, 0x1831516233f561p-52)) + @test isequal_interval(atan(bareinterval(-42.0, 17.0)), bareinterval(-0x18c079f3350d27p-52, 0x1831516233f561p-52)) end @testset "mpfi_atan2" begin - @test isequal_interval(atan(interval(-Inf, -7.0), interval(-1.0, +8.0)), interval(-0x6d9cc4b34bd0dp-50, -0x1700a7c5784633p-53)) + @test isequal_interval(atan(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), bareinterval(-0x6d9cc4b34bd0dp-50, -0x1700a7c5784633p-53)) - @test isequal_interval(atan(interval(-Inf, 0.0), interval(+8.0, +Inf)), interval(-0x1921fb54442d19p-52, 0.0)) + @test isequal_interval(atan(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), bareinterval(-0x1921fb54442d19p-52, 0.0)) - @test isequal_interval(atan(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(entireinterval(), interval(0.0, +8.0)), interval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), bareinterval(-0x1921fb54442d19p-52, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) - @test isequal_interval(atan(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-51)) + @test isequal_interval(atan(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(0x3243f6a8885a3p-49, 0x1921fb54442d19p-51)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, 0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(atan(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(0.0, 0.0)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(0.0, 0.0)) - @test isequal_interval(atan(interval(0.0, 0.0), entireinterval()), interval(0.0, 0x1921fb54442d19p-51)) + @test isequal_interval(atan(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0x1921fb54442d19p-51)) - @test isequal_interval(atan(interval(0.0, +8.0), interval(-7.0, +8.0)), interval(0.0, 0x1921fb54442d19p-51)) + @test isequal_interval(atan(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), bareinterval(0.0, 0x1921fb54442d19p-51)) - @test isequal_interval(atan(interval(0.0, 0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(atan(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(atan(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, 0x1921fb54442d19p-52)) + @test isequal_interval(atan(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, 0x1921fb54442d19p-52)) - @test isequal_interval(atan(interval(-17.0, -5.0), interval(-4002.0, -1.0)), interval(-0x191f6c4c09a81bp-51, -0x1a12a5465464cfp-52)) + @test isequal_interval(atan(bareinterval(-17.0, -5.0), bareinterval(-4002.0, -1.0)), bareinterval(-0x191f6c4c09a81bp-51, -0x1a12a5465464cfp-52)) - @test isequal_interval(atan(interval(-17.0, -5.0), interval(1.0, 4002.0)), interval(-0x1831516233f561p-52, -0xa3c20ea13f5e5p-61)) + @test isequal_interval(atan(bareinterval(-17.0, -5.0), bareinterval(1.0, 4002.0)), bareinterval(-0x1831516233f561p-52, -0xa3c20ea13f5e5p-61)) - @test isequal_interval(atan(interval(5.0, 17.0), interval(1.0, 4002.0)), interval(0xa3c20ea13f5e5p-61, 0x1831516233f561p-52)) + @test isequal_interval(atan(bareinterval(5.0, 17.0), bareinterval(1.0, 4002.0)), bareinterval(0xa3c20ea13f5e5p-61, 0x1831516233f561p-52)) - @test isequal_interval(atan(interval(5.0, 17.0), interval(-4002.0, -1.0)), interval(0x1a12a5465464cfp-52, 0x191f6c4c09a81bp-51)) + @test isequal_interval(atan(bareinterval(5.0, 17.0), bareinterval(-4002.0, -1.0)), bareinterval(0x1a12a5465464cfp-52, 0x191f6c4c09a81bp-51)) - @test isequal_interval(atan(interval(-17.0, 5.0), interval(-4002.0, 1.0)), interval(-0x1921fb54442d19p-51, 0x1921fb54442d19p-51)) + @test isequal_interval(atan(bareinterval(-17.0, 5.0), bareinterval(-4002.0, 1.0)), bareinterval(-0x1921fb54442d19p-51, 0x1921fb54442d19p-51)) end @testset "mpfi_atanh" begin - @test isequal_interval(atanh(interval(-1.0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(atanh(bareinterval(-1.0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(atanh(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(atanh(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(atanh(interval(0.0, +1.0)), interval(0.0, +Inf)) + @test isequal_interval(atanh(bareinterval(0.0, +1.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(atanh(interval(-1.0, -0.5)), interval(-Inf, -0x8c9f53d568185p-52)) + @test isequal_interval(atanh(bareinterval(-1.0, -0.5)), bareinterval(-Inf, -0x8c9f53d568185p-52)) - @test isequal_interval(atanh(interval(-0.75, -0.25)), interval(-0x3e44e55c64b4bp-50, -0x1058aefa811451p-54)) + @test isequal_interval(atanh(bareinterval(-0.75, -0.25)), bareinterval(-0x3e44e55c64b4bp-50, -0x1058aefa811451p-54)) - @test isequal_interval(atanh(interval(-0.5, 0.5)), interval(-0x1193ea7aad030bp-53, 0x1193ea7aad030bp-53)) + @test isequal_interval(atanh(bareinterval(-0.5, 0.5)), bareinterval(-0x1193ea7aad030bp-53, 0x1193ea7aad030bp-53)) - @test isequal_interval(atanh(interval(0.25, 0.625)), interval(0x1058aefa811451p-54, 0x2eec3bb76c2b3p-50)) + @test isequal_interval(atanh(bareinterval(0.25, 0.625)), bareinterval(0x1058aefa811451p-54, 0x2eec3bb76c2b3p-50)) - @test isequal_interval(atanh(interval(-1.0, 1.0)), entireinterval()) + @test isequal_interval(atanh(bareinterval(-1.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(atanh(interval(0.125, 1.0)), interval(0x1015891c9eaef7p-55, +Inf)) + @test isequal_interval(atanh(bareinterval(0.125, 1.0)), bareinterval(0x1015891c9eaef7p-55, +Inf)) end @testset "mpfi_bounded_p" begin - @test iscommon(interval(-Inf, -8.0)) == false + @test iscommon(bareinterval(-Inf, -8.0)) == false - @test iscommon(interval(-Inf, 0.0)) == false + @test iscommon(bareinterval(-Inf, 0.0)) == false - @test iscommon(interval(-Inf, 5.0)) == false + @test iscommon(bareinterval(-Inf, 5.0)) == false - @test iscommon(entireinterval()) == false + @test iscommon(entireinterval(BareInterval{Float64})) == false - @test iscommon(interval(-8.0, 0.0)) == true + @test iscommon(bareinterval(-8.0, 0.0)) == true - @test iscommon(interval(0.0, 0.0)) == true + @test iscommon(bareinterval(0.0, 0.0)) == true - @test iscommon(interval(0.0, 5.0)) == true + @test iscommon(bareinterval(0.0, 5.0)) == true - @test iscommon(interval(0.0, +Inf)) == false + @test iscommon(bareinterval(0.0, +Inf)) == false - @test iscommon(interval(5.0, +Inf)) == false + @test iscommon(bareinterval(5.0, +Inf)) == false - @test iscommon(interval(-34.0, -17.0)) == true + @test iscommon(bareinterval(-34.0, -17.0)) == true - @test iscommon(interval(-8.0, -1.0)) == true + @test iscommon(bareinterval(-8.0, -1.0)) == true - @test iscommon(interval(-34.0, 17.0)) == true + @test iscommon(bareinterval(-34.0, 17.0)) == true - @test iscommon(interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true + @test iscommon(bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true - @test iscommon(interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true + @test iscommon(bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true - @test iscommon(interval(+8.0, +0x7fffffffffffbp+51)) == true + @test iscommon(bareinterval(+8.0, +0x7fffffffffffbp+51)) == true - @test iscommon(interval(+0x1fffffffffffffp-53, 2.0)) == true + @test iscommon(bareinterval(+0x1fffffffffffffp-53, 2.0)) == true end @testset "mpfi_cbrt" begin - @test isequal_interval(cbrt(interval(-Inf, -125.0)), interval(-Inf, -5.0)) + @test isequal_interval(cbrt(bareinterval(-Inf, -125.0)), bareinterval(-Inf, -5.0)) - @test isequal_interval(cbrt(interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(cbrt(bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(cbrt(interval(-Inf, +64.0)), interval(-Inf, +4.0)) + @test isequal_interval(cbrt(bareinterval(-Inf, +64.0)), bareinterval(-Inf, +4.0)) - @test isequal_interval(cbrt(entireinterval()), entireinterval()) + @test isequal_interval(cbrt(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cbrt(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(cbrt(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(cbrt(interval(0.0, +27.0)), interval(0.0, +3.0)) + @test isequal_interval(cbrt(bareinterval(0.0, +27.0)), bareinterval(0.0, +3.0)) - @test isequal_interval(cbrt(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(cbrt(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(cbrt(interval(0x40p0, 0x7dp0)), interval(4.0, 5.0)) + @test isequal_interval(cbrt(bareinterval(0x40p0, 0x7dp0)), bareinterval(4.0, 5.0)) - @test isequal_interval(cbrt(interval(-0x1856e4be527197p-354, 0xd8p0)), interval(-0x2e5e58c0083b7bp-154, 6.0)) + @test isequal_interval(cbrt(bareinterval(-0x1856e4be527197p-354, 0xd8p0)), bareinterval(-0x2e5e58c0083b7bp-154, 6.0)) - @test isequal_interval(cbrt(interval(0x141a9019a2184dp-1047, 0xc29c78c66ac0fp-678)), interval(0x2b8172e535d44dp-385, 0x24cbd1c55aaa1p-258)) + @test isequal_interval(cbrt(bareinterval(0x141a9019a2184dp-1047, 0xc29c78c66ac0fp-678)), bareinterval(0x2b8172e535d44dp-385, 0x24cbd1c55aaa1p-258)) end @testset "mpfi_cos" begin - @test isequal_interval(cos(interval(-Inf, -7.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-Inf, -7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-Inf, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-Inf, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-Inf, +8.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-Inf, +8.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(entireinterval()), interval(-1.0, 1.0)) + @test isequal_interval(cos(entireinterval(BareInterval{Float64})), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-1.0, 0.0)), interval(0x114a280fb5068bp-53, 1.0)) + @test isequal_interval(cos(bareinterval(-1.0, 0.0)), bareinterval(0x114a280fb5068bp-53, 1.0)) - @test isequal_interval(cos(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(cos(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(cos(interval(0.0, +1.0)), interval(0x114a280fb5068bp-53, 1.0)) + @test isequal_interval(cos(bareinterval(0.0, +1.0)), bareinterval(0x114a280fb5068bp-53, 1.0)) - @test isequal_interval(cos(interval(0.0, +8.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(0.0, +8.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(0.0, +Inf)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(0.0, +Inf)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-2.0, -0.5)), interval(-0x1aa22657537205p-54, 0x1c1528065b7d5p-49)) + @test isequal_interval(cos(bareinterval(-2.0, -0.5)), bareinterval(-0x1aa22657537205p-54, 0x1c1528065b7d5p-49)) - @test isequal_interval(cos(interval(-1.0, -0.25)), interval(0x114a280fb5068bp-53, 0xf80aa4fbef751p-52)) + @test isequal_interval(cos(bareinterval(-1.0, -0.25)), bareinterval(0x114a280fb5068bp-53, 0xf80aa4fbef751p-52)) - @test isequal_interval(cos(interval(-0.5, 0.5)), interval(0x1c1528065b7d4fp-53, 1.0)) + @test isequal_interval(cos(bareinterval(-0.5, 0.5)), bareinterval(0x1c1528065b7d4fp-53, 1.0)) - @test isequal_interval(cos(interval(-4.5, 0.625)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-4.5, 0.625)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(1.0, 0x3243f6a8885a3p-48)), interval(-1.0, 0x4528a03ed41a3p-51)) + @test isequal_interval(cos(bareinterval(1.0, 0x3243f6a8885a3p-48)), bareinterval(-1.0, 0x4528a03ed41a3p-51)) - @test isequal_interval(cos(interval(0.125, 17.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(0.125, 17.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(17.0, 42.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(17.0, 42.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, -1.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, -2.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, -3.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-7.0, -4.0)), interval(-0x14eaa606db24c1p-53, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -4.0)), bareinterval(-0x14eaa606db24c1p-53, 1.0)) - @test isequal_interval(cos(interval(-7.0, -5.0)), interval(0x122785706b4ad9p-54, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -5.0)), bareinterval(0x122785706b4ad9p-54, 1.0)) - @test isequal_interval(cos(interval(-7.0, -6.0)), interval(0x181ff79ed92017p-53, 1.0)) + @test isequal_interval(cos(bareinterval(-7.0, -6.0)), bareinterval(0x181ff79ed92017p-53, 1.0)) - @test isequal_interval(cos(interval(-7.0, -7.0)), interval(0x181ff79ed92017p-53, 0x181ff79ed92018p-53)) + @test isequal_interval(cos(bareinterval(-7.0, -7.0)), bareinterval(0x181ff79ed92017p-53, 0x181ff79ed92018p-53)) - @test isequal_interval(cos(interval(-6.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-6.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-6.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-6.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-6.0, -1.0)), interval(-1.0, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -1.0)), bareinterval(-1.0, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-6.0, -2.0)), interval(-1.0, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -2.0)), bareinterval(-1.0, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-6.0, -3.0)), interval(-1.0, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -3.0)), bareinterval(-1.0, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-6.0, -4.0)), interval(-0x14eaa606db24c1p-53, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -4.0)), bareinterval(-0x14eaa606db24c1p-53, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-6.0, -5.0)), interval(0x122785706b4ad9p-54, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -5.0)), bareinterval(0x122785706b4ad9p-54, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-6.0, -6.0)), interval(0x1eb9b7097822f5p-53, 0x1eb9b7097822f6p-53)) + @test isequal_interval(cos(bareinterval(-6.0, -6.0)), bareinterval(0x1eb9b7097822f5p-53, 0x1eb9b7097822f6p-53)) - @test isequal_interval(cos(interval(-5.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-5.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-5.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-5.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-5.0, -1.0)), interval(-1.0, 0x114a280fb5068cp-53)) + @test isequal_interval(cos(bareinterval(-5.0, -1.0)), bareinterval(-1.0, 0x114a280fb5068cp-53)) - @test isequal_interval(cos(interval(-5.0, -2.0)), interval(-1.0, 0x122785706b4adap-54)) + @test isequal_interval(cos(bareinterval(-5.0, -2.0)), bareinterval(-1.0, 0x122785706b4adap-54)) - @test isequal_interval(cos(interval(-5.0, -3.0)), interval(-1.0, 0x122785706b4adap-54)) + @test isequal_interval(cos(bareinterval(-5.0, -3.0)), bareinterval(-1.0, 0x122785706b4adap-54)) - @test isequal_interval(cos(interval(-5.0, -4.0)), interval(-0x14eaa606db24c1p-53, 0x122785706b4adap-54)) + @test isequal_interval(cos(bareinterval(-5.0, -4.0)), bareinterval(-0x14eaa606db24c1p-53, 0x122785706b4adap-54)) - @test isequal_interval(cos(interval(-5.0, -5.0)), interval(0x122785706b4ad9p-54, 0x122785706b4adap-54)) + @test isequal_interval(cos(bareinterval(-5.0, -5.0)), bareinterval(0x122785706b4ad9p-54, 0x122785706b4adap-54)) - @test isequal_interval(cos(interval(-4.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-4.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-4.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(cos(bareinterval(-4.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(cos(interval(-4.0, -1.0)), interval(-1.0, 0x114a280fb5068cp-53)) + @test isequal_interval(cos(bareinterval(-4.0, -1.0)), bareinterval(-1.0, 0x114a280fb5068cp-53)) - @test isequal_interval(cos(interval(-4.0, -2.0)), interval(-1.0, -0x1aa22657537204p-54)) + @test isequal_interval(cos(bareinterval(-4.0, -2.0)), bareinterval(-1.0, -0x1aa22657537204p-54)) - @test isequal_interval(cos(interval(-4.0, -3.0)), interval(-1.0, -0x14eaa606db24c0p-53)) + @test isequal_interval(cos(bareinterval(-4.0, -3.0)), bareinterval(-1.0, -0x14eaa606db24c0p-53)) - @test isequal_interval(cos(interval(-4.0, -4.0)), interval(-0x14eaa606db24c1p-53, -0x14eaa606db24c0p-53)) + @test isequal_interval(cos(bareinterval(-4.0, -4.0)), bareinterval(-0x14eaa606db24c1p-53, -0x14eaa606db24c0p-53)) end @testset "mpfi_cosh" begin - @test isequal_interval(cosh(interval(-Inf, -7.0)), interval(0x11228949ba3a8bp-43, +Inf)) + @test isequal_interval(cosh(bareinterval(-Inf, -7.0)), bareinterval(0x11228949ba3a8bp-43, +Inf)) - @test isequal_interval(cosh(interval(-Inf, 0.0)), interval(1.0, +Inf)) + @test isequal_interval(cosh(bareinterval(-Inf, 0.0)), bareinterval(1.0, +Inf)) - @test isequal_interval(cosh(interval(-Inf, +8.0)), interval(1.0, +Inf)) + @test isequal_interval(cosh(bareinterval(-Inf, +8.0)), bareinterval(1.0, +Inf)) - @test isequal_interval(cosh(entireinterval()), interval(1.0, +Inf)) + @test isequal_interval(cosh(entireinterval(BareInterval{Float64})), bareinterval(1.0, +Inf)) - @test isequal_interval(cosh(interval(-1.0, 0.0)), interval(1.0, 0x18b07551d9f551p-52)) + @test isequal_interval(cosh(bareinterval(-1.0, 0.0)), bareinterval(1.0, 0x18b07551d9f551p-52)) - @test isequal_interval(cosh(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(cosh(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(cosh(interval(0.0, +1.0)), interval(1.0, 0x18b07551d9f551p-52)) + @test isequal_interval(cosh(bareinterval(0.0, +1.0)), bareinterval(1.0, 0x18b07551d9f551p-52)) - @test isequal_interval(cosh(interval(0.0, +8.0)), interval(1.0, 0x1749eaa93f4e77p-42)) + @test isequal_interval(cosh(bareinterval(0.0, +8.0)), bareinterval(1.0, 0x1749eaa93f4e77p-42)) - @test isequal_interval(cosh(interval(0.0, +Inf)), interval(1.0, +Inf)) + @test isequal_interval(cosh(bareinterval(0.0, +Inf)), bareinterval(1.0, +Inf)) - @test isequal_interval(cosh(interval(-0.125, 0.0)), interval(1.0, 0x10200aac16db6fp-52)) + @test isequal_interval(cosh(bareinterval(-0.125, 0.0)), bareinterval(1.0, 0x10200aac16db6fp-52)) - @test isequal_interval(cosh(interval(0.0, 0x10000000000001p-53)), interval(1.0, 0x120ac1862ae8d1p-52)) + @test isequal_interval(cosh(bareinterval(0.0, 0x10000000000001p-53)), bareinterval(1.0, 0x120ac1862ae8d1p-52)) - @test isequal_interval(cosh(interval(-4.5, -0.625)), interval(0x99d310a496b6dp-51, 0x1681ceb0641359p-47)) + @test isequal_interval(cosh(bareinterval(-4.5, -0.625)), bareinterval(0x99d310a496b6dp-51, 0x1681ceb0641359p-47)) - @test isequal_interval(cosh(interval(1.0, 3.0)), interval(0x18b07551d9f55p-48, 0x1422a497d6185fp-49)) + @test isequal_interval(cosh(bareinterval(1.0, 3.0)), bareinterval(0x18b07551d9f55p-48, 0x1422a497d6185fp-49)) - @test isequal_interval(cosh(interval(17.0, 0xb145bb71d3dbp-38)), interval(0x1709348c0ea503p-29, 0x3ffffffffffa34p+968)) + @test isequal_interval(cosh(bareinterval(17.0, 0xb145bb71d3dbp-38)), bareinterval(0x1709348c0ea503p-29, 0x3ffffffffffa34p+968)) end @testset "mpfi_cot" begin - @test isequal_interval(cot(interval(-Inf, -7.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(-Inf, -7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(-Inf, +8.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(-Inf, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(entireinterval()), entireinterval()) + @test isequal_interval(cot(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(-8.0, 0.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(-8.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(-3.0, 0.0)), interval(-Inf, 0xe07cf2eb32f0bp-49)) + @test isequal_interval(cot(bareinterval(-3.0, 0.0)), bareinterval(-Inf, 0xe07cf2eb32f0bp-49)) - @test isequal_interval(cot(interval(-1.0, 0.0)), interval(-Inf, -0x148c05d04e1cfdp-53)) + @test isequal_interval(cot(bareinterval(-1.0, 0.0)), bareinterval(-Inf, -0x148c05d04e1cfdp-53)) - @test isequal_interval(cot(interval(0.0, +1.0)), interval(0x148c05d04e1cfdp-53, +Inf)) + @test isequal_interval(cot(bareinterval(0.0, +1.0)), bareinterval(0x148c05d04e1cfdp-53, +Inf)) - @test isequal_interval(cot(interval(0.0, +3.0)), interval(-0xe07cf2eb32f0bp-49, +Inf)) + @test isequal_interval(cot(bareinterval(0.0, +3.0)), bareinterval(-0xe07cf2eb32f0bp-49, +Inf)) - @test isequal_interval(cot(interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(cot(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(-3.0, -2.0)), interval(0x1d4a42e92faa4dp-54, 0xe07cf2eb32f0bp-49)) + @test isequal_interval(cot(bareinterval(-3.0, -2.0)), bareinterval(0x1d4a42e92faa4dp-54, 0xe07cf2eb32f0bp-49)) - @test isequal_interval(cot(interval(-3.0, -0x1921fb54442d19p-52)), interval(0x5cb3b399d747fp-103, 0xe07cf2eb32f0bp-49)) + @test isequal_interval(cot(bareinterval(-3.0, -0x1921fb54442d19p-52)), bareinterval(0x5cb3b399d747fp-103, 0xe07cf2eb32f0bp-49)) - @test isequal_interval(cot(interval(-2.0, 0x1921fb54442d19p-52)), entireinterval()) + @test isequal_interval(cot(bareinterval(-2.0, 0x1921fb54442d19p-52)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(0.125, 0.5)), interval(0xea4d6bf23e051p-51, 0x1fd549f047f2bbp-50)) + @test isequal_interval(cot(bareinterval(0.125, 0.5)), bareinterval(0xea4d6bf23e051p-51, 0x1fd549f047f2bbp-50)) - @test isequal_interval(cot(interval(0.125, 0x1921fb54442d19p-52)), interval(-0x172cece675d1fdp-105, 0x1fd549f047f2bbp-50)) + @test isequal_interval(cot(bareinterval(0.125, 0x1921fb54442d19p-52)), bareinterval(-0x172cece675d1fdp-105, 0x1fd549f047f2bbp-50)) - @test isequal_interval(cot(interval(0x1921fb54442d19p-52, 4.0)), entireinterval()) + @test isequal_interval(cot(bareinterval(0x1921fb54442d19p-52, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(cot(interval(4.0, 0x3243f6a8885a3p-47)), interval(-0x1d02967c31cdb5p-1, 0x1ba35ba1c6b75dp-53)) + @test isequal_interval(cot(bareinterval(4.0, 0x3243f6a8885a3p-47)), bareinterval(-0x1d02967c31cdb5p-1, 0x1ba35ba1c6b75dp-53)) - @test isequal_interval(cot(interval(0x13a28c59d5433bp-44, 0x9d9462ceaa19dp-43)), interval(0x148c05d04e1fb7p-53, 0x1cefdde7c84c27p-4)) + @test isequal_interval(cot(bareinterval(0x13a28c59d5433bp-44, 0x9d9462ceaa19dp-43)), bareinterval(0x148c05d04e1fb7p-53, 0x1cefdde7c84c27p-4)) end @testset "mpfi_coth" begin - @test isequal_interval(coth(interval(-Inf, -7.0)), interval(-0x100001be6c882fp-52, -1.0)) + @test isequal_interval(coth(bareinterval(-Inf, -7.0)), bareinterval(-0x100001be6c882fp-52, -1.0)) - @test isequal_interval(coth(interval(-Inf, 0.0)), interval(-Inf, -1.0)) + @test isequal_interval(coth(bareinterval(-Inf, 0.0)), bareinterval(-Inf, -1.0)) - @test isequal_interval(coth(interval(-Inf, +8.0)), entireinterval()) + @test isequal_interval(coth(bareinterval(-Inf, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(coth(entireinterval()), entireinterval()) + @test isequal_interval(coth(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(coth(interval(-8.0, 0.0)), interval(-Inf, -0x1000003c6ab7e7p-52)) + @test isequal_interval(coth(bareinterval(-8.0, 0.0)), bareinterval(-Inf, -0x1000003c6ab7e7p-52)) - @test isequal_interval(coth(interval(-3.0, 0.0)), interval(-Inf, -0x10145b3cc9964bp-52)) + @test isequal_interval(coth(bareinterval(-3.0, 0.0)), bareinterval(-Inf, -0x10145b3cc9964bp-52)) - @test isequal_interval(coth(interval(-1.0, 0.0)), interval(-Inf, -0x150231499b6b1dp-52)) + @test isequal_interval(coth(bareinterval(-1.0, 0.0)), bareinterval(-Inf, -0x150231499b6b1dp-52)) - @test isequal_interval(coth(interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(coth(bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(coth(interval(0.0, +1.0)), interval(0x150231499b6b1dp-52, +Inf)) + @test isequal_interval(coth(bareinterval(0.0, +1.0)), bareinterval(0x150231499b6b1dp-52, +Inf)) - @test isequal_interval(coth(interval(0.0, +3.0)), interval(0x10145b3cc9964bp-52, +Inf)) + @test isequal_interval(coth(bareinterval(0.0, +3.0)), bareinterval(0x10145b3cc9964bp-52, +Inf)) - @test isequal_interval(coth(interval(0.0, +8.0)), interval(0x1000003c6ab7e7p-52, +Inf)) + @test isequal_interval(coth(bareinterval(0.0, +8.0)), bareinterval(0x1000003c6ab7e7p-52, +Inf)) - @test isequal_interval(coth(interval(0.0, +Inf)), interval(1.0, +Inf)) + @test isequal_interval(coth(bareinterval(0.0, +Inf)), bareinterval(1.0, +Inf)) - @test isequal_interval(coth(interval(-3.0, 2.0)), entireinterval()) + @test isequal_interval(coth(bareinterval(-3.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(coth(interval(-10.0, -8.0)), interval(-0x1000003c6ab7e8p-52, -0x100000011b4865p-52)) + @test isequal_interval(coth(bareinterval(-10.0, -8.0)), bareinterval(-0x1000003c6ab7e8p-52, -0x100000011b4865p-52)) - @test isequal_interval(coth(interval(7.0, 17.0)), interval(0x1000000000000fp-52, 0x100001be6c882fp-52)) + @test isequal_interval(coth(bareinterval(7.0, 17.0)), bareinterval(0x1000000000000fp-52, 0x100001be6c882fp-52)) - @test isequal_interval(coth(interval(0x10000000000001p-58, 0x10000000000001p-53)), interval(0x114fc6ceb099bdp-51, 0x10005554fa502fp-46)) + @test isequal_interval(coth(bareinterval(0x10000000000001p-58, 0x10000000000001p-53)), bareinterval(0x114fc6ceb099bdp-51, 0x10005554fa502fp-46)) end @testset "mpfi_csc" begin - @test isequal_interval(csc(interval(-Inf, -7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-Inf, -7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-Inf, 8.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-Inf, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(entireinterval()), entireinterval()) + @test isequal_interval(csc(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-8.0, 0.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-8.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 0.0)), interval(-Inf, -1.0)) + @test isequal_interval(csc(bareinterval(-3.0, 0.0)), bareinterval(-Inf, -1.0)) - @test isequal_interval(csc(interval(-1.0, 0.0)), interval(-Inf, -0x1303aa9620b223p-52)) + @test isequal_interval(csc(bareinterval(-1.0, 0.0)), bareinterval(-Inf, -0x1303aa9620b223p-52)) - @test isequal_interval(csc(interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(csc(bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(0.0, +1.0)), interval(0x1303aa9620b223p-52, +Inf)) + @test isequal_interval(csc(bareinterval(0.0, +1.0)), bareinterval(0x1303aa9620b223p-52, +Inf)) - @test isequal_interval(csc(interval(0.0, 3.0)), interval(1.0, +Inf)) + @test isequal_interval(csc(bareinterval(0.0, 3.0)), bareinterval(1.0, +Inf)) - @test isequal_interval(csc(interval(0.0, 8.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(0.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(csc(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, 0.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, -1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, -2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, -3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-6.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-6.0, -4.0)), interval(1.0, 0x1ca19615f903dap-51)) + @test isequal_interval(csc(bareinterval(-6.0, -4.0)), bareinterval(1.0, 0x1ca19615f903dap-51)) - @test isequal_interval(csc(interval(-6.0, -5.0)), interval(0x10af73f9df86b7p-52, 0x1ca19615f903dap-51)) + @test isequal_interval(csc(bareinterval(-6.0, -5.0)), bareinterval(0x10af73f9df86b7p-52, 0x1ca19615f903dap-51)) - @test isequal_interval(csc(interval(-6.0, -6.0)), interval(0x1ca19615f903d9p-51, 0x1ca19615f903dap-51)) + @test isequal_interval(csc(bareinterval(-6.0, -6.0)), bareinterval(0x1ca19615f903d9p-51, 0x1ca19615f903dap-51)) - @test isequal_interval(csc(interval(-5.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, 0.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, -1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, -2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, -3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-5.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-5.0, -4.0)), interval(1.0, 0x15243e8b2f4642p-52)) + @test isequal_interval(csc(bareinterval(-5.0, -4.0)), bareinterval(1.0, 0x15243e8b2f4642p-52)) - @test isequal_interval(csc(interval(-5.0, -5.0)), interval(0x10af73f9df86b7p-52, 0x10af73f9df86b8p-52)) + @test isequal_interval(csc(bareinterval(-5.0, -5.0)), bareinterval(0x10af73f9df86b7p-52, 0x10af73f9df86b8p-52)) - @test isequal_interval(csc(interval(-4.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, 0.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, -1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, -2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, -3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-4.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-4.0, -4.0)), interval(0x15243e8b2f4641p-52, 0x15243e8b2f4642p-52)) + @test isequal_interval(csc(bareinterval(-4.0, -4.0)), bareinterval(0x15243e8b2f4641p-52, 0x15243e8b2f4642p-52)) - @test isequal_interval(csc(interval(-3.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-3.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-3.0, 0.0)), interval(-Inf, -1.0)) + @test isequal_interval(csc(bareinterval(-3.0, 0.0)), bareinterval(-Inf, -1.0)) - @test isequal_interval(csc(interval(-3.0, -1.0)), interval(-0x1c583c440ab0dap-50, -1.0)) + @test isequal_interval(csc(bareinterval(-3.0, -1.0)), bareinterval(-0x1c583c440ab0dap-50, -1.0)) - @test isequal_interval(csc(interval(-3.0, -2.0)), interval(-0x1c583c440ab0dap-50, -0x119893a272f912p-52)) + @test isequal_interval(csc(bareinterval(-3.0, -2.0)), bareinterval(-0x1c583c440ab0dap-50, -0x119893a272f912p-52)) - @test isequal_interval(csc(interval(-3.0, -3.0)), interval(-0x1c583c440ab0dap-50, -0x1c583c440ab0d9p-50)) + @test isequal_interval(csc(bareinterval(-3.0, -3.0)), bareinterval(-0x1c583c440ab0dap-50, -0x1c583c440ab0d9p-50)) - @test isequal_interval(csc(interval(-2.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-2.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-2.0, 0.0)), interval(-Inf, -1.0)) + @test isequal_interval(csc(bareinterval(-2.0, 0.0)), bareinterval(-Inf, -1.0)) - @test isequal_interval(csc(interval(-2.0, -1.0)), interval(-0x1303aa9620b224p-52, -1.0)) + @test isequal_interval(csc(bareinterval(-2.0, -1.0)), bareinterval(-0x1303aa9620b224p-52, -1.0)) - @test isequal_interval(csc(interval(-2.0, -2.0)), interval(-0x119893a272f913p-52, -0x119893a272f912p-52)) + @test isequal_interval(csc(bareinterval(-2.0, -2.0)), bareinterval(-0x119893a272f913p-52, -0x119893a272f912p-52)) - @test isequal_interval(csc(interval(-1.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 3.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 2.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 1.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(-1.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(-1.0, 0.0)), interval(-Inf, -0x1303aa9620b223p-52)) + @test isequal_interval(csc(bareinterval(-1.0, 0.0)), bareinterval(-Inf, -0x1303aa9620b223p-52)) - @test isequal_interval(csc(interval(-1.0, -1.0)), interval(-0x1303aa9620b224p-52, -0x1303aa9620b223p-52)) + @test isequal_interval(csc(bareinterval(-1.0, -1.0)), bareinterval(-0x1303aa9620b224p-52, -0x1303aa9620b223p-52)) - @test isequal_interval(csc(interval(1.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(1.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(1.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(1.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(1.0, 3.0)), interval(1.0, 0x1c583c440ab0dap-50)) + @test isequal_interval(csc(bareinterval(1.0, 3.0)), bareinterval(1.0, 0x1c583c440ab0dap-50)) - @test isequal_interval(csc(interval(1.0, 2.0)), interval(1.0, 0x1303aa9620b224p-52)) + @test isequal_interval(csc(bareinterval(1.0, 2.0)), bareinterval(1.0, 0x1303aa9620b224p-52)) - @test isequal_interval(csc(interval(1.0, 1.0)), interval(0x1303aa9620b223p-52, 0x1303aa9620b224p-52)) + @test isequal_interval(csc(bareinterval(1.0, 1.0)), bareinterval(0x1303aa9620b223p-52, 0x1303aa9620b224p-52)) - @test isequal_interval(csc(interval(2.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(2.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(2.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(2.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(2.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(2.0, 3.0)), interval(0x119893a272f912p-52, 0x1c583c440ab0dap-50)) + @test isequal_interval(csc(bareinterval(2.0, 3.0)), bareinterval(0x119893a272f912p-52, 0x1c583c440ab0dap-50)) - @test isequal_interval(csc(interval(2.0, 2.0)), interval(0x119893a272f912p-52, 0x119893a272f913p-52)) + @test isequal_interval(csc(bareinterval(2.0, 2.0)), bareinterval(0x119893a272f912p-52, 0x119893a272f913p-52)) - @test isequal_interval(csc(interval(3.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(3.0, 6.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(3.0, 5.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(3.0, 4.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(3.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(3.0, 3.0)), interval(0x1c583c440ab0d9p-50, 0x1c583c440ab0dap-50)) + @test isequal_interval(csc(bareinterval(3.0, 3.0)), bareinterval(0x1c583c440ab0d9p-50, 0x1c583c440ab0dap-50)) - @test isequal_interval(csc(interval(4.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(4.0, 6.0)), interval(-0x1ca19615f903dap-51, -1.0)) + @test isequal_interval(csc(bareinterval(4.0, 6.0)), bareinterval(-0x1ca19615f903dap-51, -1.0)) - @test isequal_interval(csc(interval(4.0, 5.0)), interval(-0x15243e8b2f4642p-52, -1.0)) + @test isequal_interval(csc(bareinterval(4.0, 5.0)), bareinterval(-0x15243e8b2f4642p-52, -1.0)) - @test isequal_interval(csc(interval(4.0, 4.0)), interval(-0x15243e8b2f4642p-52, -0x15243e8b2f4641p-52)) + @test isequal_interval(csc(bareinterval(4.0, 4.0)), bareinterval(-0x15243e8b2f4642p-52, -0x15243e8b2f4641p-52)) - @test isequal_interval(csc(interval(5.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(5.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(5.0, 6.0)), interval(-0x1ca19615f903dap-51, -0x10af73f9df86b7p-52)) + @test isequal_interval(csc(bareinterval(5.0, 6.0)), bareinterval(-0x1ca19615f903dap-51, -0x10af73f9df86b7p-52)) - @test isequal_interval(csc(interval(5.0, 5.0)), interval(-0x10af73f9df86b8p-52, -0x10af73f9df86b7p-52)) + @test isequal_interval(csc(bareinterval(5.0, 5.0)), bareinterval(-0x10af73f9df86b8p-52, -0x10af73f9df86b7p-52)) - @test isequal_interval(csc(interval(6.0, 7.0)), entireinterval()) + @test isequal_interval(csc(bareinterval(6.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csc(interval(6.0, 6.0)), interval(-0x1ca19615f903dap-51, -0x1ca19615f903d9p-51)) + @test isequal_interval(csc(bareinterval(6.0, 6.0)), bareinterval(-0x1ca19615f903dap-51, -0x1ca19615f903d9p-51)) - @test isequal_interval(csc(interval(7.0, 7.0)), interval(+0x185a86a4ceb06cp-52, +0x185a86a4ceb06dp-52)) + @test isequal_interval(csc(bareinterval(7.0, 7.0)), bareinterval(+0x185a86a4ceb06cp-52, +0x185a86a4ceb06dp-52)) end @testset "mpfi_csch" begin - @test isequal_interval(csch(interval(-Inf, -7.0)), interval(-0x1de16d3cffcd54p-62, 0.0)) + @test isequal_interval(csch(bareinterval(-Inf, -7.0)), bareinterval(-0x1de16d3cffcd54p-62, 0.0)) - @test isequal_interval(csch(interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(csch(bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(csch(interval(-Inf, +8.0)), entireinterval()) + @test isequal_interval(csch(bareinterval(-Inf, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csch(entireinterval()), entireinterval()) + @test isequal_interval(csch(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(csch(interval(-8.0, 0.0)), interval(-Inf, -0x15fc212d92371ap-63)) + @test isequal_interval(csch(bareinterval(-8.0, 0.0)), bareinterval(-Inf, -0x15fc212d92371ap-63)) - @test isequal_interval(csch(interval(-3.0, 0.0)), interval(-Inf, -0x198de80929b901p-56)) + @test isequal_interval(csch(bareinterval(-3.0, 0.0)), bareinterval(-Inf, -0x198de80929b901p-56)) - @test isequal_interval(csch(interval(-1.0, 0.0)), interval(-Inf, -0x1b3ab8a78b90c0p-53)) + @test isequal_interval(csch(bareinterval(-1.0, 0.0)), bareinterval(-Inf, -0x1b3ab8a78b90c0p-53)) - @test isequal_interval(csch(interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(csch(bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(csch(interval(0.0, +1.0)), interval(0x1b3ab8a78b90c0p-53, +Inf)) + @test isequal_interval(csch(bareinterval(0.0, +1.0)), bareinterval(0x1b3ab8a78b90c0p-53, +Inf)) - @test isequal_interval(csch(interval(0.0, +3.0)), interval(0x198de80929b901p-56, +Inf)) + @test isequal_interval(csch(bareinterval(0.0, +3.0)), bareinterval(0x198de80929b901p-56, +Inf)) - @test isequal_interval(csch(interval(0.0, +8.0)), interval(0x15fc212d92371ap-63, +Inf)) + @test isequal_interval(csch(bareinterval(0.0, +8.0)), bareinterval(0x15fc212d92371ap-63, +Inf)) - @test isequal_interval(csch(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(csch(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(csch(interval(-3.0, 2.0)), entireinterval()) + @test isequal_interval(csch(bareinterval(-3.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(csch(interval(-10.0, -8.0)), interval(-0x15fc212d92371bp-63, -0x17cd79b63733a0p-66)) + @test isequal_interval(csch(bareinterval(-10.0, -8.0)), bareinterval(-0x15fc212d92371bp-63, -0x17cd79b63733a0p-66)) - @test isequal_interval(csch(interval(7.0, 17.0)), interval(0x1639e3175a68a7p-76, 0x1de16d3cffcd54p-62)) + @test isequal_interval(csch(bareinterval(7.0, 17.0)), bareinterval(0x1639e3175a68a7p-76, 0x1de16d3cffcd54p-62)) - @test isequal_interval(csch(interval(0x10000000000001p-58, 0x10000000000001p-53)), interval(0x1eb45dc88defeap-52, 0x3fff555693e722p-48)) + @test isequal_interval(csch(bareinterval(0x10000000000001p-58, 0x10000000000001p-53)), bareinterval(0x1eb45dc88defeap-52, 0x3fff555693e722p-48)) end @testset "mpfi_d_div" begin - @test isequal_interval(/(interval(-0x170ef54646d496p-107, -0x170ef54646d496p-107), interval(-Inf, -7.0)), interval(0.0, 0x1a5a3ce29a1787p-110)) + @test isequal_interval(/(bareinterval(-0x170ef54646d496p-107, -0x170ef54646d496p-107), bareinterval(-Inf, -7.0)), bareinterval(0.0, 0x1a5a3ce29a1787p-110)) - @test isequal_interval(/(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0x170ef54646d496p-107, 0x170ef54646d496p-107), interval(-Inf, -7.0)), interval(-0x1a5a3ce29a1787p-110, 0.0)) + @test isequal_interval(/(bareinterval(0x170ef54646d496p-107, 0x170ef54646d496p-107), bareinterval(-Inf, -7.0)), bareinterval(-0x1a5a3ce29a1787p-110, 0.0)) - @test isequal_interval(/(interval(-0x170ef54646d497p-106, -0x170ef54646d497p-106), interval(-Inf, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(-0x170ef54646d497p-106, -0x170ef54646d497p-106), bareinterval(-Inf, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(0.0, 0.0), interval(-Inf, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0x170ef54646d497p-106, 0x170ef54646d497p-106), interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(0x170ef54646d497p-106, 0x170ef54646d497p-106), bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(-0x16345785d8a00000p0, -0x16345785d8a00000p0), interval(-Inf, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0x16345785d8a00000p0, -0x16345785d8a00000p0), bareinterval(-Inf, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, 0.0), interval(-Inf, 8.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(-Inf, 8.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0x16345785d8a00000p0, 0x16345785d8a00000p0), interval(-Inf, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0x16345785d8a00000p0, 0x16345785d8a00000p0), bareinterval(-Inf, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0e-17, 0.0e-17), entireinterval()), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0e-17, 0.0e-17), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(+0x170ef54646d497p-105, +0x170ef54646d497p-105), entireinterval()), entireinterval()) + @test isequal_interval(/(bareinterval(+0x170ef54646d497p-105, +0x170ef54646d497p-105), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, 0.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0x170ef54646d497p-109, 0x170ef54646d497p-109), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107), interval(0.0, 7.0)), interval(-Inf, -0x13c3ada9f391a5p-110)) + @test isequal_interval(/(bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107), bareinterval(0.0, 7.0)), bareinterval(-Inf, -0x13c3ada9f391a5p-110)) - @test isequal_interval(/(interval(0.0, 0.0), interval(0.0, 7.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(0.0, 7.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107), interval(0.0, 7.0)), interval(0x13c3ada9f391a5p-110, +Inf)) + @test isequal_interval(/(bareinterval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107), bareinterval(0.0, 7.0)), bareinterval(0x13c3ada9f391a5p-110, +Inf)) - @test isequal_interval(/(interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104), interval(0.0, +Inf)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104), bareinterval(0.0, +Inf)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(0.0, 0.0), interval(0.0, +Inf)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(0.0, +Inf)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106), interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106), bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(-2.5, -2.5), interval(-8.0, 8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-2.5, -2.5), bareinterval(-8.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-2.5, -2.5), interval(-8.0, -5.0)), interval(0x5p-4, 0.5)) + @test isequal_interval(/(bareinterval(-2.5, -2.5), bareinterval(-8.0, -5.0)), bareinterval(0x5p-4, 0.5)) - @test isequal_interval(/(interval(-2.5, -2.5), interval(25.0, 40.0)), interval(-0x1999999999999ap-56, -0x1p-4)) + @test isequal_interval(/(bareinterval(-2.5, -2.5), bareinterval(25.0, 40.0)), bareinterval(-0x1999999999999ap-56, -0x1p-4)) - @test isequal_interval(/(interval(-2.5, -2.5), interval(-16.0, -7.0)), interval(0x5p-5, 0x16db6db6db6db7p-54)) + @test isequal_interval(/(bareinterval(-2.5, -2.5), bareinterval(-16.0, -7.0)), bareinterval(0x5p-5, 0x16db6db6db6db7p-54)) - @test isequal_interval(/(interval(-2.5, -2.5), interval(11.0, 143.0)), interval(-0x1d1745d1745d18p-55, -0x11e6efe35b4cfap-58)) + @test isequal_interval(/(bareinterval(-2.5, -2.5), bareinterval(11.0, 143.0)), bareinterval(-0x1d1745d1745d18p-55, -0x11e6efe35b4cfap-58)) - @test isequal_interval(/(interval(33.125, 33.125), interval(8.28125, 530.0)), interval(0x1p-4, 4.0)) + @test isequal_interval(/(bareinterval(33.125, 33.125), bareinterval(8.28125, 530.0)), bareinterval(0x1p-4, 4.0)) - @test isequal_interval(/(interval(33.125, 33.125), interval(-530.0, -496.875)), interval(-0x11111111111112p-56, -0x1p-4)) + @test isequal_interval(/(bareinterval(33.125, 33.125), bareinterval(-530.0, -496.875)), bareinterval(-0x11111111111112p-56, -0x1p-4)) - @test isequal_interval(/(interval(33.125, 33.125), interval(54.0, 265.0)), interval(0.125, 0x13a12f684bda13p-53)) + @test isequal_interval(/(bareinterval(33.125, 33.125), bareinterval(54.0, 265.0)), bareinterval(0.125, 0x13a12f684bda13p-53)) - @test isequal_interval(/(interval(33.125, 33.125), interval(52.0, 54.0)), interval(0x13a12f684bda12p-53, 0x14627627627628p-53)) + @test isequal_interval(/(bareinterval(33.125, 33.125), bareinterval(52.0, 54.0)), bareinterval(0x13a12f684bda12p-53, 0x14627627627628p-53)) end @testset "mpfi_diam_abs" begin - @test diam(interval(-Inf, -8.0)) == +Inf + @test diam(bareinterval(-Inf, -8.0)) == +Inf - @test diam(interval(-Inf, 0.0)) == +Inf + @test diam(bareinterval(-Inf, 0.0)) == +Inf - @test diam(interval(-Inf, 5.0)) == +Inf + @test diam(bareinterval(-Inf, 5.0)) == +Inf - @test diam(entireinterval()) == +Inf + @test diam(entireinterval(BareInterval{Float64})) == +Inf - @test diam(interval(-Inf, 0.0)) == +Inf + @test diam(bareinterval(-Inf, 0.0)) == +Inf - @test diam(interval(-8.0, 0.0)) == +8.0 + @test diam(bareinterval(-8.0, 0.0)) == +8.0 - @test diam(interval(0.0, 0.0)) == 0.0 + @test diam(bareinterval(0.0, 0.0)) == 0.0 - @test diam(interval(0.0, 5.0)) == +5.0 + @test diam(bareinterval(0.0, 5.0)) == +5.0 - @test diam(interval(0.0, +Inf)) == +Inf + @test diam(bareinterval(0.0, +Inf)) == +Inf - @test diam(interval(-34.0, -17.0)) == 17.0 + @test diam(bareinterval(-34.0, -17.0)) == 17.0 end @testset "mpfi_div" begin - @test isequal_interval(/(interval(-Inf, -7.0), interval(-1.0, +8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf, 0.0), interval(+8.0, +Inf)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(-Inf, +8.0), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, 0.0), entireinterval()), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, +8.0), interval(-7.0, +8.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(-0x75bcd15p0, -0x754ep0), interval(-0x11ep0, -0x9p0)), interval(0x69p0, 0xd14fadp0)) + @test isequal_interval(/(bareinterval(-0x75bcd15p0, -0x754ep0), bareinterval(-0x11ep0, -0x9p0)), bareinterval(0x69p0, 0xd14fadp0)) - @test isequal_interval(/(interval(-0x75bcd15p0, -0x1.489c07caba163p-4), interval(-0x2.e8e36e560704ap+4, -0x9p0)), interval(0x7.0ef61537b1704p-12, 0xd14fadp0)) + @test isequal_interval(/(bareinterval(-0x75bcd15p0, -0x1.489c07caba163p-4), bareinterval(-0x2.e8e36e560704ap+4, -0x9p0)), bareinterval(0x7.0ef61537b1704p-12, 0xd14fadp0)) - @test isequal_interval(/(interval(-0x1.02f0415f9f596p+0, -0x754ep-16), interval(-0x11ep0, -0x7.62ce64fbacd2cp-8)), interval(0x69p-16, 0x2.30ee5eef9c36cp+4)) + @test isequal_interval(/(bareinterval(-0x1.02f0415f9f596p+0, -0x754ep-16), bareinterval(-0x11ep0, -0x7.62ce64fbacd2cp-8)), bareinterval(0x69p-16, 0x2.30ee5eef9c36cp+4)) - @test isequal_interval(/(interval(-0x1.02f0415f9f596p+0, -0x1.489c07caba163p-4), interval(-0x2.e8e36e560704ap+0, -0x7.62ce64fbacd2cp-8)), interval(0x7.0ef61537b1704p-8, 0x2.30ee5eef9c36cp+4)) + @test isequal_interval(/(bareinterval(-0x1.02f0415f9f596p+0, -0x1.489c07caba163p-4), bareinterval(-0x2.e8e36e560704ap+0, -0x7.62ce64fbacd2cp-8)), bareinterval(0x7.0ef61537b1704p-8, 0x2.30ee5eef9c36cp+4)) - @test isequal_interval(/(interval(-0xacbp+256, -0x6f9p0), interval(-0x7p0, 0.0)), interval(0xffp0, +Inf)) + @test isequal_interval(/(bareinterval(-0xacbp+256, -0x6f9p0), bareinterval(-0x7p0, 0.0)), bareinterval(0xffp0, +Inf)) - @test isequal_interval(/(interval(-0x100p0, -0xe.bb80d0a0824ep-4), interval(-0x1.7c6d760a831fap+0, 0.0)), interval(0x9.e9f24790445fp-4, +Inf)) + @test isequal_interval(/(bareinterval(-0x100p0, -0xe.bb80d0a0824ep-4), bareinterval(-0x1.7c6d760a831fap+0, 0.0)), bareinterval(0x9.e9f24790445fp-4, +Inf)) - @test isequal_interval(/(interval(-0x1.25f2d73472753p+0, -0x9.9a19fd3c1fc18p-4), interval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval()) + @test isequal_interval(/(bareinterval(-0x1.25f2d73472753p+0, -0x9.9a19fd3c1fc18p-4), bareinterval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-100.0, -15.0), interval(0.0, +3.0)), interval(-Inf, -5.0)) + @test isequal_interval(/(bareinterval(-100.0, -15.0), bareinterval(0.0, +3.0)), bareinterval(-Inf, -5.0)) - @test isequal_interval(/(interval(-2.0, -0x1.25f2d73472753p+0), interval(0.0, +0x9.3b0c8074ccc18p-4)), interval(-Inf, -0x1.fd8457415f917p+0)) + @test isequal_interval(/(bareinterval(-2.0, -0x1.25f2d73472753p+0), bareinterval(0.0, +0x9.3b0c8074ccc18p-4)), bareinterval(-Inf, -0x1.fd8457415f917p+0)) - @test isequal_interval(/(interval(-0x123456789p0, -0x754ep+4), interval(0x40bp0, 0x11ep+4)), interval(-0x480b3bp0, -0x69p0)) + @test isequal_interval(/(bareinterval(-0x123456789p0, -0x754ep+4), bareinterval(0x40bp0, 0x11ep+4)), bareinterval(-0x480b3bp0, -0x69p0)) - @test isequal_interval(/(interval(-0xd.67775e4b8588p-4, -0x754ep-53), interval(0x4.887091874ffc8p+0, 0x11ep+201)), interval(-0x2.f5008d2df94ccp-4, -0x69p-254)) + @test isequal_interval(/(bareinterval(-0xd.67775e4b8588p-4, -0x754ep-53), bareinterval(0x4.887091874ffc8p+0, 0x11ep+201)), bareinterval(-0x2.f5008d2df94ccp-4, -0x69p-254)) - @test isequal_interval(/(interval(-0x123456789p0, -0x1.b0a62934c76e9p+0), interval(0x40bp-17, 0x2.761ec797697a4p-4)), interval(-0x480b3bp+17, -0xa.fc5e7338f3e4p+0)) + @test isequal_interval(/(bareinterval(-0x123456789p0, -0x1.b0a62934c76e9p+0), bareinterval(0x40bp-17, 0x2.761ec797697a4p-4)), bareinterval(-0x480b3bp+17, -0xa.fc5e7338f3e4p+0)) - @test isequal_interval(/(interval(-0xd.67775e4b8588p+0, -0x1.b0a62934c76e9p+0), interval(0x4.887091874ffc8p-4, 0x2.761ec797697a4p+4)), interval(-0x2.f5008d2df94ccp+4, -0xa.fc5e7338f3e4p-8)) + @test isequal_interval(/(bareinterval(-0xd.67775e4b8588p+0, -0x1.b0a62934c76e9p+0), bareinterval(0x4.887091874ffc8p-4, 0x2.761ec797697a4p+4)), bareinterval(-0x2.f5008d2df94ccp+4, -0xa.fc5e7338f3e4p-8)) - @test isequal_interval(/(interval(-0x75bcd15p0, 0.0), interval(-0x90p0, -0x9p0)), interval(0.0, 0xd14fadp0)) + @test isequal_interval(/(bareinterval(-0x75bcd15p0, 0.0), bareinterval(-0x90p0, -0x9p0)), bareinterval(0.0, 0xd14fadp0)) - @test isequal_interval(/(interval(-0x1.4298b2138f2a7p-4, 0.0), interval(-0x1p-8, -0xf.5e4900c9c19fp-12)), interval(0.0, 0x1.4fdb41a33d6cep+4)) + @test isequal_interval(/(bareinterval(-0x1.4298b2138f2a7p-4, 0.0), bareinterval(-0x1p-8, -0xf.5e4900c9c19fp-12)), bareinterval(0.0, 0x1.4fdb41a33d6cep+4)) - @test isequal_interval(/(interval(-0xeeeeeeeeep0, 0.0), interval(-0xaaaaaaaaap0, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(-0xeeeeeeeeep0, 0.0), bareinterval(-0xaaaaaaaaap0, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(-0x1.25f2d73472753p+0, 0.0), interval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval()) + @test isequal_interval(/(bareinterval(-0x1.25f2d73472753p+0, 0.0), bareinterval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0xeeeeeeeeep0, 0.0), interval(0.0, +0x3p0)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(-0xeeeeeeeeep0, 0.0), bareinterval(0.0, +0x3p0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(-0x75bcd15p0, 0.0), interval(0x9p0, 0x90p0)), interval(-0xd14fadp0, 0.0)) + @test isequal_interval(/(bareinterval(-0x75bcd15p0, 0.0), bareinterval(0x9p0, 0x90p0)), bareinterval(-0xd14fadp0, 0.0)) - @test isequal_interval(/(interval(-0x1.4298b2138f2a7p-4, 0.0), interval(0xf.5e4900c9c19fp-12, 0x9p0)), interval(-0x1.4fdb41a33d6cep+4, 0.0)) + @test isequal_interval(/(bareinterval(-0x1.4298b2138f2a7p-4, 0.0), bareinterval(0xf.5e4900c9c19fp-12, 0x9p0)), bareinterval(-0x1.4fdb41a33d6cep+4, 0.0)) - @test isequal_interval(/(interval(-0x75bcd15p0, 0xa680p0), interval(-0xaf6p0, -0x9p0)), interval(-0x1280p0, 0xd14fadp0)) + @test isequal_interval(/(bareinterval(-0x75bcd15p0, 0xa680p0), bareinterval(-0xaf6p0, -0x9p0)), bareinterval(-0x1280p0, 0xd14fadp0)) - @test isequal_interval(/(interval(-0x12p0, 0x10p0), interval(-0xbbbbbbbbbbp0, -0x9p0)), interval(-0x1.c71c71c71c71dp0, 2.0)) + @test isequal_interval(/(bareinterval(-0x12p0, 0x10p0), bareinterval(-0xbbbbbbbbbbp0, -0x9p0)), bareinterval(-0x1.c71c71c71c71dp0, 2.0)) - @test isequal_interval(/(interval(-0x1p0, 0x754ep-16), interval(-0xccccccccccp0, -0x11ep0)), interval(-0x69p-16, 0xe.525982af70c9p-12)) + @test isequal_interval(/(bareinterval(-0x1p0, 0x754ep-16), bareinterval(-0xccccccccccp0, -0x11ep0)), bareinterval(-0x69p-16, 0xe.525982af70c9p-12)) - @test isequal_interval(/(interval(-0xb.5b90b4d32136p-4, 0x6.e694ac6767394p+0), interval(-0xdddddddddddp0, -0xc.f459be9e80108p-4)), interval(-0x8.85e40b3c3f63p+0, 0xe.071cbfa1de788p-4)) + @test isequal_interval(/(bareinterval(-0xb.5b90b4d32136p-4, 0x6.e694ac6767394p+0), bareinterval(-0xdddddddddddp0, -0xc.f459be9e80108p-4)), bareinterval(-0x8.85e40b3c3f63p+0, 0xe.071cbfa1de788p-4)) - @test isequal_interval(/(interval(-0xacbp+256, 0x6f9p0), interval(-0x7p0, 0.0)), entireinterval()) + @test isequal_interval(/(bareinterval(-0xacbp+256, 0x6f9p0), bareinterval(-0x7p0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0x1.25f2d73472753p+0, +0x9.9a19fd3c1fc18p-4), interval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval()) + @test isequal_interval(/(bareinterval(-0x1.25f2d73472753p+0, +0x9.9a19fd3c1fc18p-4), bareinterval(-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, +15.0), interval(-3.0, +3.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0, +15.0), bareinterval(-3.0, +3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-0x754ep0, 0xd0e9dc4p+12), interval(0x11ep0, 0xbbbp0)), interval(-0x69p0, 0xbaffep+12)) + @test isequal_interval(/(bareinterval(-0x754ep0, 0xd0e9dc4p+12), bareinterval(0x11ep0, 0xbbbp0)), bareinterval(-0x69p0, 0xbaffep+12)) - @test isequal_interval(/(interval(-0x10p0, 0xd0e9dc4p+12), interval(0x11ep0, 0xbbbp0)), interval(-0xe.525982af70c9p-8, 0xbaffep+12)) + @test isequal_interval(/(bareinterval(-0x10p0, 0xd0e9dc4p+12), bareinterval(0x11ep0, 0xbbbp0)), bareinterval(-0xe.525982af70c9p-8, 0xbaffep+12)) - @test isequal_interval(/(interval(-0x754ep0, 0x1p+10), interval(0x11ep0, 0xbbbp0)), interval(-0x69p0, 0xe.525982af70c9p-2)) + @test isequal_interval(/(bareinterval(-0x754ep0, 0x1p+10), bareinterval(0x11ep0, 0xbbbp0)), bareinterval(-0x69p0, 0xe.525982af70c9p-2)) - @test isequal_interval(/(interval(-0x1.18333622af827p+0, 0x2.14b836907297p+0), interval(0x1.263147d1f4bcbp+0, 0x111p0)), interval(-0xf.3d2f5db8ec728p-4, 0x1.cf8fa732de129p+0)) + @test isequal_interval(/(bareinterval(-0x1.18333622af827p+0, 0x2.14b836907297p+0), bareinterval(0x1.263147d1f4bcbp+0, 0x111p0)), bareinterval(-0xf.3d2f5db8ec728p-4, 0x1.cf8fa732de129p+0)) - @test isequal_interval(/(interval(0.0, 0x75bcd15p0), interval(-0xap0, -0x9p0)), interval(-0xd14fadp0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0x75bcd15p0), bareinterval(-0xap0, -0x9p0)), bareinterval(-0xd14fadp0, 0.0)) - @test isequal_interval(/(interval(0.0, 0x1.acbf1702af6edp+0), interval(-0x0.fp0, -0xe.3d7a59e2bdacp-4)), interval(-0x1.e1bb896bfda07p+0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0x1.acbf1702af6edp+0), bareinterval(-0x0.fp0, -0xe.3d7a59e2bdacp-4)), bareinterval(-0x1.e1bb896bfda07p+0, 0.0)) - @test isequal_interval(/(interval(0.0, 0xap0), interval(-0x9p0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0xap0), bareinterval(-0x9p0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(0.0, 0xap0), interval(-1.0, +1.0)), entireinterval()) + @test isequal_interval(/(bareinterval(0.0, 0xap0), bareinterval(-1.0, +1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, 0x75bcd15p0), interval(+0x9p0, +0xap0)), interval(0.0, 0xd14fadp0)) + @test isequal_interval(/(bareinterval(0.0, 0x75bcd15p0), bareinterval(+0x9p0, +0xap0)), bareinterval(0.0, 0xd14fadp0)) - @test isequal_interval(/(interval(0.0, 0x1.5f6b03dc8c66fp+0), interval(+0x2.39ad24e812dcep+0, 0xap0)), interval(0.0, 0x9.deb65b02baep-4)) + @test isequal_interval(/(bareinterval(0.0, 0x1.5f6b03dc8c66fp+0), bareinterval(+0x2.39ad24e812dcep+0, 0xap0)), bareinterval(0.0, 0x9.deb65b02baep-4)) - @test isequal_interval(/(interval(0x754ep0, 0x75bcd15p0), interval(-0x11ep0, -0x9p0)), interval(-0xd14fadp0, -0x69p0)) + @test isequal_interval(/(bareinterval(0x754ep0, 0x75bcd15p0), bareinterval(-0x11ep0, -0x9p0)), bareinterval(-0xd14fadp0, -0x69p0)) - @test isequal_interval(/(interval(0x754ep-16, 0x1.008a3accc766dp+4), interval(-0x11ep0, -0x2.497403b31d32ap+0)), interval(-0x7.02d3edfbc8b6p+0, -0x69p-16)) + @test isequal_interval(/(bareinterval(0x754ep-16, 0x1.008a3accc766dp+4), bareinterval(-0x11ep0, -0x2.497403b31d32ap+0)), bareinterval(-0x7.02d3edfbc8b6p+0, -0x69p-16)) - @test isequal_interval(/(interval(0x9.ac412ff1f1478p-4, 0x75bcd15p0), interval(-0x1.5232c83a0e726p+4, -0x9p0)), interval(-0xd14fadp0, -0x7.52680a49e5d68p-8)) + @test isequal_interval(/(bareinterval(0x9.ac412ff1f1478p-4, 0x75bcd15p0), bareinterval(-0x1.5232c83a0e726p+4, -0x9p0)), bareinterval(-0xd14fadp0, -0x7.52680a49e5d68p-8)) - @test isequal_interval(/(interval(0xe.1552a314d629p-4, 0x1.064c5adfd0042p+0), interval(-0x5.0d4d319a50b04p-4, -0x2.d8f51df1e322ep-4)), interval(-0x5.c1d97d57d81ccp+0, -0x2.c9a600c455f5ap+0)) + @test isequal_interval(/(bareinterval(0xe.1552a314d629p-4, 0x1.064c5adfd0042p+0), bareinterval(-0x5.0d4d319a50b04p-4, -0x2.d8f51df1e322ep-4)), bareinterval(-0x5.c1d97d57d81ccp+0, -0x2.c9a600c455f5ap+0)) - @test isequal_interval(/(interval(0x754ep0, 0xeeeep0), interval(-0x11ep0, 0.0)), interval(-Inf, -0x69p0)) + @test isequal_interval(/(bareinterval(0x754ep0, 0xeeeep0), bareinterval(-0x11ep0, 0.0)), bareinterval(-Inf, -0x69p0)) - @test isequal_interval(/(interval(0x1.a9016514490e6p-4, 0xeeeep0), interval(-0xe.316e87be0b24p-4, 0.0)), interval(-Inf, -0x1.df1cc82e6a583p-4)) + @test isequal_interval(/(bareinterval(0x1.a9016514490e6p-4, 0xeeeep0), bareinterval(-0xe.316e87be0b24p-4, 0.0)), bareinterval(-Inf, -0x1.df1cc82e6a583p-4)) - @test isequal_interval(/(interval(5.0, 6.0), interval(-0x5.0d4d319a50b04p-4, 0x2.d8f51df1e322ep-4)), entireinterval()) + @test isequal_interval(/(bareinterval(5.0, 6.0), bareinterval(-0x5.0d4d319a50b04p-4, 0x2.d8f51df1e322ep-4)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0x754ep0, +0xeeeeep0), interval(0.0, +0x11ep0)), interval(0x69p0, +Inf)) + @test isequal_interval(/(bareinterval(0x754ep0, +0xeeeeep0), bareinterval(0.0, +0x11ep0)), bareinterval(0x69p0, +Inf)) - @test isequal_interval(/(interval(0x1.7f03f2a978865p+0, 0xeeeeep0), interval(0.0, 0x1.48b08624606b9p+0)), interval(0x1.2a4fcda56843p+0, +Inf)) + @test isequal_interval(/(bareinterval(0x1.7f03f2a978865p+0, 0xeeeeep0), bareinterval(0.0, 0x1.48b08624606b9p+0)), bareinterval(0x1.2a4fcda56843p+0, +Inf)) - @test isequal_interval(/(interval(0x5efc1492p0, 0x1ba2dc763p0), interval(0x2fdd1fp0, 0x889b71p0)), interval(0xb2p0, 0x93dp0)) + @test isequal_interval(/(bareinterval(0x5efc1492p0, 0x1ba2dc763p0), bareinterval(0x2fdd1fp0, 0x889b71p0)), bareinterval(0xb2p0, 0x93dp0)) - @test isequal_interval(/(interval(0x1.d7c06f9ff0706p-8, 0x1ba2dc763p0), interval(0x2fdd1fp-20, 0xe.3d7a59e2bdacp+0)), interval(0x2.120d75be74b54p-12, 0x93dp+20)) + @test isequal_interval(/(bareinterval(0x1.d7c06f9ff0706p-8, 0x1ba2dc763p0), bareinterval(0x2fdd1fp-20, 0xe.3d7a59e2bdacp+0)), bareinterval(0x2.120d75be74b54p-12, 0x93dp+20)) - @test isequal_interval(/(interval(0x5.efc1492p-4, 0x1.008a3accc766dp+0), interval(0x2.497403b31d32ap+0, 0x8.89b71p+0)), interval(0xb.2p-8, 0x7.02d3edfbc8b6p-4)) + @test isequal_interval(/(bareinterval(0x5.efc1492p-4, 0x1.008a3accc766dp+0), bareinterval(0x2.497403b31d32ap+0, 0x8.89b71p+0)), bareinterval(0xb.2p-8, 0x7.02d3edfbc8b6p-4)) - @test isequal_interval(/(interval(0x8.440e7d65be6bp-8, 0x3.99982e9eae09ep+0), interval(0x8.29fa8d0659e48p-4, 0xc.13d2fd762e4a8p-4)), interval(0xa.f3518768b206p-8, 0x7.0e2acad54859cp+0)) + @test isequal_interval(/(bareinterval(0x8.440e7d65be6bp-8, 0x3.99982e9eae09ep+0), bareinterval(0x8.29fa8d0659e48p-4, 0xc.13d2fd762e4a8p-4)), bareinterval(0xa.f3518768b206p-8, 0x7.0e2acad54859cp+0)) end @testset "mpfi_div_d" begin - @test isequal_interval(/(interval(-Inf, -7.0), interval(-7.0, -7.0)), interval(1.0, +Inf)) + @test isequal_interval(/(bareinterval(-Inf, -7.0), bareinterval(-7.0, -7.0)), bareinterval(1.0, +Inf)) - @test isequal_interval(/(interval(-Inf, -7.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf, -7.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf, -7.0), interval(7.0, 7.0)), interval(-Inf, -1.0)) + @test isequal_interval(/(bareinterval(-Inf, -7.0), bareinterval(7.0, 7.0)), bareinterval(-Inf, -1.0)) - @test isequal_interval(/(interval(-Inf, 0.0), interval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(-Inf, 0.0), bareinterval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(-Inf, 0.0), interval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(-Inf, 0.0), bareinterval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(-Inf, 8.0), interval(-3.0, -3.0)), interval(-0x15555555555556p-51, +Inf)) + @test isequal_interval(/(bareinterval(-Inf, 8.0), bareinterval(-3.0, -3.0)), bareinterval(-0x15555555555556p-51, +Inf)) - @test isequal_interval(/(interval(-Inf, 8.0), interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(/(bareinterval(-Inf, 8.0), bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(-Inf, 8.0), interval(3.0, 3.0)), interval(-Inf, 0x15555555555556p-51)) + @test isequal_interval(/(bareinterval(-Inf, 8.0), bareinterval(3.0, 3.0)), bareinterval(-Inf, 0x15555555555556p-51)) - @test isequal_interval(/(entireinterval(), interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(0.0e-17, 0.0e-17)), emptyinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(0.0e-17, 0.0e-17)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(/(entireinterval(), interval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(/(entireinterval(BareInterval{Float64}), bareinterval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(/(interval(0.0, 0.0), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, 0.0), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), interval(0.0, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 0.0), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), bareinterval(0.0, 0.0)) - @test isequal_interval(/(interval(0.0, 8.0), interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), interval(-0x1d9b1f5d20d556p+5, 0.0)) + @test isequal_interval(/(bareinterval(0.0, 8.0), bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), bareinterval(-0x1d9b1f5d20d556p+5, 0.0)) - @test isequal_interval(/(interval(0.0, 8.0), interval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107)), interval(0.0, 0x1d9b1f5d20d556p+5)) + @test isequal_interval(/(bareinterval(0.0, 8.0), bareinterval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107)), bareinterval(0.0, 0x1d9b1f5d20d556p+5)) - @test isequal_interval(/(interval(0.0, +Inf), interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), interval(-Inf, 0.0)) + @test isequal_interval(/(bareinterval(0.0, +Inf), bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), bareinterval(-Inf, 0.0)) - @test isequal_interval(/(interval(0.0, +Inf), interval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), interval(0.0, +Inf)) + @test isequal_interval(/(bareinterval(0.0, +Inf), bareinterval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), bareinterval(0.0, +Inf)) - @test isequal_interval(/(interval(-0x10000000000001p-20, -0x10000000000001p-53), interval(-1.0, -1.0)), interval(0x10000000000001p-53, 0x10000000000001p-20)) + @test isequal_interval(/(bareinterval(-0x10000000000001p-20, -0x10000000000001p-53), bareinterval(-1.0, -1.0)), bareinterval(0x10000000000001p-53, 0x10000000000001p-20)) - @test isequal_interval(/(interval(-0x10000000000002p-20, -0x10000000000001p-53), interval(0x10000000000001p-53, 0x10000000000001p-53)), interval(-0x10000000000001p-19, -1.0)) + @test isequal_interval(/(bareinterval(-0x10000000000002p-20, -0x10000000000001p-53), bareinterval(0x10000000000001p-53, 0x10000000000001p-53)), bareinterval(-0x10000000000001p-19, -1.0)) - @test isequal_interval(/(interval(-0x10000000000001p-20, -0x10000020000001p-53), interval(0x10000000000001p-53, 0x10000000000001p-53)), interval(-0x1p+33, -0x1000001fffffffp-52)) + @test isequal_interval(/(bareinterval(-0x10000000000001p-20, -0x10000020000001p-53), bareinterval(0x10000000000001p-53, 0x10000000000001p-53)), bareinterval(-0x1p+33, -0x1000001fffffffp-52)) - @test isequal_interval(/(interval(-0x10000000000002p-20, -0x10000020000001p-53), interval(0x10000000000001p-53, 0x10000000000001p-53)), interval(-0x10000000000001p-19, -0x1000001fffffffp-52)) + @test isequal_interval(/(bareinterval(-0x10000000000002p-20, -0x10000020000001p-53), bareinterval(0x10000000000001p-53, 0x10000000000001p-53)), bareinterval(-0x10000000000001p-19, -0x1000001fffffffp-52)) - @test isequal_interval(/(interval(-0x123456789abcdfp-53, 0x123456789abcdfp-7), interval(-0x123456789abcdfp0, -0x123456789abcdfp0)), interval(-0x1p-7, 0x1p-53)) + @test isequal_interval(/(bareinterval(-0x123456789abcdfp-53, 0x123456789abcdfp-7), bareinterval(-0x123456789abcdfp0, -0x123456789abcdfp0)), bareinterval(-0x1p-7, 0x1p-53)) - @test isequal_interval(/(interval(-0x123456789abcdfp-53, 0x10000000000001p-53), interval(-0x123456789abcdfp0, -0x123456789abcdfp0)), interval(-0x1c200000000002p-106, 0x1p-53)) + @test isequal_interval(/(bareinterval(-0x123456789abcdfp-53, 0x10000000000001p-53), bareinterval(-0x123456789abcdfp0, -0x123456789abcdfp0)), bareinterval(-0x1c200000000002p-106, 0x1p-53)) - @test isequal_interval(/(interval(-1.0, 0x123456789abcdfp-7), interval(-0x123456789abcdfp0, -0x123456789abcdfp0)), interval(-0x1p-7, 0x1c200000000001p-105)) + @test isequal_interval(/(bareinterval(-1.0, 0x123456789abcdfp-7), bareinterval(-0x123456789abcdfp0, -0x123456789abcdfp0)), bareinterval(-0x1p-7, 0x1c200000000001p-105)) - @test isequal_interval(/(interval(-1.0, 0x10000000000001p-53), interval(-0x123456789abcdfp0, -0x123456789abcdfp0)), interval(-0x1c200000000002p-106, 0x1c200000000001p-105)) + @test isequal_interval(/(bareinterval(-1.0, 0x10000000000001p-53), bareinterval(-0x123456789abcdfp0, -0x123456789abcdfp0)), bareinterval(-0x1c200000000002p-106, 0x1c200000000001p-105)) end @testset "mpfi_d_sub" begin - @test isequal_interval(-(interval(-0x170ef54646d497p-107, -0x170ef54646d497p-107), interval(-Inf, -7.0)), interval(0x1bffffffffffffp-50, +Inf)) + @test isequal_interval(-(bareinterval(-0x170ef54646d497p-107, -0x170ef54646d497p-107), bareinterval(-Inf, -7.0)), bareinterval(0x1bffffffffffffp-50, +Inf)) - @test isequal_interval(-(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(7.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(7.0, +Inf)) - @test isequal_interval(-(interval(0x170ef54646d497p-107, 0x170ef54646d497p-107), interval(-Inf, -7.0)), interval(7.0, +Inf)) + @test isequal_interval(-(bareinterval(0x170ef54646d497p-107, 0x170ef54646d497p-107), bareinterval(-Inf, -7.0)), bareinterval(7.0, +Inf)) - @test isequal_interval(-(interval(-0x170ef54646d497p-96, -0x170ef54646d497p-96), interval(-Inf, 0.0)), interval(-0x170ef54646d497p-96, +Inf)) + @test isequal_interval(-(bareinterval(-0x170ef54646d497p-96, -0x170ef54646d497p-96), bareinterval(-Inf, 0.0)), bareinterval(-0x170ef54646d497p-96, +Inf)) - @test isequal_interval(-(interval(0.0, 0.0), interval(-Inf, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(-(interval(0x170ef54646d497p-96, 0x170ef54646d497p-96), interval(-Inf, 0.0)), interval(0x170ef54646d497p-96, +Inf)) + @test isequal_interval(-(bareinterval(0x170ef54646d497p-96, 0x170ef54646d497p-96), bareinterval(-Inf, 0.0)), bareinterval(0x170ef54646d497p-96, +Inf)) - @test isequal_interval(-(interval(-0x16345785d8a00000p0, -0x16345785d8a00000p0), interval(-Inf, 8.0)), interval(-0x16345785d8a00100p0, +Inf)) + @test isequal_interval(-(bareinterval(-0x16345785d8a00000p0, -0x16345785d8a00000p0), bareinterval(-Inf, 8.0)), bareinterval(-0x16345785d8a00100p0, +Inf)) - @test isequal_interval(-(interval(0.0, 0.0), interval(-Inf, 8.0)), interval(-8.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(-Inf, 8.0)), bareinterval(-8.0, +Inf)) - @test isequal_interval(-(interval(0x16345785d8a00000p0, 0x16345785d8a00000p0), interval(-Inf, 8.0)), interval(0x16345785d89fff00p0, +Inf)) + @test isequal_interval(-(bareinterval(0x16345785d8a00000p0, 0x16345785d8a00000p0), bareinterval(-Inf, 8.0)), bareinterval(0x16345785d89fff00p0, +Inf)) - @test isequal_interval(-(interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0.0e-17, 0.0e-17), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(0.0e-17, 0.0e-17), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0x170ef54646d497p-105, 0x170ef54646d497p-105), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(0x170ef54646d497p-105, 0x170ef54646d497p-105), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109), interval(0.0, 0.0)), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) + @test isequal_interval(-(bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109), bareinterval(0.0, 0.0)), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(-(interval(0x170ef54646d497p-109, 0x170ef54646d497p-109), interval(0.0, 0.0)), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)) + @test isequal_interval(-(bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109), bareinterval(0.0, 0.0)), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)) - @test isequal_interval(-(interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107), interval(0.0, 8.0)), interval(-0x10000000000001p-49, -0x114b37f4b51f71p-107)) + @test isequal_interval(-(bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107), bareinterval(0.0, 8.0)), bareinterval(-0x10000000000001p-49, -0x114b37f4b51f71p-107)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, 8.0)), interval(-8.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, 8.0)), bareinterval(-8.0, 0.0)) - @test isequal_interval(-(interval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107), interval(0.0, 8.0)), interval(-8.0, 0x114b37f4b51f71p-107)) + @test isequal_interval(-(bareinterval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107), bareinterval(0.0, 8.0)), bareinterval(-8.0, 0x114b37f4b51f71p-107)) - @test isequal_interval(-(interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104), interval(0.0, +Inf)), interval(-Inf, -0x50b45a75f7e81p-104)) + @test isequal_interval(-(bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104), bareinterval(0.0, +Inf)), bareinterval(-Inf, -0x50b45a75f7e81p-104)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, +Inf)), interval(-Inf, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, +Inf)), bareinterval(-Inf, 0.0)) - @test isequal_interval(-(interval(-0x142d169d7dfa03p-106, -0x142d169d7dfa03p-106), interval(0.0, +Inf)), interval(-Inf, -0x142d169d7dfa03p-106)) + @test isequal_interval(-(bareinterval(-0x142d169d7dfa03p-106, -0x142d169d7dfa03p-106), bareinterval(0.0, +Inf)), bareinterval(-Inf, -0x142d169d7dfa03p-106)) - @test isequal_interval(-(interval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47), interval(17.0, 32.0)), interval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) + @test isequal_interval(-(bareinterval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47), bareinterval(17.0, 32.0)), bareinterval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) - @test isequal_interval(-(interval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47), interval(17.0, 0xfb53d14aa9c2fp-47)), interval(0.0, 0x7353d14aa9c2fp-47)) + @test isequal_interval(-(bareinterval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47), bareinterval(17.0, 0xfb53d14aa9c2fp-47)), bareinterval(0.0, 0x7353d14aa9c2fp-47)) - @test isequal_interval(-(interval(0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48), interval(0xfb53d14aa9c2fp-48, 32.0)), interval(-0x104ac2eb5563d1p-48, 0.0)) + @test isequal_interval(-(bareinterval(0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48), bareinterval(0xfb53d14aa9c2fp-48, 32.0)), bareinterval(-0x104ac2eb5563d1p-48, 0.0)) - @test isequal_interval(-(interval(3.5, 3.5), interval(-0x123456789abcdfp-4, -0x123456789abcdfp-48)), interval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) + @test isequal_interval(-(bareinterval(3.5, 3.5), bareinterval(-0x123456789abcdfp-4, -0x123456789abcdfp-48)), bareinterval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) - @test isequal_interval(-(interval(3.5, 3.5), interval(-0x123456789abcdfp-4, -0x123456789abcdfp-56)), interval(0x3923456789abcdp-52, 0x123456789abd17p-4)) + @test isequal_interval(-(bareinterval(3.5, 3.5), bareinterval(-0x123456789abcdfp-4, -0x123456789abcdfp-56)), bareinterval(0x3923456789abcdp-52, 0x123456789abd17p-4)) - @test isequal_interval(-(interval(256.5, 256.5), interval(-0x123456789abcdfp-52, 0xffp0)), interval(0x18p-4, 0x101a3456789abdp-44)) + @test isequal_interval(-(bareinterval(256.5, 256.5), bareinterval(-0x123456789abcdfp-52, 0xffp0)), bareinterval(0x18p-4, 0x101a3456789abdp-44)) - @test isequal_interval(-(interval(4097.5, 4097.5), interval(0x1p-550, 0x1fffffffffffffp-52)), interval(0xfff8p-4, 0x10018p-4)) + @test isequal_interval(-(bareinterval(4097.5, 4097.5), bareinterval(0x1p-550, 0x1fffffffffffffp-52)), bareinterval(0xfff8p-4, 0x10018p-4)) - @test isequal_interval(-(interval(-3.5, -3.5), interval(-0x123456789abcdfp-4, -0x123456789abcdfp-48)), interval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) + @test isequal_interval(-(bareinterval(-3.5, -3.5), bareinterval(-0x123456789abcdfp-4, -0x123456789abcdfp-48)), bareinterval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) - @test isequal_interval(-(interval(-3.5, -3.5), interval(-0x123456789abcdfp-4, -0x123456789abcdfp-56)), interval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) + @test isequal_interval(-(bareinterval(-3.5, -3.5), bareinterval(-0x123456789abcdfp-4, -0x123456789abcdfp-56)), bareinterval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) - @test isequal_interval(-(interval(-256.5, -256.5), interval(-0x123456789abcdfp-52, 0xffp0)), interval(-0x1ff8p-4, -0xff5cba9876543p-44)) + @test isequal_interval(-(bareinterval(-256.5, -256.5), bareinterval(-0x123456789abcdfp-52, 0xffp0)), bareinterval(-0x1ff8p-4, -0xff5cba9876543p-44)) - @test isequal_interval(-(interval(-4097.5, -4097.5), interval(0x1p-550, 0x1fffffffffffffp-52)), interval(-0x10038p-4, -0x10018p-4)) + @test isequal_interval(-(bareinterval(-4097.5, -4097.5), bareinterval(0x1p-550, 0x1fffffffffffffp-52)), bareinterval(-0x10038p-4, -0x10018p-4)) end @testset "mpfi_exp" begin - @test isequal_interval(exp(interval(-Inf, -7.0)), interval(0.0, 0x1de16b9c24a98fp-63)) + @test isequal_interval(exp(bareinterval(-Inf, -7.0)), bareinterval(0.0, 0x1de16b9c24a98fp-63)) - @test isequal_interval(exp(interval(-Inf, 0.0)), interval(0.0, 1.0)) + @test isequal_interval(exp(bareinterval(-Inf, 0.0)), bareinterval(0.0, 1.0)) - @test isequal_interval(exp(interval(-Inf, +1.0)), interval(0.0, 0x15bf0a8b14576ap-51)) + @test isequal_interval(exp(bareinterval(-Inf, +1.0)), bareinterval(0.0, 0x15bf0a8b14576ap-51)) - @test isequal_interval(exp(entireinterval()), interval(0.0, +Inf)) + @test isequal_interval(exp(entireinterval(BareInterval{Float64})), bareinterval(0.0, +Inf)) - @test isequal_interval(exp(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(exp(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(exp(interval(0.0, +1.0)), interval(1.0, 0x15bf0a8b14576ap-51)) + @test isequal_interval(exp(bareinterval(0.0, +1.0)), bareinterval(1.0, 0x15bf0a8b14576ap-51)) - @test isequal_interval(exp(interval(0.0, +Inf)), interval(1.0, +Inf)) + @test isequal_interval(exp(bareinterval(0.0, +Inf)), bareinterval(1.0, +Inf)) - @test isequal_interval(exp(interval(-123.0, -17.0)), interval(0x1766b45dd84f17p-230, 0x1639e3175a689dp-77)) + @test isequal_interval(exp(bareinterval(-123.0, -17.0)), bareinterval(0x1766b45dd84f17p-230, 0x1639e3175a689dp-77)) - @test isequal_interval(exp(interval(-0.125, 0.25)), interval(0x1c3d6a24ed8221p-53, 0x148b5e3c3e8187p-52)) + @test isequal_interval(exp(bareinterval(-0.125, 0.25)), bareinterval(0x1c3d6a24ed8221p-53, 0x148b5e3c3e8187p-52)) - @test isequal_interval(exp(interval(-0.125, 0.0)), interval(0x1c3d6a24ed8221p-53, 1.0)) + @test isequal_interval(exp(bareinterval(-0.125, 0.0)), bareinterval(0x1c3d6a24ed8221p-53, 1.0)) - @test isequal_interval(exp(interval(0.0, 0.25)), interval(1.0, 0x148b5e3c3e8187p-52)) + @test isequal_interval(exp(bareinterval(0.0, 0.25)), bareinterval(1.0, 0x148b5e3c3e8187p-52)) - @test isequal_interval(exp(interval(0xap-47, 0xbp-47)), interval(0x10000000000140p-52, 0x10000000000161p-52)) + @test isequal_interval(exp(bareinterval(0xap-47, 0xbp-47)), bareinterval(0x10000000000140p-52, 0x10000000000161p-52)) end @testset "mpfi_exp2" begin - @test isequal_interval(exp2(interval(-Inf, -1.0)), interval(0.0, 0.5)) + @test isequal_interval(exp2(bareinterval(-Inf, -1.0)), bareinterval(0.0, 0.5)) - @test isequal_interval(exp2(interval(-Inf, 0.0)), interval(0.0, 1.0)) + @test isequal_interval(exp2(bareinterval(-Inf, 0.0)), bareinterval(0.0, 1.0)) - @test isequal_interval(exp2(interval(-Inf, 1.0)), interval(0.0, 2.0)) + @test isequal_interval(exp2(bareinterval(-Inf, 1.0)), bareinterval(0.0, 2.0)) - @test isequal_interval(exp2(entireinterval()), interval(0.0, +Inf)) + @test isequal_interval(exp2(entireinterval(BareInterval{Float64})), bareinterval(0.0, +Inf)) - @test isequal_interval(exp2(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(exp2(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(exp2(interval(0.0, +1.0)), interval(1.0, 2.0)) + @test isequal_interval(exp2(bareinterval(0.0, +1.0)), bareinterval(1.0, 2.0)) - @test isequal_interval(exp2(interval(0.0, +Inf)), interval(1.0, +Inf)) + @test isequal_interval(exp2(bareinterval(0.0, +Inf)), bareinterval(1.0, +Inf)) - @test isequal_interval(exp2(interval(-123.0, -17.0)), interval(0x1p-123, 0x1p-17)) + @test isequal_interval(exp2(bareinterval(-123.0, -17.0)), bareinterval(0x1p-123, 0x1p-17)) - @test isequal_interval(exp2(interval(-7.0, 7.0)), interval(0x1p-7, 0x1p+7)) + @test isequal_interval(exp2(bareinterval(-7.0, 7.0)), bareinterval(0x1p-7, 0x1p+7)) - @test isequal_interval(exp2(interval(-0.125, 0.25)), interval(0x1d5818dcfba487p-53, 0x1306fe0a31b716p-52)) + @test isequal_interval(exp2(bareinterval(-0.125, 0.25)), bareinterval(0x1d5818dcfba487p-53, 0x1306fe0a31b716p-52)) - @test isequal_interval(exp2(interval(-0.125, 0.0)), interval(0x1d5818dcfba487p-53, 1.0)) + @test isequal_interval(exp2(bareinterval(-0.125, 0.0)), bareinterval(0x1d5818dcfba487p-53, 1.0)) - @test isequal_interval(exp2(interval(0.0, 0.25)), interval(1.0, 0x1306fe0a31b716p-52)) + @test isequal_interval(exp2(bareinterval(0.0, 0.25)), bareinterval(1.0, 0x1306fe0a31b716p-52)) - @test isequal_interval(exp2(interval(0xap-47, 0xbp-47)), interval(0x100000000000ddp-52, 0x100000000000f4p-52)) + @test isequal_interval(exp2(bareinterval(0xap-47, 0xbp-47)), bareinterval(0x100000000000ddp-52, 0x100000000000f4p-52)) end @testset "mpfi_expm1" begin - @test isequal_interval(expm1(interval(-Inf, -7.0)), interval(-1.0, -0x1ff887a518f6d5p-53)) + @test isequal_interval(expm1(bareinterval(-Inf, -7.0)), bareinterval(-1.0, -0x1ff887a518f6d5p-53)) - @test isequal_interval(expm1(interval(-Inf, 0.0)), interval(-1.0, 0.0)) + @test isequal_interval(expm1(bareinterval(-Inf, 0.0)), bareinterval(-1.0, 0.0)) - @test isequal_interval(expm1(interval(-Inf, 1.0)), interval(-1.0, 0x1b7e151628aed3p-52)) + @test isequal_interval(expm1(bareinterval(-Inf, 1.0)), bareinterval(-1.0, 0x1b7e151628aed3p-52)) - @test isequal_interval(expm1(entireinterval()), interval(-1.0, +Inf)) + @test isequal_interval(expm1(entireinterval(BareInterval{Float64})), bareinterval(-1.0, +Inf)) - @test isequal_interval(expm1(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(expm1(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(expm1(interval(0.0, 1.0)), interval(0.0, 0x1b7e151628aed3p-52)) + @test isequal_interval(expm1(bareinterval(0.0, 1.0)), bareinterval(0.0, 0x1b7e151628aed3p-52)) - @test isequal_interval(expm1(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(expm1(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(expm1(interval(-36.0, -36.0)), interval(-0x1ffffffffffffep-53, -0x1ffffffffffffdp-53)) + @test isequal_interval(expm1(bareinterval(-36.0, -36.0)), bareinterval(-0x1ffffffffffffep-53, -0x1ffffffffffffdp-53)) - @test isequal_interval(expm1(interval(-0.125, 0.25)), interval(-0x1e14aed893eef4p-56, 0x122d78f0fa061ap-54)) + @test isequal_interval(expm1(bareinterval(-0.125, 0.25)), bareinterval(-0x1e14aed893eef4p-56, 0x122d78f0fa061ap-54)) - @test isequal_interval(expm1(interval(-0.125, 0.0)), interval(-0x1e14aed893eef4p-56, 0.0)) + @test isequal_interval(expm1(bareinterval(-0.125, 0.0)), bareinterval(-0x1e14aed893eef4p-56, 0.0)) - @test isequal_interval(expm1(interval(0.0, 0.25)), interval(0.0, 0x122d78f0fa061ap-54)) + @test isequal_interval(expm1(bareinterval(0.0, 0.25)), bareinterval(0.0, 0x122d78f0fa061ap-54)) - @test isequal_interval(expm1(interval(0xap-47, 0xbp-47)), interval(0x140000000000c8p-96, 0x160000000000f3p-96)) + @test isequal_interval(expm1(bareinterval(0xap-47, 0xbp-47)), bareinterval(0x140000000000c8p-96, 0x160000000000f3p-96)) end @testset "mpfi_hypot" begin - @test isequal_interval(hypot(interval(-Inf, -7.0), interval(-1.0, 8.0)), interval(7.0, +Inf)) + @test isequal_interval(hypot(bareinterval(-Inf, -7.0), bareinterval(-1.0, 8.0)), bareinterval(7.0, +Inf)) - @test isequal_interval(hypot(interval(-Inf, 0.0), interval(8.0, +Inf)), interval(8.0, +Inf)) + @test isequal_interval(hypot(bareinterval(-Inf, 0.0), bareinterval(8.0, +Inf)), bareinterval(8.0, +Inf)) - @test isequal_interval(hypot(interval(-Inf, 8.0), interval(0.0, 8.0)), interval(0.0, +Inf)) + @test isequal_interval(hypot(bareinterval(-Inf, 8.0), bareinterval(0.0, 8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hypot(entireinterval(), interval(0.0, 8.0)), interval(0.0, +Inf)) + @test isequal_interval(hypot(entireinterval(BareInterval{Float64}), bareinterval(0.0, 8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hypot(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(7.0, +Inf)) + @test isequal_interval(hypot(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(7.0, +Inf)) - @test isequal_interval(hypot(interval(0.0, 3.0), interval(-4.0, 0.0)), interval(0.0, 5.0)) + @test isequal_interval(hypot(bareinterval(0.0, 3.0), bareinterval(-4.0, 0.0)), bareinterval(0.0, 5.0)) - @test isequal_interval(hypot(interval(0.0, 0.0), interval(0.0, 8.0)), interval(0.0, 8.0)) + @test isequal_interval(hypot(bareinterval(0.0, 0.0), bareinterval(0.0, 8.0)), bareinterval(0.0, 8.0)) - @test isequal_interval(hypot(interval(0.0, +Inf), interval(0.0, 8.0)), interval(0.0, +Inf)) + @test isequal_interval(hypot(bareinterval(0.0, +Inf), bareinterval(0.0, 8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hypot(interval(0.0, 0.0), interval(8.0, +Inf)), interval(8.0, +Inf)) + @test isequal_interval(hypot(bareinterval(0.0, 0.0), bareinterval(8.0, +Inf)), bareinterval(8.0, +Inf)) - @test isequal_interval(hypot(interval(0.0, 0.0), entireinterval()), interval(0.0, +Inf)) + @test isequal_interval(hypot(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, +Inf)) - @test isequal_interval(hypot(interval(0.0, 5.0), interval(0.0, 12.0)), interval(0.0, 13.0)) + @test isequal_interval(hypot(bareinterval(0.0, 5.0), bareinterval(0.0, 12.0)), bareinterval(0.0, 13.0)) - @test isequal_interval(hypot(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(hypot(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(hypot(interval(0.0, +Inf), interval(-7.0, 8.0)), interval(0.0, +Inf)) + @test isequal_interval(hypot(bareinterval(0.0, +Inf), bareinterval(-7.0, 8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hypot(interval(-12.0, -5.0), interval(-35.0, -12.0)), interval(13.0, 37.0)) + @test isequal_interval(hypot(bareinterval(-12.0, -5.0), bareinterval(-35.0, -12.0)), bareinterval(13.0, 37.0)) - @test isequal_interval(hypot(interval(6.0, 7.0), interval(1.0, 24.0)), interval(0x1854bfb363dc39p-50, 25.0)) + @test isequal_interval(hypot(bareinterval(6.0, 7.0), bareinterval(1.0, 24.0)), bareinterval(0x1854bfb363dc39p-50, 25.0)) - @test isequal_interval(hypot(interval(-4.0, +7.0), interval(-25.0, 3.0)), interval(0.0, 0x19f625847a5899p-48)) + @test isequal_interval(hypot(bareinterval(-4.0, +7.0), bareinterval(-25.0, 3.0)), bareinterval(0.0, 0x19f625847a5899p-48)) - @test isequal_interval(hypot(interval(0x1854bfb363dc39p-50, 0x19f625847a5899p-48), interval(0x1854bfb363dc39p-50, 0x19f625847a5899p-48)), interval(0x113463fa37014dp-49, 0x125b89092b8fc0p-47)) + @test isequal_interval(hypot(bareinterval(0x1854bfb363dc39p-50, 0x19f625847a5899p-48), bareinterval(0x1854bfb363dc39p-50, 0x19f625847a5899p-48)), bareinterval(0x113463fa37014dp-49, 0x125b89092b8fc0p-47)) end @testset "mpfi_intersect" begin - @test isequal_interval(intersect_interval(interval(-Inf, -7.0), interval(-1.0, +8.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-Inf, 0.0), interval(+8.0, +Inf)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(intersect_interval(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(intersect_interval(entireinterval(), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(intersect_interval(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(intersect_interval(interval(0.0, 0.0), interval(-Inf, -7.0)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(intersect_interval(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, 0.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(intersect_interval(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(intersect_interval(interval(0.0, 0.0), interval(+8.0, +Inf)), emptyinterval()) + @test isequal_interval(intersect_interval(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(intersect_interval(interval(0.0, 0.0), entireinterval()), interval(0.0, 0.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0.0)) - @test isequal_interval(intersect_interval(interval(0.0, +8.0), interval(-7.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(intersect_interval(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(intersect_interval(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(intersect_interval(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(intersect_interval(interval(0x12p0, 0x90p0), interval(-0x0dp0, 0x34p0)), interval(0x12p0, 0x34p0)) + @test isequal_interval(intersect_interval(bareinterval(0x12p0, 0x90p0), bareinterval(-0x0dp0, 0x34p0)), bareinterval(0x12p0, 0x34p0)) end @testset "mpfi_inv" begin - @test isequal_interval(inv(interval(-Inf, -.25)), interval(-4.0, 0.0)) + @test isequal_interval(inv(bareinterval(-Inf, -.25)), bareinterval(-4.0, 0.0)) - @test isequal_interval(inv(interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(inv(bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(inv(interval(-Inf, +4.0)), entireinterval()) + @test isequal_interval(inv(bareinterval(-Inf, +4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(inv(entireinterval()), entireinterval()) + @test isequal_interval(inv(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(0.0, 0.0)), emptyinterval()) + @test isequal_interval(inv(bareinterval(0.0, 0.0)), emptyinterval(BareInterval{Float64})) - @test isequal_interval(inv(interval(0.0, +2.0)), interval(+.5, +Inf)) + @test isequal_interval(inv(bareinterval(0.0, +2.0)), bareinterval(+.5, +Inf)) - @test isequal_interval(inv(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(inv(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(inv(interval(-8.0, -2.0)), interval(-.5, -0.125)) + @test isequal_interval(inv(bareinterval(-8.0, -2.0)), bareinterval(-.5, -0.125)) - @test isequal_interval(inv(interval(0x1p-4, 0x1440c131282cd9p-53)), interval(0x1947bfce1bc417p-52, 0x10p0)) + @test isequal_interval(inv(bareinterval(0x1p-4, 0x1440c131282cd9p-53)), bareinterval(0x1947bfce1bc417p-52, 0x10p0)) - @test isequal_interval(inv(interval(0x19f1a539c91fddp-55, +64.0)), interval(0.015625, 0x13bc205a76b3fdp-50)) + @test isequal_interval(inv(bareinterval(0x19f1a539c91fddp-55, +64.0)), bareinterval(0.015625, 0x13bc205a76b3fdp-50)) - @test isequal_interval(inv(interval(-0xae83b95effd69p-52, -0x63e3cb4ed72a3p-53)), interval(-0x1480a9b5772a23p-50, -0x177887d65484c9p-52)) + @test isequal_interval(inv(bareinterval(-0xae83b95effd69p-52, -0x63e3cb4ed72a3p-53)), bareinterval(-0x1480a9b5772a23p-50, -0x177887d65484c9p-52)) end @testset "mpfi_is_neg" begin - @test precedes(interval(-Inf, -8.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-Inf, -8.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-Inf, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-Inf, 5.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-Inf, 5.0), bareinterval(0.0, 0.0)) == false - @test precedes(entireinterval(), interval(0.0, 0.0)) == false + @test precedes(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-8.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-8.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 5.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0.0, 5.0), bareinterval(0.0, 0.0)) == false - @test precedes(interval(0.0, +Inf), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)) == false - @test precedes(interval(5.0, +Inf), interval(0.0, 0.0)) == false + @test precedes(bareinterval(5.0, +Inf), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-34.0, -17.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-34.0, -17.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-8.0, -1.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-8.0, -1.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-34.0, 17.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-34.0, 17.0), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(+8.0, +0x7fffffffffffbp+51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(+8.0, +0x7fffffffffffbp+51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(+0x1fffffffffffffp-53, 2.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(+0x1fffffffffffffp-53, 2.0), bareinterval(0.0, 0.0)) == false end @testset "mpfi_is_nonneg" begin - @test precedes(interval(0.0, 0.0), interval(-Inf, -8.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, -8.0)) == false - @test precedes(interval(0.0, 0.0), interval(-Inf, 0.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)) == false - @test precedes(interval(0.0, 0.0), interval(-Inf, 5.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 5.0)) == false - @test precedes(interval(0.0, 0.0), entireinterval()) == false + @test precedes(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})) == false - @test precedes(interval(0.0, 0.0), interval(-8.0, 0.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-8.0, 0.0)) == false - @test precedes(interval(0.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, 5.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 5.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, +Inf)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, +Inf)) == true - @test precedes(interval(0.0, 0.0), interval(5.0, +Inf)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(5.0, +Inf)) == true - @test precedes(interval(0.0, 0.0), interval(-34.0, -17.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-34.0, -17.0)) == false - @test precedes(interval(0.0, 0.0), interval(-8.0, -1.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-8.0, -1.0)) == false - @test precedes(interval(0.0, 0.0), interval(-34.0, 17.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-34.0, 17.0)) == false - @test precedes(interval(0.0, 0.0), interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false - @test precedes(interval(0.0, 0.0), interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true - @test precedes(interval(0.0, 0.0), interval(+8.0, +0x7fffffffffffbp+51)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(+8.0, +0x7fffffffffffbp+51)) == true - @test precedes(interval(0.0, 0.0), interval(+0x1fffffffffffffp-53, 2.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(+0x1fffffffffffffp-53, 2.0)) == true end @testset "mpfi_is_nonpos" begin - @test precedes(interval(-Inf, -8.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-Inf, -8.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-Inf, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-Inf, 5.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-Inf, 5.0), bareinterval(0.0, 0.0)) == false - @test precedes(entireinterval(), interval(0.0, 0.0)) == false + @test precedes(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-8.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-8.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 5.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0.0, 5.0), bareinterval(0.0, 0.0)) == false - @test precedes(interval(0.0, +Inf), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)) == false - @test precedes(interval(5.0, +Inf), interval(0.0, 0.0)) == false + @test precedes(bareinterval(5.0, +Inf), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-34.0, -17.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-34.0, -17.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-8.0, -1.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(-8.0, -1.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(-34.0, 17.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-34.0, 17.0), bareinterval(0.0, 0.0)) == false - @test precedes(interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(8.0, 0x7fffffffffffbp+51), interval(0.0, 0.0)) == false + @test precedes(bareinterval(8.0, 0x7fffffffffffbp+51), bareinterval(0.0, 0.0)) == false - @test precedes(interval(0x1fffffffffffffp-53, 2.0), interval(0.0, 0.0)) == false + @test precedes(bareinterval(0x1fffffffffffffp-53, 2.0), bareinterval(0.0, 0.0)) == false end @testset "mpfi_is_pos" begin - @test precedes(interval(0.0, 0.0), interval(-Inf, -8.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, -8.0)) == false - @test precedes(interval(0.0, 0.0), interval(-Inf, 0.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)) == false - @test precedes(interval(0.0, 0.0), interval(-Inf, 5.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 5.0)) == false - @test precedes(interval(0.0, 0.0), entireinterval()) == false + @test precedes(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})) == false - @test precedes(interval(0.0, 0.0), interval(-8.0, 0.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-8.0, 0.0)) == false - @test precedes(interval(0.0, 0.0), interval(0.0, 0.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, 5.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, 5.0)) == true - @test precedes(interval(0.0, 0.0), interval(0.0, +Inf)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0.0, +Inf)) == true - @test precedes(interval(0.0, 0.0), interval(5.0, +Inf)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(5.0, +Inf)) == true - @test precedes(interval(0.0, 0.0), interval(-34.0, -17.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-34.0, -17.0)) == false - @test precedes(interval(0.0, 0.0), interval(-8.0, -1.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-8.0, -1.0)) == false - @test precedes(interval(0.0, 0.0), interval(-34.0, 17.0)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-34.0, 17.0)) == false - @test precedes(interval(0.0, 0.0), interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false + @test precedes(bareinterval(0.0, 0.0), bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false - @test precedes(interval(0.0, 0.0), interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true - @test precedes(interval(0.0, 0.0), interval(+8.0, +0x7fffffffffffbp+51)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(+8.0, +0x7fffffffffffbp+51)) == true - @test precedes(interval(0.0, 0.0), interval(+0x1fffffffffffffp-53, 2.0)) == true + @test precedes(bareinterval(0.0, 0.0), bareinterval(+0x1fffffffffffffp-53, 2.0)) == true end @testset "mpfi_is_strictly_neg" begin - @test strictprecedes(interval(-Inf, -8.0), interval(0.0, 0.0)) == true + @test strictprecedes(bareinterval(-Inf, -8.0), bareinterval(0.0, 0.0)) == true - @test strictprecedes(interval(-Inf, 0.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(-Inf, 5.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(-Inf, 5.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(entireinterval(), interval(0.0, 0.0)) == false + @test strictprecedes(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(-8.0, 0.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(-8.0, 0.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(0.0, 5.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(0.0, 5.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(0.0, +Inf), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(5.0, +Inf), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(5.0, +Inf), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(-34.0, -17.0), interval(0.0, 0.0)) == true + @test strictprecedes(bareinterval(-34.0, -17.0), bareinterval(0.0, 0.0)) == true - @test strictprecedes(interval(-8.0, -1.0), interval(0.0, 0.0)) == true + @test strictprecedes(bareinterval(-8.0, -1.0), bareinterval(0.0, 0.0)) == true - @test strictprecedes(interval(-34.0, 17.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(-34.0, 17.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(+8.0, +0x7fffffffffffbp+51), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(+8.0, +0x7fffffffffffbp+51), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(+0x1fffffffffffffp-53, 2.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(+0x1fffffffffffffp-53, 2.0), bareinterval(0.0, 0.0)) == false end @testset "mpfi_is_strictly_pos" begin - @test strictprecedes(interval(0.0, 0.0), interval(-Inf, -8.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-Inf, -8.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(-Inf, 0.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(-Inf, 5.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-Inf, 5.0)) == false - @test strictprecedes(interval(0.0, 0.0), entireinterval()) == false + @test strictprecedes(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})) == false - @test strictprecedes(interval(0.0, 0.0), interval(-8.0, 0.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-8.0, 0.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(0.0, 0.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(0.0, 5.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(0.0, 5.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(0.0, +Inf)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(0.0, +Inf)) == false - @test strictprecedes(interval(0.0, 0.0), interval(5.0, +Inf)) == true + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(5.0, +Inf)) == true - @test strictprecedes(interval(0.0, 0.0), interval(-34.0, -17.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-34.0, -17.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(-8.0, -1.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-8.0, -1.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(-34.0, 17.0)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-34.0, 17.0)) == false - @test strictprecedes(interval(0.0, 0.0), interval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(-0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == false - @test strictprecedes(interval(0.0, 0.0), interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == true - @test strictprecedes(interval(0.0, 0.0), interval(+8.0, +0x7fffffffffffbp+51)) == true + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(+8.0, +0x7fffffffffffbp+51)) == true - @test strictprecedes(interval(0.0, 0.0), interval(+0x1fffffffffffffp-53, 2.0)) == true + @test strictprecedes(bareinterval(0.0, 0.0), bareinterval(+0x1fffffffffffffp-53, 2.0)) == true end @testset "mpfi_log" begin - @test isequal_interval(log(interval(0.0, +1.0)), interval(-Inf, 0.0)) + @test isequal_interval(log(bareinterval(0.0, +1.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(log(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(log(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log(interval(+1.0, +1.0)), interval(0.0, 0.0)) + @test isequal_interval(log(bareinterval(+1.0, +1.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(log(interval(0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14)), interval(0xc6dc8a2928579p-47, 0x1a9500bc7ffcc5p-48)) + @test isequal_interval(log(bareinterval(0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14)), bareinterval(0xc6dc8a2928579p-47, 0x1a9500bc7ffcc5p-48)) - @test isequal_interval(log(interval(0xb616ab8b683b5p-52, +1.0)), interval(-0x2b9b8b1fb2fb9p-51, 0.0)) + @test isequal_interval(log(bareinterval(0xb616ab8b683b5p-52, +1.0)), bareinterval(-0x2b9b8b1fb2fb9p-51, 0.0)) - @test isequal_interval(log(interval(+1.0, 0x8ac74d932fae3p-21)), interval(0.0, 0x5380455576989p-46)) + @test isequal_interval(log(bareinterval(+1.0, 0x8ac74d932fae3p-21)), bareinterval(0.0, 0x5380455576989p-46)) - @test isequal_interval(log(interval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), interval(0xbdee7228cfedfp-47, 0x1b3913fc99f555p-48)) + @test isequal_interval(log(bareinterval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), bareinterval(0xbdee7228cfedfp-47, 0x1b3913fc99f555p-48)) end @testset "mpfi_log1p" begin - @test isequal_interval(log1p(interval(-1.0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(log1p(bareinterval(-1.0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(log1p(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(log1p(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(log1p(interval(0.0, 1.0)), interval(0.0, 0x162e42fefa39f0p-53)) + @test isequal_interval(log1p(bareinterval(0.0, 1.0)), bareinterval(0.0, 0x162e42fefa39f0p-53)) - @test isequal_interval(log1p(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(log1p(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(log1p(interval(-0xb616ab8b683b5p-52, 0.0)), interval(-0x13e080325bab7bp-52, 0.0)) + @test isequal_interval(log1p(bareinterval(-0xb616ab8b683b5p-52, 0.0)), bareinterval(-0x13e080325bab7bp-52, 0.0)) - @test isequal_interval(log1p(interval(0.0, 0x8ac74d932fae3p-21)), interval(0.0, 0x14e0115561569cp-48)) + @test isequal_interval(log1p(bareinterval(0.0, 0x8ac74d932fae3p-21)), bareinterval(0.0, 0x14e0115561569cp-48)) - @test isequal_interval(log1p(interval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), interval(0x17bdce451a337fp-48, 0x1b3913fc99f6fcp-48)) + @test isequal_interval(log1p(bareinterval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), bareinterval(0x17bdce451a337fp-48, 0x1b3913fc99f6fcp-48)) end @testset "mpfi_log2" begin - @test isequal_interval(log2(interval(0.0, +1.0)), interval(-Inf, 0.0)) + @test isequal_interval(log2(bareinterval(0.0, +1.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(log2(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(log2(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log2(interval(1.0, 1.0)), interval(0.0, 0.0)) + @test isequal_interval(log2(bareinterval(1.0, 1.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(log2(interval(0xb616ab8b683b5p-52, 1.0)), interval(-0x1f74cb5d105b3ap-54, 0.0)) + @test isequal_interval(log2(bareinterval(0xb616ab8b683b5p-52, 1.0)), bareinterval(-0x1f74cb5d105b3ap-54, 0.0)) - @test isequal_interval(log2(interval(1.0, 0x8ac74d932fae3p-21)), interval(0.0, 0x1e1ddc27c2c70fp-48)) + @test isequal_interval(log2(bareinterval(1.0, 0x8ac74d932fae3p-21)), bareinterval(0.0, 0x1e1ddc27c2c70fp-48)) - @test isequal_interval(log2(interval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), interval(0x112035c9390c07p-47, 0x13a3208f61f10cp-47)) + @test isequal_interval(log2(bareinterval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), bareinterval(0x112035c9390c07p-47, 0x13a3208f61f10cp-47)) end @testset "mpfi_log10" begin - @test isequal_interval(log10(interval(0.0, 1.0)), interval(-Inf, 0.0)) + @test isequal_interval(log10(bareinterval(0.0, 1.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(log10(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(log10(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(log10(interval(1.0, 1.0)), interval(0.0, 0.0)) + @test isequal_interval(log10(bareinterval(1.0, 1.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(log10(interval(0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14)), interval(0x159753104a9401p-49, 0x1716c01a04b570p-49)) + @test isequal_interval(log10(bareinterval(0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14)), bareinterval(0x159753104a9401p-49, 0x1716c01a04b570p-49)) - @test isequal_interval(log10(interval(0xb616ab8b683b5p-52, 1.0)), interval(-0x12f043ec00f8d6p-55, 0.0)) + @test isequal_interval(log10(bareinterval(0xb616ab8b683b5p-52, 1.0)), bareinterval(-0x12f043ec00f8d6p-55, 0.0)) - @test isequal_interval(log10(interval(100.0, 0x8ac74d932fae3p-21)), interval(2.0, 0x1221cc590b9946p-49)) + @test isequal_interval(log10(bareinterval(100.0, 0x8ac74d932fae3p-21)), bareinterval(2.0, 0x1221cc590b9946p-49)) - @test isequal_interval(log10(interval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), interval(0x149f1d70168f49p-49, 0x17a543a94fb65ep-49)) + @test isequal_interval(log10(bareinterval(0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11)), bareinterval(0x149f1d70168f49p-49, 0x17a543a94fb65ep-49)) end @testset "mpfi_mag" begin - @test mag(interval(-Inf, -8.0)) == +Inf + @test mag(bareinterval(-Inf, -8.0)) == +Inf - @test mag(interval(-Inf, 0.0)) == +Inf + @test mag(bareinterval(-Inf, 0.0)) == +Inf - @test mag(interval(-Inf, 5.0)) == +Inf + @test mag(bareinterval(-Inf, 5.0)) == +Inf - @test mag(entireinterval()) == +Inf + @test mag(entireinterval(BareInterval{Float64})) == +Inf - @test mag(interval(-Inf, 0.0)) == +Inf + @test mag(bareinterval(-Inf, 0.0)) == +Inf - @test mag(interval(-8.0, 0.0)) == +8.0 + @test mag(bareinterval(-8.0, 0.0)) == +8.0 - @test mag(interval(0.0, 0.0)) == +0.0 + @test mag(bareinterval(0.0, 0.0)) == +0.0 - @test mag(interval(0.0, 5.0)) == +5.0 + @test mag(bareinterval(0.0, 5.0)) == +5.0 - @test mag(interval(0.0, +Inf)) == +Inf + @test mag(bareinterval(0.0, +Inf)) == +Inf - @test mag(interval(-34.0, -17.0)) == 34.0 + @test mag(bareinterval(-34.0, -17.0)) == 34.0 end @testset "mpfi_mid" begin - @test mid(interval(-8.0, 0.0)) == -4.0 + @test mid(bareinterval(-8.0, 0.0)) == -4.0 - @test mid(interval(0.0, 0.0)) == +0.0 + @test mid(bareinterval(0.0, 0.0)) == +0.0 - @test mid(interval(0.0, 5.0)) == +2.5 + @test mid(bareinterval(0.0, 5.0)) == +2.5 - @test mid(interval(-34.0, -17.0)) == -0x33p-1 + @test mid(bareinterval(-34.0, -17.0)) == -0x33p-1 - @test mid(interval(-34.0, 17.0)) == -8.5 + @test mid(bareinterval(-34.0, 17.0)) == -8.5 - @test mid(interval(0.0, +0x123456789abcdp-2)) == +0x123456789abcdp-3 + @test mid(bareinterval(0.0, +0x123456789abcdp-2)) == +0x123456789abcdp-3 - @test mid(interval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == 0x1921fb54442d18p-51 + @test mid(bareinterval(0x1921fb54442d18p-51, 0x1921fb54442d19p-51)) == 0x1921fb54442d18p-51 - @test mid(interval(-0x1921fb54442d19p-51, -0x1921fb54442d18p-51)) == -0x1921fb54442d18p-51 + @test mid(bareinterval(-0x1921fb54442d19p-51, -0x1921fb54442d18p-51)) == -0x1921fb54442d18p-51 - @test mid(interval(-4.0, -0x7fffffffffffdp-51)) == -0x27fffffffffffbp-52 + @test mid(bareinterval(-4.0, -0x7fffffffffffdp-51)) == -0x27fffffffffffbp-52 - @test mid(interval(-8.0, -0x7fffffffffffbp-51)) == -0x47fffffffffffbp-52 + @test mid(bareinterval(-8.0, -0x7fffffffffffbp-51)) == -0x47fffffffffffbp-52 - @test mid(interval(-0x1fffffffffffffp-53, 2.0)) == 0.5 + @test mid(bareinterval(-0x1fffffffffffffp-53, 2.0)) == 0.5 end @testset "mpfi_mig" begin - @test mig(interval(-Inf, -8.0)) == 8.0 + @test mig(bareinterval(-Inf, -8.0)) == 8.0 - @test mig(interval(-Inf, 0.0)) == +0.0 + @test mig(bareinterval(-Inf, 0.0)) == +0.0 - @test mig(interval(-Inf, 5.0)) == +0.0 + @test mig(bareinterval(-Inf, 5.0)) == +0.0 - @test mig(entireinterval()) == +0.0 + @test mig(entireinterval(BareInterval{Float64})) == +0.0 - @test mig(interval(-Inf, 0.0)) == +0.0 + @test mig(bareinterval(-Inf, 0.0)) == +0.0 - @test mig(interval(-8.0, 0.0)) == +0.0 + @test mig(bareinterval(-8.0, 0.0)) == +0.0 - @test mig(interval(0.0, 0.0)) == +0.0 + @test mig(bareinterval(0.0, 0.0)) == +0.0 - @test mig(interval(0.0, 5.0)) == +0.0 + @test mig(bareinterval(0.0, 5.0)) == +0.0 - @test mig(interval(0.0, +Inf)) == +0.0 + @test mig(bareinterval(0.0, +Inf)) == +0.0 - @test mig(interval(-34.0, -17.0)) == 17.0 + @test mig(bareinterval(-34.0, -17.0)) == 17.0 end @testset "mpfi_mul" begin - @test isequal_interval(*(interval(-Inf, -7.0), interval(-1.0, +8.0)), entireinterval()) + @test isequal_interval(*(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(-Inf, 0.0), interval(+8.0, +Inf)), interval(-Inf, 0.0)) + @test isequal_interval(*(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), bareinterval(-Inf, 0.0)) - @test isequal_interval(*(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(-Inf, +64.0)) + @test isequal_interval(*(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(-Inf, +64.0)) - @test isequal_interval(*(entireinterval(), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(entireinterval(), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(-56.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(-56.0, 0.0)) - @test isequal_interval(*(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(*(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(*(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, 0.0), entireinterval()), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, +8.0), interval(-7.0, +8.0)), interval(-56.0, +64.0)) + @test isequal_interval(*(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), bareinterval(-56.0, +64.0)) - @test isequal_interval(*(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(*(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(*(interval(-3.0, +7.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(-3.0, +7.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(-0x0dp0, -0x09p0), interval(-0x04p0, -0x02p0)), interval(0x12p0, 0x34p0)) + @test isequal_interval(*(bareinterval(-0x0dp0, -0x09p0), bareinterval(-0x04p0, -0x02p0)), bareinterval(0x12p0, 0x34p0)) - @test isequal_interval(*(interval(-0x0dp0, -0xd.f0e7927d247cp-4), interval(-0x04p0, -0xa.41084aff48f8p-8)), interval(0x8.ef3aa21dba748p-8, 0x34p0)) + @test isequal_interval(*(bareinterval(-0x0dp0, -0xd.f0e7927d247cp-4), bareinterval(-0x04p0, -0xa.41084aff48f8p-8)), bareinterval(0x8.ef3aa21dba748p-8, 0x34p0)) - @test isequal_interval(*(interval(-0xe.26c9e9eb67b48p-4, -0x8.237d2eb8b1178p-4), interval(-0x5.8c899a0706d5p-4, -0x3.344e57a37b5e8p-4)), interval(0x1.a142a930de328p-4, 0x4.e86c3434cd924p-4)) + @test isequal_interval(*(bareinterval(-0xe.26c9e9eb67b48p-4, -0x8.237d2eb8b1178p-4), bareinterval(-0x5.8c899a0706d5p-4, -0x3.344e57a37b5e8p-4)), bareinterval(0x1.a142a930de328p-4, 0x4.e86c3434cd924p-4)) - @test isequal_interval(*(interval(-0x37p0, -0x07p0), interval(-0x01p0, 0x22p0)), interval(-0x74ep0, 0x37p0)) + @test isequal_interval(*(bareinterval(-0x37p0, -0x07p0), bareinterval(-0x01p0, 0x22p0)), bareinterval(-0x74ep0, 0x37p0)) - @test isequal_interval(*(interval(-0xe.063f267ed51ap-4, -0x0.33p0), interval(-0x01p0, 0x1.777ab178b4a1ep+0)), interval(-0x1.491df346a9f15p+0, 0xe.063f267ed51ap-4)) + @test isequal_interval(*(bareinterval(-0xe.063f267ed51ap-4, -0x0.33p0), bareinterval(-0x01p0, 0x1.777ab178b4a1ep+0)), bareinterval(-0x1.491df346a9f15p+0, 0xe.063f267ed51ap-4)) - @test isequal_interval(*(interval(-0x1.cb540b71699a8p+4, -0x0.33p0), interval(-0x1.64dcaaa101f18p+0, 0x01p0)), interval(-0x1.cb540b71699a8p+4, 0x2.804cce4a3f42ep+4)) + @test isequal_interval(*(bareinterval(-0x1.cb540b71699a8p+4, -0x0.33p0), bareinterval(-0x1.64dcaaa101f18p+0, 0x01p0)), bareinterval(-0x1.cb540b71699a8p+4, 0x2.804cce4a3f42ep+4)) - @test isequal_interval(*(interval(-0x1.cb540b71699a8p+4, -0x0.33p0), interval(-0x1.64dcaaa101f18p+0, 0x1.eb67a1a6ef725p+4)), interval(-0x3.71b422ce817f4p+8, 0x2.804cce4a3f42ep+4)) + @test isequal_interval(*(bareinterval(-0x1.cb540b71699a8p+4, -0x0.33p0), bareinterval(-0x1.64dcaaa101f18p+0, 0x1.eb67a1a6ef725p+4)), bareinterval(-0x3.71b422ce817f4p+8, 0x2.804cce4a3f42ep+4)) - @test isequal_interval(*(interval(-0x123456789ap0, -0x01p0), interval(0x01p0, 0x10p0)), interval(-0x123456789a0p0, -0x01p0)) + @test isequal_interval(*(bareinterval(-0x123456789ap0, -0x01p0), bareinterval(0x01p0, 0x10p0)), bareinterval(-0x123456789a0p0, -0x01p0)) - @test isequal_interval(*(interval(-0xb.6c67d3a37d54p-4, -0x0.8p0), interval(0x02p0, 0x2.0bee4e8bb3dfp+0)), interval(-0x1.7611a672948a5p+0, -0x01p0)) + @test isequal_interval(*(bareinterval(-0xb.6c67d3a37d54p-4, -0x0.8p0), bareinterval(0x02p0, 0x2.0bee4e8bb3dfp+0)), bareinterval(-0x1.7611a672948a5p+0, -0x01p0)) - @test isequal_interval(*(interval(-0x04p0, -0xa.497d533c3b2ep-8), interval(0xb.d248df3373e68p-4, 0x04p0)), interval(-0x10p0, -0x7.99b990532d434p-8)) + @test isequal_interval(*(bareinterval(-0x04p0, -0xa.497d533c3b2ep-8), bareinterval(0xb.d248df3373e68p-4, 0x04p0)), bareinterval(-0x10p0, -0x7.99b990532d434p-8)) - @test isequal_interval(*(interval(-0xb.6c67d3a37d54p-4, -0xa.497d533c3b2ep-8), interval(0xb.d248df3373e68p-4, 0x2.0bee4e8bb3dfp+0)), interval(-0x1.7611a672948a5p+0, -0x7.99b990532d434p-8)) + @test isequal_interval(*(bareinterval(-0xb.6c67d3a37d54p-4, -0xa.497d533c3b2ep-8), bareinterval(0xb.d248df3373e68p-4, 0x2.0bee4e8bb3dfp+0)), bareinterval(-0x1.7611a672948a5p+0, -0x7.99b990532d434p-8)) - @test isequal_interval(*(interval(-0x01p0, 0x11p0), interval(-0x07p0, -0x04p0)), interval(-0x77p0, 0x07p0)) + @test isequal_interval(*(bareinterval(-0x01p0, 0x11p0), bareinterval(-0x07p0, -0x04p0)), bareinterval(-0x77p0, 0x07p0)) - @test isequal_interval(*(interval(-0x01p0, 0xe.ca7ddfdb8572p-4), interval(-0x2.3b46226145234p+0, -0x0.1p0)), interval(-0x2.101b41d3d48b8p+0, 0x2.3b46226145234p+0)) + @test isequal_interval(*(bareinterval(-0x01p0, 0xe.ca7ddfdb8572p-4), bareinterval(-0x2.3b46226145234p+0, -0x0.1p0)), bareinterval(-0x2.101b41d3d48b8p+0, 0x2.3b46226145234p+0)) - @test isequal_interval(*(interval(-0x1.1d069e75e8741p+8, 0x01p0), interval(-0x2.3b46226145234p+0, -0x0.1p0)), interval(-0x2.3b46226145234p+0, 0x2.7c0bd9877f404p+8)) + @test isequal_interval(*(bareinterval(-0x1.1d069e75e8741p+8, 0x01p0), bareinterval(-0x2.3b46226145234p+0, -0x0.1p0)), bareinterval(-0x2.3b46226145234p+0, 0x2.7c0bd9877f404p+8)) - @test isequal_interval(*(interval(-0xe.ca7ddfdb8572p-4, 0x1.1d069e75e8741p+8), interval(-0x2.3b46226145234p+0, -0x0.1p0)), interval(-0x2.7c0bd9877f404p+8, 0x2.101b41d3d48b8p+0)) + @test isequal_interval(*(bareinterval(-0xe.ca7ddfdb8572p-4, 0x1.1d069e75e8741p+8), bareinterval(-0x2.3b46226145234p+0, -0x0.1p0)), bareinterval(-0x2.7c0bd9877f404p+8, 0x2.101b41d3d48b8p+0)) - @test isequal_interval(*(interval(-0x01p0, 0x10p0), interval(-0x02p0, 0x03p0)), interval(-0x20p0, 0x30p0)) + @test isequal_interval(*(bareinterval(-0x01p0, 0x10p0), bareinterval(-0x02p0, 0x03p0)), bareinterval(-0x20p0, 0x30p0)) - @test isequal_interval(*(interval(-0x01p0, 0x2.db091cea593fap-4), interval(-0x2.6bff2625fb71cp-4, 0x1p-8)), interval(-0x6.ea77a3ee43de8p-8, 0x2.6bff2625fb71cp-4)) + @test isequal_interval(*(bareinterval(-0x01p0, 0x2.db091cea593fap-4), bareinterval(-0x2.6bff2625fb71cp-4, 0x1p-8)), bareinterval(-0x6.ea77a3ee43de8p-8, 0x2.6bff2625fb71cp-4)) - @test isequal_interval(*(interval(-0x01p0, 0x6.e211fefc216ap-4), interval(-0x1p-4, 0x1.8e3fe93a4ea52p+0)), interval(-0x1.8e3fe93a4ea52p+0, 0xa.b52fe22d72788p-4)) + @test isequal_interval(*(bareinterval(-0x01p0, 0x6.e211fefc216ap-4), bareinterval(-0x1p-4, 0x1.8e3fe93a4ea52p+0)), bareinterval(-0x1.8e3fe93a4ea52p+0, 0xa.b52fe22d72788p-4)) - @test isequal_interval(*(interval(-0x1.15e079e49a0ddp+0, 0x1p-8), interval(-0x2.77fc84629a602p+0, 0x8.3885932f13fp-4)), interval(-0x8.ec5de73125be8p-4, 0x2.adfe651d3b19ap+0)) + @test isequal_interval(*(bareinterval(-0x1.15e079e49a0ddp+0, 0x1p-8), bareinterval(-0x2.77fc84629a602p+0, 0x8.3885932f13fp-4)), bareinterval(-0x8.ec5de73125be8p-4, 0x2.adfe651d3b19ap+0)) - @test isequal_interval(*(interval(-0x07p0, 0x07p0), interval(0x13p0, 0x24p0)), interval(-0xfcp0, 0xfcp0)) + @test isequal_interval(*(bareinterval(-0x07p0, 0x07p0), bareinterval(0x13p0, 0x24p0)), bareinterval(-0xfcp0, 0xfcp0)) - @test isequal_interval(*(interval(-0xa.8071f870126cp-4, 0x10p0), interval(0x02p0, 0x2.3381083e7d3b4p+0)), interval(-0x1.71dc5b5607781p+0, 0x2.3381083e7d3b4p+4)) + @test isequal_interval(*(bareinterval(-0xa.8071f870126cp-4, 0x10p0), bareinterval(0x02p0, 0x2.3381083e7d3b4p+0)), bareinterval(-0x1.71dc5b5607781p+0, 0x2.3381083e7d3b4p+4)) - @test isequal_interval(*(interval(-0x01p0, 0x1.90aa487ecf153p+0), interval(0x01p-53, 0x1.442e2695ac81ap+0)), interval(-0x1.442e2695ac81ap+0, 0x1.fb5fbebd0cbc6p+0)) + @test isequal_interval(*(bareinterval(-0x01p0, 0x1.90aa487ecf153p+0), bareinterval(0x01p-53, 0x1.442e2695ac81ap+0)), bareinterval(-0x1.442e2695ac81ap+0, 0x1.fb5fbebd0cbc6p+0)) - @test isequal_interval(*(interval(-0x1.c40db77f2f6fcp+0, 0x1.8eb70bbd94478p+0), interval(0x02p0, 0x3.45118635235c6p+0)), interval(-0x5.c61fcad908df4p+0, 0x5.17b7c49130824p+0)) + @test isequal_interval(*(bareinterval(-0x1.c40db77f2f6fcp+0, 0x1.8eb70bbd94478p+0), bareinterval(0x02p0, 0x3.45118635235c6p+0)), bareinterval(-0x5.c61fcad908df4p+0, 0x5.17b7c49130824p+0)) - @test isequal_interval(*(interval(0xcp0, 0x2dp0), interval(-0x679p0, -0xe5p0)), interval(-0x12345p0, -0xabcp0)) + @test isequal_interval(*(bareinterval(0xcp0, 0x2dp0), bareinterval(-0x679p0, -0xe5p0)), bareinterval(-0x12345p0, -0xabcp0)) - @test isequal_interval(*(interval(0xcp0, 0x1.1833fdcab4c4ap+10), interval(-0x2.4c0afc50522ccp+40, -0xe5p0)), interval(-0x2.83a3712099234p+50, -0xabcp0)) + @test isequal_interval(*(bareinterval(0xcp0, 0x1.1833fdcab4c4ap+10), bareinterval(-0x2.4c0afc50522ccp+40, -0xe5p0)), bareinterval(-0x2.83a3712099234p+50, -0xabcp0)) - @test isequal_interval(*(interval(0xb.38f1fb0ef4308p+0, 0x2dp0), interval(-0x679p0, -0xa.4771d7d0c604p+0)), interval(-0x12345p0, -0x7.35b3c8400ade4p+4)) + @test isequal_interval(*(bareinterval(0xb.38f1fb0ef4308p+0, 0x2dp0), bareinterval(-0x679p0, -0xa.4771d7d0c604p+0)), bareinterval(-0x12345p0, -0x7.35b3c8400ade4p+4)) - @test isequal_interval(*(interval(0xf.08367984ca1cp-4, 0xa.bcf6c6cbe341p+0), interval(-0x5.cbc445e9952c4p+0, -0x2.8ad05a7b988fep-8)), interval(-0x3.e3ce52d4a139cp+4, -0x2.637164cf2f346p-8)) + @test isequal_interval(*(bareinterval(0xf.08367984ca1cp-4, 0xa.bcf6c6cbe341p+0), bareinterval(-0x5.cbc445e9952c4p+0, -0x2.8ad05a7b988fep-8)), bareinterval(-0x3.e3ce52d4a139cp+4, -0x2.637164cf2f346p-8)) - @test isequal_interval(*(interval(0x01p0, 0xcp0), interval(-0xe5p0, 0x01p0)), interval(-0xabcp0, 0xcp0)) + @test isequal_interval(*(bareinterval(0x01p0, 0xcp0), bareinterval(-0xe5p0, 0x01p0)), bareinterval(-0xabcp0, 0xcp0)) - @test isequal_interval(*(interval(0x123p-52, 0x1.ec24910ac6aecp+0), interval(-0xa.a97267f56a9b8p-4, 0x1p+32)), interval(-0x1.47f2dbe4ef916p+0, 0x1.ec24910ac6aecp+32)) + @test isequal_interval(*(bareinterval(0x123p-52, 0x1.ec24910ac6aecp+0), bareinterval(-0xa.a97267f56a9b8p-4, 0x1p+32)), bareinterval(-0x1.47f2dbe4ef916p+0, 0x1.ec24910ac6aecp+32)) - @test isequal_interval(*(interval(0x03p0, 0x7.2bea531ef4098p+0), interval(-0x01p0, 0xa.a97267f56a9b8p-4)), interval(-0x7.2bea531ef4098p+0, 0x4.c765967f9468p+0)) + @test isequal_interval(*(bareinterval(0x03p0, 0x7.2bea531ef4098p+0), bareinterval(-0x01p0, 0xa.a97267f56a9b8p-4)), bareinterval(-0x7.2bea531ef4098p+0, 0x4.c765967f9468p+0)) - @test isequal_interval(*(interval(0x0.3p0, 0xa.a97267f56a9b8p-4), interval(-0x1.ec24910ac6aecp+0, 0x7.2bea531ef4098p+0)), interval(-0x1.47f2dbe4ef916p+0, 0x4.c765967f9468p+0)) + @test isequal_interval(*(bareinterval(0x0.3p0, 0xa.a97267f56a9b8p-4), bareinterval(-0x1.ec24910ac6aecp+0, 0x7.2bea531ef4098p+0)), bareinterval(-0x1.47f2dbe4ef916p+0, 0x4.c765967f9468p+0)) - @test isequal_interval(*(interval(0x3p0, 0x7p0), interval(0x5p0, 0xbp0)), interval(0xfp0, 0x4dp0)) + @test isequal_interval(*(bareinterval(0x3p0, 0x7p0), bareinterval(0x5p0, 0xbp0)), bareinterval(0xfp0, 0x4dp0)) - @test isequal_interval(*(interval(0x2.48380232f6c16p+0, 0x7p0), interval(0x3.71cb6c53e68eep+0, 0xbp0)), interval(0x7.dc58fb323ad78p+0, 0x4dp0)) + @test isequal_interval(*(bareinterval(0x2.48380232f6c16p+0, 0x7p0), bareinterval(0x3.71cb6c53e68eep+0, 0xbp0)), bareinterval(0x7.dc58fb323ad78p+0, 0x4dp0)) - @test isequal_interval(*(interval(0x3p0, 0x3.71cb6c53e68eep+0), interval(0x5p-25, 0x2.48380232f6c16p+0)), interval(0xfp-25, 0x7.dc58fb323ad7cp+0)) + @test isequal_interval(*(bareinterval(0x3p0, 0x3.71cb6c53e68eep+0), bareinterval(0x5p-25, 0x2.48380232f6c16p+0)), bareinterval(0xfp-25, 0x7.dc58fb323ad7cp+0)) - @test isequal_interval(*(interval(0x3.10e8a605572p-4, 0x2.48380232f6c16p+0), interval(0xc.3d8e305214ecp-4, 0x2.9e7db05203c88p+0)), interval(0x2.587a32d02bc04p-4, 0x5.fa216b7c20c6cp+0)) + @test isequal_interval(*(bareinterval(0x3.10e8a605572p-4, 0x2.48380232f6c16p+0), bareinterval(0xc.3d8e305214ecp-4, 0x2.9e7db05203c88p+0)), bareinterval(0x2.587a32d02bc04p-4, 0x5.fa216b7c20c6cp+0)) end @testset "mpfi_mul_d" begin - @test isequal_interval(*(interval(-Inf, -7.0), interval(-0x17p0, -0x17p0)), interval(+0xa1p0, +Inf)) + @test isequal_interval(*(bareinterval(-Inf, -7.0), bareinterval(-0x17p0, -0x17p0)), bareinterval(+0xa1p0, +Inf)) - @test isequal_interval(*(interval(-Inf, -7.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(-Inf, -7.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(-Inf, -7.0), interval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), interval(-Inf, -0xa168b4ebefd020p-107)) + @test isequal_interval(*(bareinterval(-Inf, -7.0), bareinterval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), bareinterval(-Inf, -0xa168b4ebefd020p-107)) - @test isequal_interval(*(interval(-Inf, 0.0), interval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), interval(0.0, +Inf)) + @test isequal_interval(*(bareinterval(-Inf, 0.0), bareinterval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), bareinterval(0.0, +Inf)) - @test isequal_interval(*(interval(-Inf, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(-Inf, 0.0), interval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), interval(-Inf, 0.0)) + @test isequal_interval(*(bareinterval(-Inf, 0.0), bareinterval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), bareinterval(-Inf, 0.0)) - @test isequal_interval(*(interval(-Inf, 8.0), interval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), interval(-0xb1a2bc2ec5000000p0, +Inf)) + @test isequal_interval(*(bareinterval(-Inf, 8.0), bareinterval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), bareinterval(-0xb1a2bc2ec5000000p0, +Inf)) - @test isequal_interval(*(interval(-Inf, 8.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(-Inf, 8.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(-Inf, 8.0), interval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), interval(-Inf, 0xb1a2bc2ec5000000p0)) + @test isequal_interval(*(bareinterval(-Inf, 8.0), bareinterval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), bareinterval(-Inf, 0xb1a2bc2ec5000000p0)) - @test isequal_interval(*(entireinterval(), interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(entireinterval(), interval(0.0e-17, 0.0e-17)), interval(0.0, 0.0)) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(0.0e-17, 0.0e-17)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(entireinterval(), interval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(*(entireinterval(BareInterval{Float64}), bareinterval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(*(interval(0.0, 0.0), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, 0.0), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 0.0), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, 7.0), interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), interval(-0x790e87b0f3dc18p-107, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 7.0), bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), bareinterval(-0x790e87b0f3dc18p-107, 0.0)) - @test isequal_interval(*(interval(0.0, 8.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, 8.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, 9.0), interval(0x114b37f4b51f71p-103, 0x114b37f4b51f71p-103)), interval(0.0, 0x9ba4f79a5e1b00p-103)) + @test isequal_interval(*(bareinterval(0.0, 9.0), bareinterval(0x114b37f4b51f71p-103, 0x114b37f4b51f71p-103)), bareinterval(0.0, 0x9ba4f79a5e1b00p-103)) - @test isequal_interval(*(interval(0.0, +Inf), interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), interval(-Inf, 0.0)) + @test isequal_interval(*(bareinterval(0.0, +Inf), bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), bareinterval(-Inf, 0.0)) - @test isequal_interval(*(interval(0.0, +Inf), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(*(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(*(interval(0.0, +Inf), interval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), interval(0.0, +Inf)) + @test isequal_interval(*(bareinterval(0.0, +Inf), bareinterval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), bareinterval(0.0, +Inf)) - @test isequal_interval(*(interval(-0x1717170p0, -0xaaaaaaaaaaaaap-123), interval(-1.5, -1.5)), interval(0xfffffffffffffp-123, 0x22a2a28p0)) + @test isequal_interval(*(bareinterval(-0x1717170p0, -0xaaaaaaaaaaaaap-123), bareinterval(-1.5, -1.5)), bareinterval(0xfffffffffffffp-123, 0x22a2a28p0)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaaap0, 0x1717170p+401), interval(-1.5, -1.5)), interval(-0x22a2a28p+401, 0xfffffffffffffp0)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaaap0, 0x1717170p+401), bareinterval(-1.5, -1.5)), bareinterval(-0x22a2a28p+401, 0xfffffffffffffp0)) - @test isequal_interval(*(interval(0x10000000000010p0, 0x888888888888p+654), interval(-2.125, -2.125)), interval(-0x1222222222221p+654, -0x22000000000022p0)) + @test isequal_interval(*(bareinterval(0x10000000000010p0, 0x888888888888p+654), bareinterval(-2.125, -2.125)), bareinterval(-0x1222222222221p+654, -0x22000000000022p0)) - @test isequal_interval(*(interval(-0x1717170p0, -0xaaaaaaaaaaaaap-123), interval(1.5, 1.5)), interval(-0x22a2a28p0, -0xfffffffffffffp-123)) + @test isequal_interval(*(bareinterval(-0x1717170p0, -0xaaaaaaaaaaaaap-123), bareinterval(1.5, 1.5)), bareinterval(-0x22a2a28p0, -0xfffffffffffffp-123)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaaap0, 0x1717170p+401), interval(1.5, 1.5)), interval(-0xfffffffffffffp0, 0x22a2a28p+401)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaaap0, 0x1717170p+401), bareinterval(1.5, 1.5)), bareinterval(-0xfffffffffffffp0, 0x22a2a28p+401)) - @test isequal_interval(*(interval(0x10000000000010p0, 0x888888888888p+654), interval(2.125, 2.125)), interval(0x22000000000022p0, 0x1222222222221p+654)) + @test isequal_interval(*(bareinterval(0x10000000000010p0, 0x888888888888p+654), bareinterval(2.125, 2.125)), bareinterval(0x22000000000022p0, 0x1222222222221p+654)) - @test isequal_interval(*(interval(-0x1717170p+36, -0x10000000000001p0), interval(-1.5, -1.5)), interval(0x18000000000001p0, 0x22a2a28p+36)) + @test isequal_interval(*(bareinterval(-0x1717170p+36, -0x10000000000001p0), bareinterval(-1.5, -1.5)), bareinterval(0x18000000000001p0, 0x22a2a28p+36)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaaap0, 0x10000000000001p0), interval(-1.5, -1.5)), interval(-0x18000000000002p0, 0xfffffffffffffp0)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaaap0, 0x10000000000001p0), bareinterval(-1.5, -1.5)), bareinterval(-0x18000000000002p0, 0xfffffffffffffp0)) - @test isequal_interval(*(interval(0x10000000000010p0, 0x11111111111111p0), interval(-2.125, -2.125)), interval(-0x12222222222223p+1, -0x22000000000022p0)) + @test isequal_interval(*(bareinterval(0x10000000000010p0, 0x11111111111111p0), bareinterval(-2.125, -2.125)), bareinterval(-0x12222222222223p+1, -0x22000000000022p0)) - @test isequal_interval(*(interval(-0x10000000000001p0, -0xaaaaaaaaaaaaap-123), interval(1.5, 1.5)), interval(-0x18000000000002p0, -0xfffffffffffffp-123)) + @test isequal_interval(*(bareinterval(-0x10000000000001p0, -0xaaaaaaaaaaaaap-123), bareinterval(1.5, 1.5)), bareinterval(-0x18000000000002p0, -0xfffffffffffffp-123)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaabp0, 0x1717170p+401), interval(1.5, 1.5)), interval(-0x10000000000001p0, 0x22a2a28p+401)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaabp0, 0x1717170p+401), bareinterval(1.5, 1.5)), bareinterval(-0x10000000000001p0, 0x22a2a28p+401)) - @test isequal_interval(*(interval(0x10000000000001p0, 0x888888888888p+654), interval(2.125, 2.125)), interval(0x22000000000002p0, 0x1222222222221p+654)) + @test isequal_interval(*(bareinterval(0x10000000000001p0, 0x888888888888p+654), bareinterval(2.125, 2.125)), bareinterval(0x22000000000002p0, 0x1222222222221p+654)) - @test isequal_interval(*(interval(-0x11717171717171p0, -0xaaaaaaaaaaaaap-123), interval(-1.5, -1.5)), interval(0xfffffffffffffp-123, 0x1a2a2a2a2a2a2ap0)) + @test isequal_interval(*(bareinterval(-0x11717171717171p0, -0xaaaaaaaaaaaaap-123), bareinterval(-1.5, -1.5)), bareinterval(0xfffffffffffffp-123, 0x1a2a2a2a2a2a2ap0)) - @test isequal_interval(*(interval(-0x10000000000001p0, 0x1717170p+401), interval(-1.5, -1.5)), interval(-0x22a2a28p+401, 0x18000000000002p0)) + @test isequal_interval(*(bareinterval(-0x10000000000001p0, 0x1717170p+401), bareinterval(-1.5, -1.5)), bareinterval(-0x22a2a28p+401, 0x18000000000002p0)) - @test isequal_interval(*(interval(0x10000000000001p0, 0x888888888888p+654), interval(-2.125, -2.125)), interval(-0x1222222222221p+654, -0x22000000000002p0)) + @test isequal_interval(*(bareinterval(0x10000000000001p0, 0x888888888888p+654), bareinterval(-2.125, -2.125)), bareinterval(-0x1222222222221p+654, -0x22000000000002p0)) - @test isequal_interval(*(interval(-0x1717170p0, -0x1aaaaaaaaaaaaap-123), interval(1.5, 1.5)), interval(-0x22a2a28p0, -0x27fffffffffffep-123)) + @test isequal_interval(*(bareinterval(-0x1717170p0, -0x1aaaaaaaaaaaaap-123), bareinterval(1.5, 1.5)), bareinterval(-0x22a2a28p0, -0x27fffffffffffep-123)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaaap0, 0x11717171717171p0), interval(1.5, 1.5)), interval(-0xfffffffffffffp0, 0x1a2a2a2a2a2a2ap0)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaaap0, 0x11717171717171p0), bareinterval(1.5, 1.5)), bareinterval(-0xfffffffffffffp0, 0x1a2a2a2a2a2a2ap0)) - @test isequal_interval(*(interval(0x10000000000010p0, 0x18888888888889p0), interval(2.125, 2.125)), interval(0x22000000000022p0, 0x34222222222224p0)) + @test isequal_interval(*(bareinterval(0x10000000000010p0, 0x18888888888889p0), bareinterval(2.125, 2.125)), bareinterval(0x22000000000022p0, 0x34222222222224p0)) - @test isequal_interval(*(interval(-0x11717171717171p0, -0x10000000000001p0), interval(-1.5, -1.5)), interval(0x18000000000001p0, 0x1a2a2a2a2a2a2ap0)) + @test isequal_interval(*(bareinterval(-0x11717171717171p0, -0x10000000000001p0), bareinterval(-1.5, -1.5)), bareinterval(0x18000000000001p0, 0x1a2a2a2a2a2a2ap0)) - @test isequal_interval(*(interval(-0x10000000000001p0, 0x10000000000001p0), interval(-1.5, -1.5)), interval(-0x18000000000002p0, 0x18000000000002p0)) + @test isequal_interval(*(bareinterval(-0x10000000000001p0, 0x10000000000001p0), bareinterval(-1.5, -1.5)), bareinterval(-0x18000000000002p0, 0x18000000000002p0)) - @test isequal_interval(*(interval(0x10000000000001p0, 0x11111111111111p0), interval(-2.125, -2.125)), interval(-0x12222222222223p+1, -0x22000000000002p0)) + @test isequal_interval(*(bareinterval(0x10000000000001p0, 0x11111111111111p0), bareinterval(-2.125, -2.125)), bareinterval(-0x12222222222223p+1, -0x22000000000002p0)) - @test isequal_interval(*(interval(-0x10000000000001p0, -0x1aaaaaaaaaaaaap-123), interval(1.5, 1.5)), interval(-0x18000000000002p0, -0x27fffffffffffep-123)) + @test isequal_interval(*(bareinterval(-0x10000000000001p0, -0x1aaaaaaaaaaaaap-123), bareinterval(1.5, 1.5)), bareinterval(-0x18000000000002p0, -0x27fffffffffffep-123)) - @test isequal_interval(*(interval(-0xaaaaaaaaaaaabp0, 0x11717171717171p0), interval(1.5, 1.5)), interval(-0x10000000000001p0, 0x1a2a2a2a2a2a2ap0)) + @test isequal_interval(*(bareinterval(-0xaaaaaaaaaaaabp0, 0x11717171717171p0), bareinterval(1.5, 1.5)), bareinterval(-0x10000000000001p0, 0x1a2a2a2a2a2a2ap0)) - @test isequal_interval(*(interval(0x10000000000001p0, 0x18888888888889p0), interval(2.125, 2.125)), interval(0x22000000000002p0, 0x34222222222224p0)) + @test isequal_interval(*(bareinterval(0x10000000000001p0, 0x18888888888889p0), bareinterval(2.125, 2.125)), bareinterval(0x22000000000002p0, 0x34222222222224p0)) end @testset "mpfi_neg" begin - @test isequal_interval(-(interval(-Inf, -7.0)), interval(+7.0, +Inf)) + @test isequal_interval(-(bareinterval(-Inf, -7.0)), bareinterval(+7.0, +Inf)) - @test isequal_interval(-(interval(-Inf, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(-(bareinterval(-Inf, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(-(interval(-Inf, +8.0)), interval(-8.0, +Inf)) + @test isequal_interval(-(bareinterval(-Inf, +8.0)), bareinterval(-8.0, +Inf)) - @test isequal_interval(-(entireinterval()), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(-(interval(0.0, +8.0)), interval(-8.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, +8.0)), bareinterval(-8.0, 0.0)) - @test isequal_interval(-(interval(0.0, +Inf)), interval(-Inf, 0.0)) + @test isequal_interval(-(bareinterval(0.0, +Inf)), bareinterval(-Inf, 0.0)) - @test isequal_interval(-(interval(0x123456789p-16, 0x123456799p-16)), interval(-0x123456799p-16, -0x123456789p-16)) + @test isequal_interval(-(bareinterval(0x123456789p-16, 0x123456799p-16)), bareinterval(-0x123456799p-16, -0x123456789p-16)) end @testset "mpfi_put_d" begin - @test isequal_interval(hull(interval(0.0, 0.0), interval(-8.0, -8.0)), interval(-8.0, 0.0)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(-8.0, -8.0)), bareinterval(-8.0, 0.0)) - @test isequal_interval(hull(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(hull(interval(+5.0, +5.0), interval(0.0, 0.0)), interval(0.0, +5.0)) + @test isequal_interval(hull(bareinterval(+5.0, +5.0), bareinterval(0.0, 0.0)), bareinterval(0.0, +5.0)) end @testset "mpfi_sec" begin - @test isequal_interval(sec(interval(-Inf, -7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-Inf, -7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-Inf, 8.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-Inf, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(entireinterval()), entireinterval()) + @test isequal_interval(sec(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-8.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-8.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 0.0)), interval(1.0, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(-1.0, 0.0)), bareinterval(1.0, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(sec(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(sec(interval(0.0, +1.0)), interval(1.0, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(0.0, +1.0)), bareinterval(1.0, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(0.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(0.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(0.0, 8.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(0.0, 8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(sec(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, -1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, -2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, -3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, -4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-6.0, -4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-6.0, -5.0)), interval(0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51)) + @test isequal_interval(sec(bareinterval(-6.0, -5.0)), bareinterval(0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51)) - @test isequal_interval(sec(interval(-6.0, -6.0)), interval(0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52)) + @test isequal_interval(sec(bareinterval(-6.0, -6.0)), bareinterval(0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52)) - @test isequal_interval(sec(interval(-5.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, -1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, -2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, -3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, -4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-5.0, -4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-5.0, -5.0)), interval(0x1c33db0464189ap-51, 0x1c33db0464189bp-51)) + @test isequal_interval(sec(bareinterval(-5.0, -5.0)), bareinterval(0x1c33db0464189ap-51, 0x1c33db0464189bp-51)) - @test isequal_interval(sec(interval(-4.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, -1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-4.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-4.0, -2.0)), interval(-0x133956fecf9e49p-51, -1.0)) + @test isequal_interval(sec(bareinterval(-4.0, -2.0)), bareinterval(-0x133956fecf9e49p-51, -1.0)) - @test isequal_interval(sec(interval(-4.0, -3.0)), interval(-0x187a6961d2485fp-52, -1.0)) + @test isequal_interval(sec(bareinterval(-4.0, -3.0)), bareinterval(-0x187a6961d2485fp-52, -1.0)) - @test isequal_interval(sec(interval(-4.0, -4.0)), interval(-0x187a6961d2485fp-52, -0x187a6961d2485ep-52)) + @test isequal_interval(sec(bareinterval(-4.0, -4.0)), bareinterval(-0x187a6961d2485fp-52, -0x187a6961d2485ep-52)) - @test isequal_interval(sec(interval(-3.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, -1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-3.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-3.0, -2.0)), interval(-0x133956fecf9e49p-51, -0x102967b457b245p-52)) + @test isequal_interval(sec(bareinterval(-3.0, -2.0)), bareinterval(-0x133956fecf9e49p-51, -0x102967b457b245p-52)) - @test isequal_interval(sec(interval(-3.0, -3.0)), interval(-0x102967b457b246p-52, -0x102967b457b245p-52)) + @test isequal_interval(sec(bareinterval(-3.0, -3.0)), bareinterval(-0x102967b457b246p-52, -0x102967b457b245p-52)) - @test isequal_interval(sec(interval(-2.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, 0.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, -1.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-2.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-2.0, -2.0)), interval(-0x133956fecf9e49p-51, -0x133956fecf9e48p-51)) + @test isequal_interval(sec(bareinterval(-2.0, -2.0)), bareinterval(-0x133956fecf9e49p-51, -0x133956fecf9e48p-51)) - @test isequal_interval(sec(interval(-1.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(-1.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(-1.0, 1.0)), interval(1.0, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(-1.0, 1.0)), bareinterval(1.0, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(-1.0, 0.0)), interval(1.0, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(-1.0, 0.0)), bareinterval(1.0, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(-1.0, -1.0)), interval(0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(-1.0, -1.0)), bareinterval(0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(1.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 4.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 3.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 2.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(1.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(1.0, 1.0)), interval(0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52)) + @test isequal_interval(sec(bareinterval(1.0, 1.0)), bareinterval(0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52)) - @test isequal_interval(sec(interval(2.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(2.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(2.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(2.0, 4.0)), interval(-0x133956fecf9e49p-51, -1.0)) + @test isequal_interval(sec(bareinterval(2.0, 4.0)), bareinterval(-0x133956fecf9e49p-51, -1.0)) - @test isequal_interval(sec(interval(2.0, 3.0)), interval(-0x133956fecf9e49p-51, -0x102967b457b245p-52)) + @test isequal_interval(sec(bareinterval(2.0, 3.0)), bareinterval(-0x133956fecf9e49p-51, -0x102967b457b245p-52)) - @test isequal_interval(sec(interval(2.0, 2.0)), interval(-0x133956fecf9e49p-51, -0x133956fecf9e48p-51)) + @test isequal_interval(sec(bareinterval(2.0, 2.0)), bareinterval(-0x133956fecf9e49p-51, -0x133956fecf9e48p-51)) - @test isequal_interval(sec(interval(3.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(3.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(3.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(3.0, 4.0)), interval(-0x187a6961d2485fp-52, -1.0)) + @test isequal_interval(sec(bareinterval(3.0, 4.0)), bareinterval(-0x187a6961d2485fp-52, -1.0)) - @test isequal_interval(sec(interval(3.0, 3.0)), interval(-0x102967b457b246p-52, -0x102967b457b245p-52)) + @test isequal_interval(sec(bareinterval(3.0, 3.0)), bareinterval(-0x102967b457b246p-52, -0x102967b457b245p-52)) - @test isequal_interval(sec(interval(4.0, 7.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(4.0, 6.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(4.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(4.0, 5.0)), entireinterval()) + @test isequal_interval(sec(bareinterval(4.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(sec(interval(4.0, 4.0)), interval(-0x187a6961d2485fp-52, -0x187a6961d2485ep-52)) + @test isequal_interval(sec(bareinterval(4.0, 4.0)), bareinterval(-0x187a6961d2485fp-52, -0x187a6961d2485ep-52)) - @test isequal_interval(sec(interval(5.0, 7.0)), interval(1.0, 0x1c33db0464189bp-51)) + @test isequal_interval(sec(bareinterval(5.0, 7.0)), bareinterval(1.0, 0x1c33db0464189bp-51)) - @test isequal_interval(sec(interval(5.0, 6.0)), interval(0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51)) + @test isequal_interval(sec(bareinterval(5.0, 6.0)), bareinterval(0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51)) - @test isequal_interval(sec(interval(5.0, 5.0)), interval(0x1c33db0464189ap-51, 0x1c33db0464189bp-51)) + @test isequal_interval(sec(bareinterval(5.0, 5.0)), bareinterval(0x1c33db0464189ap-51, 0x1c33db0464189bp-51)) - @test isequal_interval(sec(interval(6.0, 7.0)), interval(1.0, 0x153910a80e7db5p-52)) + @test isequal_interval(sec(bareinterval(6.0, 7.0)), bareinterval(1.0, 0x153910a80e7db5p-52)) - @test isequal_interval(sec(interval(6.0, 6.0)), interval(0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52)) + @test isequal_interval(sec(bareinterval(6.0, 6.0)), bareinterval(0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52)) - @test isequal_interval(sec(interval(7.0, 7.0)), interval(0x153910a80e7db4p-52, 0x153910a80e7db5p-52)) + @test isequal_interval(sec(bareinterval(7.0, 7.0)), bareinterval(0x153910a80e7db4p-52, 0x153910a80e7db5p-52)) end @testset "mpfi_sech" begin - @test isequal_interval(sech(interval(-Inf, -7.0)), interval(0.0, 0x1de169fb49b339p-62)) + @test isequal_interval(sech(bareinterval(-Inf, -7.0)), bareinterval(0.0, 0x1de169fb49b339p-62)) - @test isequal_interval(sech(interval(-Inf, 0.0)), interval(0.0, 1.0)) + @test isequal_interval(sech(bareinterval(-Inf, 0.0)), bareinterval(0.0, 1.0)) - @test isequal_interval(sech(interval(-Inf, +8.0)), interval(0.0, 1.0)) + @test isequal_interval(sech(bareinterval(-Inf, +8.0)), bareinterval(0.0, 1.0)) - @test isequal_interval(sech(entireinterval()), interval(0.0, 1.0)) + @test isequal_interval(sech(entireinterval(BareInterval{Float64})), bareinterval(0.0, 1.0)) - @test isequal_interval(sech(interval(-1.0, 0.0)), interval(0x14bcdc50ed6be7p-53, 1.0)) + @test isequal_interval(sech(bareinterval(-1.0, 0.0)), bareinterval(0x14bcdc50ed6be7p-53, 1.0)) - @test isequal_interval(sech(interval(0.0, 0.0)), interval(1.0, 1.0)) + @test isequal_interval(sech(bareinterval(0.0, 0.0)), bareinterval(1.0, 1.0)) - @test isequal_interval(sech(interval(0.0, +1.0)), interval(0x14bcdc50ed6be7p-53, 1.0)) + @test isequal_interval(sech(bareinterval(0.0, +1.0)), bareinterval(0x14bcdc50ed6be7p-53, 1.0)) - @test isequal_interval(sech(interval(0.0, +8.0)), interval(0x15fc20da8e18dbp-63, 1.0)) + @test isequal_interval(sech(bareinterval(0.0, +8.0)), bareinterval(0x15fc20da8e18dbp-63, 1.0)) - @test isequal_interval(sech(interval(0.0, +Inf)), interval(0.0, 1.0)) + @test isequal_interval(sech(bareinterval(0.0, +Inf)), bareinterval(0.0, 1.0)) - @test isequal_interval(sech(interval(-0.125, 0.0)), interval(0x1fc069fe3f72bep-53, 1.0)) + @test isequal_interval(sech(bareinterval(-0.125, 0.0)), bareinterval(0x1fc069fe3f72bep-53, 1.0)) - @test isequal_interval(sech(interval(0.0, 0x10000000000001p-53)), interval(0x1c60d1ff040dcfp-53, 1.0)) + @test isequal_interval(sech(bareinterval(0.0, 0x10000000000001p-53)), bareinterval(0x1c60d1ff040dcfp-53, 1.0)) - @test isequal_interval(sech(interval(-4.5, -0.625)), interval(0x16bf984a9a2355p-58, 0x1aa0b464a5e24ap-53)) + @test isequal_interval(sech(bareinterval(-4.5, -0.625)), bareinterval(0x16bf984a9a2355p-58, 0x1aa0b464a5e24ap-53)) - @test isequal_interval(sech(interval(1.0, 3.0)), interval(0x196d8e17d88eb1p-56, 0x14bcdc50ed6be8p-53)) + @test isequal_interval(sech(bareinterval(1.0, 3.0)), bareinterval(0x196d8e17d88eb1p-56, 0x14bcdc50ed6be8p-53)) - @test isequal_interval(sech(interval(17.0, 0xb145bb71d3dbp-38)), interval(0x10000000000173p-1074, 0x1639e3175a6893p-76)) + @test isequal_interval(sech(bareinterval(17.0, 0xb145bb71d3dbp-38)), bareinterval(0x10000000000173p-1074, 0x1639e3175a6893p-76)) end @testset "mpfi_sin" begin - @test isequal_interval(sin(interval(-Inf, -7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-Inf, -7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-Inf, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-Inf, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-Inf, +8.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-Inf, +8.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(entireinterval()), interval(-1.0, 1.0)) + @test isequal_interval(sin(entireinterval(BareInterval{Float64})), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-1.0, 0.0)), interval(-0x1aed548f090cefp-53, 0.0)) + @test isequal_interval(sin(bareinterval(-1.0, 0.0)), bareinterval(-0x1aed548f090cefp-53, 0.0)) - @test isequal_interval(sin(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(sin(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(sin(interval(0.0, +1.0)), interval(0.0, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(0.0, +8.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(0.0, +8.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(0.0, +Inf)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(0.0, +Inf)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(0.125, 17.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(0.125, 17.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(0x1921fb54442d18p-52, 0x1921fb54442d19p-52)), interval(0x1fffffffffffffp-53, 1.0)) + @test isequal_interval(sin(bareinterval(0x1921fb54442d18p-52, 0x1921fb54442d19p-52)), bareinterval(0x1fffffffffffffp-53, 1.0)) - @test isequal_interval(sin(interval(-2.0, -0.5)), interval(-1.0, -0x1eaee8744b05efp-54)) + @test isequal_interval(sin(bareinterval(-2.0, -0.5)), bareinterval(-1.0, -0x1eaee8744b05efp-54)) - @test isequal_interval(sin(interval(-4.5, 0.625)), interval(-1.0, 0x1f47ed3dc74081p-53)) + @test isequal_interval(sin(bareinterval(-4.5, 0.625)), bareinterval(-1.0, 0x1f47ed3dc74081p-53)) - @test isequal_interval(sin(interval(-1.0, -0.25)), interval(-0x1aed548f090cefp-53, -0x1faaeed4f31576p-55)) + @test isequal_interval(sin(bareinterval(-1.0, -0.25)), bareinterval(-0x1aed548f090cefp-53, -0x1faaeed4f31576p-55)) - @test isequal_interval(sin(interval(-0.5, 0.5)), interval(-0x1eaee8744b05f0p-54, 0x1eaee8744b05f0p-54)) + @test isequal_interval(sin(bareinterval(-0.5, 0.5)), bareinterval(-0x1eaee8744b05f0p-54, 0x1eaee8744b05f0p-54)) - @test isequal_interval(sin(interval(0x71p+76, 0x71p+76)), interval(0x1bde6c11cbfc46p-55, 0x1bde6c11cbfc47p-55)) + @test isequal_interval(sin(bareinterval(0x71p+76, 0x71p+76)), bareinterval(0x1bde6c11cbfc46p-55, 0x1bde6c11cbfc47p-55)) - @test isequal_interval(sin(interval(-7.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, -1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, -1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-7.0, -2.0)), interval(-0x1d18f6ead1b446p-53, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, 1.0)) - @test isequal_interval(sin(interval(-7.0, -3.0)), interval(-0x150608c26d0a09p-53, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, -3.0)), bareinterval(-0x150608c26d0a09p-53, 1.0)) - @test isequal_interval(sin(interval(-7.0, -4.0)), interval(-0x150608c26d0a09p-53, 1.0)) + @test isequal_interval(sin(bareinterval(-7.0, -4.0)), bareinterval(-0x150608c26d0a09p-53, 1.0)) - @test isequal_interval(sin(interval(-7.0, -5.0)), interval(-0x150608c26d0a09p-53, 0x1eaf81f5e09934p-53)) + @test isequal_interval(sin(bareinterval(-7.0, -5.0)), bareinterval(-0x150608c26d0a09p-53, 0x1eaf81f5e09934p-53)) - @test isequal_interval(sin(interval(-7.0, -6.0)), interval(-0x150608c26d0a09p-53, 0x11e1f18ab0a2c1p-54)) + @test isequal_interval(sin(bareinterval(-7.0, -6.0)), bareinterval(-0x150608c26d0a09p-53, 0x11e1f18ab0a2c1p-54)) - @test isequal_interval(sin(interval(-7.0, -7.0)), interval(-0x150608c26d0a09p-53, -0x150608c26d0a08p-53)) + @test isequal_interval(sin(bareinterval(-7.0, -7.0)), bareinterval(-0x150608c26d0a09p-53, -0x150608c26d0a08p-53)) - @test isequal_interval(sin(interval(-6.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, -1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, -1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-6.0, -2.0)), interval(-0x1d18f6ead1b446p-53, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, 1.0)) - @test isequal_interval(sin(interval(-6.0, -3.0)), interval(-0x1210386db6d55cp-55, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, -3.0)), bareinterval(-0x1210386db6d55cp-55, 1.0)) - @test isequal_interval(sin(interval(-6.0, -4.0)), interval(0x11e1f18ab0a2c0p-54, 1.0)) + @test isequal_interval(sin(bareinterval(-6.0, -4.0)), bareinterval(0x11e1f18ab0a2c0p-54, 1.0)) - @test isequal_interval(sin(interval(-6.0, -5.0)), interval(0x11e1f18ab0a2c0p-54, 0x1eaf81f5e09934p-53)) + @test isequal_interval(sin(bareinterval(-6.0, -5.0)), bareinterval(0x11e1f18ab0a2c0p-54, 0x1eaf81f5e09934p-53)) - @test isequal_interval(sin(interval(-6.0, -6.0)), interval(0x11e1f18ab0a2c0p-54, 0x11e1f18ab0a2c1p-54)) + @test isequal_interval(sin(bareinterval(-6.0, -6.0)), bareinterval(0x11e1f18ab0a2c0p-54, 0x11e1f18ab0a2c1p-54)) - @test isequal_interval(sin(interval(-5.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, 0.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, 0.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, -1.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, -1.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-5.0, -2.0)), interval(-0x1d18f6ead1b446p-53, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, 1.0)) - @test isequal_interval(sin(interval(-5.0, -3.0)), interval(-0x1210386db6d55cp-55, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, -3.0)), bareinterval(-0x1210386db6d55cp-55, 1.0)) - @test isequal_interval(sin(interval(-5.0, -4.0)), interval(0x1837b9dddc1eaep-53, 1.0)) + @test isequal_interval(sin(bareinterval(-5.0, -4.0)), bareinterval(0x1837b9dddc1eaep-53, 1.0)) - @test isequal_interval(sin(interval(-5.0, -5.0)), interval(0x1eaf81f5e09933p-53, 0x1eaf81f5e09934p-53)) + @test isequal_interval(sin(bareinterval(-5.0, -5.0)), bareinterval(0x1eaf81f5e09933p-53, 0x1eaf81f5e09934p-53)) - @test isequal_interval(sin(interval(-4.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-4.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-4.0, 1.0)), interval(-1.0, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(-4.0, 1.0)), bareinterval(-1.0, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(-4.0, 0.0)), interval(-1.0, 0x1837b9dddc1eafp-53)) + @test isequal_interval(sin(bareinterval(-4.0, 0.0)), bareinterval(-1.0, 0x1837b9dddc1eafp-53)) - @test isequal_interval(sin(interval(-4.0, -1.0)), interval(-1.0, 0x1837b9dddc1eafp-53)) + @test isequal_interval(sin(bareinterval(-4.0, -1.0)), bareinterval(-1.0, 0x1837b9dddc1eafp-53)) - @test isequal_interval(sin(interval(-4.0, -2.0)), interval(-0x1d18f6ead1b446p-53, 0x1837b9dddc1eafp-53)) + @test isequal_interval(sin(bareinterval(-4.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, 0x1837b9dddc1eafp-53)) - @test isequal_interval(sin(interval(-4.0, -3.0)), interval(-0x1210386db6d55cp-55, 0x1837b9dddc1eafp-53)) + @test isequal_interval(sin(bareinterval(-4.0, -3.0)), bareinterval(-0x1210386db6d55cp-55, 0x1837b9dddc1eafp-53)) - @test isequal_interval(sin(interval(-4.0, -4.0)), interval(0x1837b9dddc1eaep-53, 0x1837b9dddc1eafp-53)) + @test isequal_interval(sin(bareinterval(-4.0, -4.0)), bareinterval(0x1837b9dddc1eaep-53, 0x1837b9dddc1eafp-53)) - @test isequal_interval(sin(interval(-3.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-3.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-3.0, 1.0)), interval(-1.0, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(-3.0, 1.0)), bareinterval(-1.0, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(-3.0, 0.0)), interval(-1.0, 0.0)) + @test isequal_interval(sin(bareinterval(-3.0, 0.0)), bareinterval(-1.0, 0.0)) - @test isequal_interval(sin(interval(-3.0, -1.0)), interval(-1.0, -0x1210386db6d55bp-55)) + @test isequal_interval(sin(bareinterval(-3.0, -1.0)), bareinterval(-1.0, -0x1210386db6d55bp-55)) - @test isequal_interval(sin(interval(-3.0, -2.0)), interval(-0x1d18f6ead1b446p-53, -0x1210386db6d55bp-55)) + @test isequal_interval(sin(bareinterval(-3.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, -0x1210386db6d55bp-55)) - @test isequal_interval(sin(interval(-3.0, -3.0)), interval(-0x1210386db6d55cp-55, -0x1210386db6d55bp-55)) + @test isequal_interval(sin(bareinterval(-3.0, -3.0)), bareinterval(-0x1210386db6d55cp-55, -0x1210386db6d55bp-55)) - @test isequal_interval(sin(interval(-2.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 4.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 4.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 3.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 3.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 2.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-2.0, 2.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-2.0, 1.0)), interval(-1.0, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(-2.0, 1.0)), bareinterval(-1.0, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(-2.0, 0.0)), interval(-1.0, 0.0)) + @test isequal_interval(sin(bareinterval(-2.0, 0.0)), bareinterval(-1.0, 0.0)) - @test isequal_interval(sin(interval(-2.0, -1.0)), interval(-1.0, -0x1aed548f090ceep-53)) + @test isequal_interval(sin(bareinterval(-2.0, -1.0)), bareinterval(-1.0, -0x1aed548f090ceep-53)) - @test isequal_interval(sin(interval(-2.0, -2.0)), interval(-0x1d18f6ead1b446p-53, -0x1d18f6ead1b445p-53)) + @test isequal_interval(sin(bareinterval(-2.0, -2.0)), bareinterval(-0x1d18f6ead1b446p-53, -0x1d18f6ead1b445p-53)) - @test isequal_interval(sin(interval(-1.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-1.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-1.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(-1.0, 4.0)), interval(-0x1aed548f090cefp-53, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 4.0)), bareinterval(-0x1aed548f090cefp-53, 1.0)) - @test isequal_interval(sin(interval(-1.0, 3.0)), interval(-0x1aed548f090cefp-53, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 3.0)), bareinterval(-0x1aed548f090cefp-53, 1.0)) - @test isequal_interval(sin(interval(-1.0, 2.0)), interval(-0x1aed548f090cefp-53, 1.0)) + @test isequal_interval(sin(bareinterval(-1.0, 2.0)), bareinterval(-0x1aed548f090cefp-53, 1.0)) - @test isequal_interval(sin(interval(-1.0, 1.0)), interval(-0x1aed548f090cefp-53, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(-1.0, 1.0)), bareinterval(-0x1aed548f090cefp-53, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(-1.0, 0.0)), interval(-0x1aed548f090cefp-53, 0.0)) + @test isequal_interval(sin(bareinterval(-1.0, 0.0)), bareinterval(-0x1aed548f090cefp-53, 0.0)) - @test isequal_interval(sin(interval(-1.0, -1.0)), interval(-0x1aed548f090cefp-53, -0x1aed548f090ceep-53)) + @test isequal_interval(sin(bareinterval(-1.0, -1.0)), bareinterval(-0x1aed548f090cefp-53, -0x1aed548f090ceep-53)) - @test isequal_interval(sin(interval(1.0, 7.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 7.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(1.0, 6.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 6.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(1.0, 5.0)), interval(-1.0, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 5.0)), bareinterval(-1.0, 1.0)) - @test isequal_interval(sin(interval(1.0, 4.0)), interval(-0x1837b9dddc1eafp-53, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 4.0)), bareinterval(-0x1837b9dddc1eafp-53, 1.0)) - @test isequal_interval(sin(interval(1.0, 3.0)), interval(0x1210386db6d55bp-55, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 3.0)), bareinterval(0x1210386db6d55bp-55, 1.0)) - @test isequal_interval(sin(interval(1.0, 2.0)), interval(0x1aed548f090ceep-53, 1.0)) + @test isequal_interval(sin(bareinterval(1.0, 2.0)), bareinterval(0x1aed548f090ceep-53, 1.0)) - @test isequal_interval(sin(interval(1.0, 1.0)), interval(0x1aed548f090ceep-53, 0x1aed548f090cefp-53)) + @test isequal_interval(sin(bareinterval(1.0, 1.0)), bareinterval(0x1aed548f090ceep-53, 0x1aed548f090cefp-53)) - @test isequal_interval(sin(interval(2.0, 7.0)), interval(-1.0, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 7.0)), bareinterval(-1.0, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(2.0, 6.0)), interval(-1.0, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 6.0)), bareinterval(-1.0, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(2.0, 5.0)), interval(-1.0, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 5.0)), bareinterval(-1.0, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(2.0, 4.0)), interval(-0x1837b9dddc1eafp-53, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 4.0)), bareinterval(-0x1837b9dddc1eafp-53, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(2.0, 3.0)), interval(0x1210386db6d55bp-55, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 3.0)), bareinterval(0x1210386db6d55bp-55, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(2.0, 2.0)), interval(0x1d18f6ead1b445p-53, 0x1d18f6ead1b446p-53)) + @test isequal_interval(sin(bareinterval(2.0, 2.0)), bareinterval(0x1d18f6ead1b445p-53, 0x1d18f6ead1b446p-53)) - @test isequal_interval(sin(interval(3.0, 7.0)), interval(-1.0, 0x150608c26d0a09p-53)) + @test isequal_interval(sin(bareinterval(3.0, 7.0)), bareinterval(-1.0, 0x150608c26d0a09p-53)) - @test isequal_interval(sin(interval(3.0, 6.0)), interval(-1.0, 0x1210386db6d55cp-55)) + @test isequal_interval(sin(bareinterval(3.0, 6.0)), bareinterval(-1.0, 0x1210386db6d55cp-55)) - @test isequal_interval(sin(interval(3.0, 5.0)), interval(-1.0, 0x1210386db6d55cp-55)) + @test isequal_interval(sin(bareinterval(3.0, 5.0)), bareinterval(-1.0, 0x1210386db6d55cp-55)) - @test isequal_interval(sin(interval(3.0, 4.0)), interval(-0x1837b9dddc1eafp-53, 0x1210386db6d55cp-55)) + @test isequal_interval(sin(bareinterval(3.0, 4.0)), bareinterval(-0x1837b9dddc1eafp-53, 0x1210386db6d55cp-55)) - @test isequal_interval(sin(interval(3.0, 3.0)), interval(0x1210386db6d55bp-55, 0x1210386db6d55cp-55)) + @test isequal_interval(sin(bareinterval(3.0, 3.0)), bareinterval(0x1210386db6d55bp-55, 0x1210386db6d55cp-55)) - @test isequal_interval(sin(interval(4.0, 7.0)), interval(-1.0, 0x150608c26d0a09p-53)) + @test isequal_interval(sin(bareinterval(4.0, 7.0)), bareinterval(-1.0, 0x150608c26d0a09p-53)) - @test isequal_interval(sin(interval(4.0, 6.0)), interval(-1.0, -0x11e1f18ab0a2c0p-54)) + @test isequal_interval(sin(bareinterval(4.0, 6.0)), bareinterval(-1.0, -0x11e1f18ab0a2c0p-54)) - @test isequal_interval(sin(interval(4.0, 5.0)), interval(-1.0, -0x1837b9dddc1eaep-53)) + @test isequal_interval(sin(bareinterval(4.0, 5.0)), bareinterval(-1.0, -0x1837b9dddc1eaep-53)) - @test isequal_interval(sin(interval(4.0, 4.0)), interval(-0x1837b9dddc1eafp-53, -0x1837b9dddc1eaep-53)) + @test isequal_interval(sin(bareinterval(4.0, 4.0)), bareinterval(-0x1837b9dddc1eafp-53, -0x1837b9dddc1eaep-53)) - @test isequal_interval(sin(interval(5.0, 7.0)), interval(-0x1eaf81f5e09934p-53, 0x150608c26d0a09p-53)) + @test isequal_interval(sin(bareinterval(5.0, 7.0)), bareinterval(-0x1eaf81f5e09934p-53, 0x150608c26d0a09p-53)) - @test isequal_interval(sin(interval(5.0, 6.0)), interval(-0x1eaf81f5e09934p-53, -0x11e1f18ab0a2c0p-54)) + @test isequal_interval(sin(bareinterval(5.0, 6.0)), bareinterval(-0x1eaf81f5e09934p-53, -0x11e1f18ab0a2c0p-54)) - @test isequal_interval(sin(interval(5.0, 5.0)), interval(-0x1eaf81f5e09934p-53, -0x1eaf81f5e09933p-53)) + @test isequal_interval(sin(bareinterval(5.0, 5.0)), bareinterval(-0x1eaf81f5e09934p-53, -0x1eaf81f5e09933p-53)) - @test isequal_interval(sin(interval(6.0, 7.0)), interval(-0x11e1f18ab0a2c1p-54, 0x150608c26d0a09p-53)) + @test isequal_interval(sin(bareinterval(6.0, 7.0)), bareinterval(-0x11e1f18ab0a2c1p-54, 0x150608c26d0a09p-53)) - @test isequal_interval(sin(interval(6.0, 6.0)), interval(-0x11e1f18ab0a2c1p-54, -0x11e1f18ab0a2c0p-54)) + @test isequal_interval(sin(bareinterval(6.0, 6.0)), bareinterval(-0x11e1f18ab0a2c1p-54, -0x11e1f18ab0a2c0p-54)) - @test isequal_interval(sin(interval(7.0, 7.0)), interval(0x150608c26d0a08p-53, 0x150608c26d0a09p-53)) + @test isequal_interval(sin(bareinterval(7.0, 7.0)), bareinterval(0x150608c26d0a08p-53, 0x150608c26d0a09p-53)) end @testset "mpfi_sinh" begin - @test isequal_interval(sinh(interval(-Inf, -7.0)), interval(-Inf, -0x1122876ba380c9p-43)) + @test isequal_interval(sinh(bareinterval(-Inf, -7.0)), bareinterval(-Inf, -0x1122876ba380c9p-43)) - @test isequal_interval(sinh(interval(-Inf, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(sinh(bareinterval(-Inf, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(sinh(interval(-Inf, +8.0)), interval(-Inf, 0x1749ea514eca66p-42)) + @test isequal_interval(sinh(bareinterval(-Inf, +8.0)), bareinterval(-Inf, 0x1749ea514eca66p-42)) - @test isequal_interval(sinh(entireinterval()), entireinterval()) + @test isequal_interval(sinh(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(sinh(interval(-1.0, 0.0)), interval(-0x12cd9fc44eb983p-52, 0.0)) + @test isequal_interval(sinh(bareinterval(-1.0, 0.0)), bareinterval(-0x12cd9fc44eb983p-52, 0.0)) - @test isequal_interval(sinh(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(sinh(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(sinh(interval(0.0, +1.0)), interval(0.0, 0x12cd9fc44eb983p-52)) + @test isequal_interval(sinh(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x12cd9fc44eb983p-52)) - @test isequal_interval(sinh(interval(0.0, +8.0)), interval(0.0, 0x1749ea514eca66p-42)) + @test isequal_interval(sinh(bareinterval(0.0, +8.0)), bareinterval(0.0, 0x1749ea514eca66p-42)) - @test isequal_interval(sinh(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(sinh(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(sinh(interval(-0.125, 0.0)), interval(-0x100aaccd00d2f1p-55, 0.0)) + @test isequal_interval(sinh(bareinterval(-0.125, 0.0)), bareinterval(-0x100aaccd00d2f1p-55, 0.0)) - @test isequal_interval(sinh(interval(0.0, 0x10000000000001p-53)), interval(0.0, 0x10acd00fe63b98p-53)) + @test isequal_interval(sinh(bareinterval(0.0, 0x10000000000001p-53)), bareinterval(0.0, 0x10acd00fe63b98p-53)) - @test isequal_interval(sinh(interval(-4.5, -0.625)), interval(-0x168062ab5fa9fdp-47, -0x1553e795dc19ccp-53)) + @test isequal_interval(sinh(bareinterval(-4.5, -0.625)), bareinterval(-0x168062ab5fa9fdp-47, -0x1553e795dc19ccp-53)) - @test isequal_interval(sinh(interval(1.0, 3.0)), interval(0x12cd9fc44eb982p-52, 0x140926e70949aep-49)) + @test isequal_interval(sinh(bareinterval(1.0, 3.0)), bareinterval(0x12cd9fc44eb982p-52, 0x140926e70949aep-49)) end @testset "mpfi_sqr" begin - @test isequal_interval(interval(-Inf, -7.0)^2, interval(+49.0, +Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf, -7.0), 2), bareinterval(+49.0, +Inf)) - @test isequal_interval(interval(-Inf, 0.0)^2, interval(0.0, +Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf, 0.0), 2), bareinterval(0.0, +Inf)) - @test isequal_interval(interval(-Inf, +8.0)^2, interval(0.0, +Inf)) + @test isequal_interval(nthpow(bareinterval(-Inf, +8.0), 2), bareinterval(0.0, +Inf)) - @test isequal_interval(entireinterval()^2, interval(0.0, +Inf)) + @test isequal_interval(nthpow(entireinterval(BareInterval{Float64}), 2), bareinterval(0.0, +Inf)) - @test isequal_interval(interval(0.0, 0.0)^2, interval(0.0, 0.0)) + @test isequal_interval(nthpow(bareinterval(0.0, 0.0), 2), bareinterval(0.0, 0.0)) - @test isequal_interval(interval(0.0, +8.0)^2, interval(0.0, +64.0)) + @test isequal_interval(nthpow(bareinterval(0.0, +8.0), 2), bareinterval(0.0, +64.0)) - @test isequal_interval(interval(0.0, +Inf)^2, interval(0.0, +Inf)) + @test isequal_interval(nthpow(bareinterval(0.0, +Inf), 2), bareinterval(0.0, +Inf)) - @test isequal_interval(interval(0x8.6374d8p-4, 0x3.f1d929p+8)^2, interval(0x4.65df11464764p-4, 0xf.8f918d688891p+16)) + @test isequal_interval(nthpow(bareinterval(0x8.6374d8p-4, 0x3.f1d929p+8), 2), bareinterval(0x4.65df11464764p-4, 0xf.8f918d688891p+16)) - @test isequal_interval(interval(0x6.61485c33c0b14p+4, 0x123456p0)^2, interval(0x2.8b45c3cc03ea6p+12, 0x14b66cb0ce4p0)) + @test isequal_interval(nthpow(bareinterval(0x6.61485c33c0b14p+4, 0x123456p0), 2), bareinterval(0x2.8b45c3cc03ea6p+12, 0x14b66cb0ce4p0)) - @test isequal_interval(interval(-0x1.64722ad2480c9p+0, 0x1p0)^2, interval(0.0, 0x1.f04dba0302d4dp+0)) + @test isequal_interval(nthpow(bareinterval(-0x1.64722ad2480c9p+0, 0x1p0), 2), bareinterval(0.0, 0x1.f04dba0302d4dp+0)) - @test isequal_interval(interval(0x1.6b079248747a2p+0, 0x2.b041176d263f6p+0)^2, interval(0x2.02ce7912cddf6p+0, 0x7.3a5dee779527p+0)) + @test isequal_interval(nthpow(bareinterval(0x1.6b079248747a2p+0, 0x2.b041176d263f6p+0), 2), bareinterval(0x2.02ce7912cddf6p+0, 0x7.3a5dee779527p+0)) end @testset "mpfi_sqrt" begin - @test isequal_interval(sqrt(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(sqrt(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(sqrt(interval(0.0, +9.0)), interval(0.0, +3.0)) + @test isequal_interval(sqrt(bareinterval(0.0, +9.0)), bareinterval(0.0, +3.0)) - @test isequal_interval(sqrt(interval(0.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(sqrt(bareinterval(0.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(sqrt(interval(0xaaa1p0, 0x14b66cb0ce4p0)), interval(0xd1p0, 0x123456p0)) + @test isequal_interval(sqrt(bareinterval(0xaaa1p0, 0x14b66cb0ce4p0)), bareinterval(0xd1p0, 0x123456p0)) - @test isequal_interval(sqrt(interval(0xe.49ae7969e41bp-4, 0xaaa1p0)), interval(0xf.1ea42821b27a8p-4, 0xd1p0)) + @test isequal_interval(sqrt(bareinterval(0xe.49ae7969e41bp-4, 0xaaa1p0)), bareinterval(0xf.1ea42821b27a8p-4, 0xd1p0)) - @test isequal_interval(sqrt(interval(0xa.aa1p-4, 0x1.0c348f804c7a9p+0)), interval(0xd.1p-4, 0x1.06081714eef1dp+0)) + @test isequal_interval(sqrt(bareinterval(0xa.aa1p-4, 0x1.0c348f804c7a9p+0)), bareinterval(0xd.1p-4, 0x1.06081714eef1dp+0)) - @test isequal_interval(sqrt(interval(0xe.49ae7969e41bp-4, 0x1.0c348f804c7a9p+0)), interval(0xf.1ea42821b27a8p-4, 0x1.06081714eef1dp+0)) + @test isequal_interval(sqrt(bareinterval(0xe.49ae7969e41bp-4, 0x1.0c348f804c7a9p+0)), bareinterval(0xf.1ea42821b27a8p-4, 0x1.06081714eef1dp+0)) end @testset "mpfi_sub" begin - @test isequal_interval(-(interval(-Inf, -7.0), interval(-1.0, +8.0)), interval(-Inf, -6.0)) + @test isequal_interval(-(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), bareinterval(-Inf, -6.0)) - @test isequal_interval(-(interval(-Inf, 0.0), interval(+8.0, +Inf)), interval(-Inf, -8.0)) + @test isequal_interval(-(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), bareinterval(-Inf, -8.0)) - @test isequal_interval(-(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(-Inf, +8.0)) + @test isequal_interval(-(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(-Inf, +8.0)) - @test isequal_interval(-(entireinterval(), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(+7.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(+7.0, +Inf)) - @test isequal_interval(-(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(0.0, +15.0)) + @test isequal_interval(-(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(0.0, +15.0)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, +8.0)), interval(-8.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(-8.0, 0.0)) - @test isequal_interval(-(interval(0.0, +Inf), interval(0.0, +8.0)), interval(-8.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(-8.0, +Inf)) - @test isequal_interval(-(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(-Inf, -8.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(-Inf, -8.0)) - @test isequal_interval(-(interval(0.0, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(-(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0.0, +8.0), interval(-7.0, +8.0)), interval(-8.0, +15.0)) + @test isequal_interval(-(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), bareinterval(-8.0, +15.0)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(-(interval(0.0, +Inf), interval(0.0, +8.0)), interval(-8.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(-8.0, +Inf)) - @test isequal_interval(-(interval(-5.0, 59.0), interval(17.0, 81.0)), interval(-86.0, 42.0)) + @test isequal_interval(-(bareinterval(-5.0, 59.0), bareinterval(17.0, 81.0)), bareinterval(-86.0, 42.0)) - @test isequal_interval(-(interval(-0x1p-300, 0x123456p+28), interval(-0x789abcdp0, 0x10000000000000p-93)), interval(-0x10000000000001p-93, 0x123456789abcdp0)) + @test isequal_interval(-(bareinterval(-0x1p-300, 0x123456p+28), bareinterval(-0x789abcdp0, 0x10000000000000p-93)), bareinterval(-0x10000000000001p-93, 0x123456789abcdp0)) - @test isequal_interval(-(interval(-4.0, 7.0), interval(-3e300, 0x123456789abcdp-17)), interval(-0x123456791abcdp-17, 0x8f596b3002c1bp+947)) + @test isequal_interval(-(bareinterval(-4.0, 7.0), bareinterval(-3e300, 0x123456789abcdp-17)), bareinterval(-0x123456791abcdp-17, 0x8f596b3002c1bp+947)) - @test isequal_interval(-(interval(-0x1000100010001p+8, 0x1p+60), interval(-3e300, 0x1000100010001p0)), interval(-0x10101010101011p+4, 0x8f596b3002c1bp+947)) + @test isequal_interval(-(bareinterval(-0x1000100010001p+8, 0x1p+60), bareinterval(-3e300, 0x1000100010001p0)), bareinterval(-0x10101010101011p+4, 0x8f596b3002c1bp+947)) - @test isequal_interval(-(interval(-5.0, 1.0), interval(1.0, 0x1p+70)), interval(-0x10000000000001p+18, 0.0)) + @test isequal_interval(-(bareinterval(-5.0, 1.0), bareinterval(1.0, 0x1p+70)), bareinterval(-0x10000000000001p+18, 0.0)) - @test isequal_interval(-(interval(5.0, 0x1p+70), interval(3.0, 5.0)), interval(0.0, 0x1p+70)) + @test isequal_interval(-(bareinterval(5.0, 0x1p+70), bareinterval(3.0, 5.0)), bareinterval(0.0, 0x1p+70)) end @testset "mpfi_sub_d" begin - @test isequal_interval(-(interval(-Inf, -7.0), interval(-0x170ef54646d497p-107, -0x170ef54646d497p-107)), interval(-Inf, -0x1bffffffffffffp-50)) + @test isequal_interval(-(bareinterval(-Inf, -7.0), bareinterval(-0x170ef54646d497p-107, -0x170ef54646d497p-107)), bareinterval(-Inf, -0x1bffffffffffffp-50)) - @test isequal_interval(-(interval(-Inf, -7.0), interval(0.0, 0.0)), interval(-Inf, -7.0)) + @test isequal_interval(-(bareinterval(-Inf, -7.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, -7.0)) - @test isequal_interval(-(interval(-Inf, -7.0), interval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), interval(-Inf, -7.0)) + @test isequal_interval(-(bareinterval(-Inf, -7.0), bareinterval(0x170ef54646d497p-107, 0x170ef54646d497p-107)), bareinterval(-Inf, -7.0)) - @test isequal_interval(-(interval(-Inf, 0.0), interval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), interval(-Inf, 0x170ef54646d497p-106)) + @test isequal_interval(-(bareinterval(-Inf, 0.0), bareinterval(-0x170ef54646d497p-106, -0x170ef54646d497p-106)), bareinterval(-Inf, 0x170ef54646d497p-106)) - @test isequal_interval(-(interval(-Inf, 0.0), interval(0.0, 0.0)), interval(-Inf, 0.0)) + @test isequal_interval(-(bareinterval(-Inf, 0.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(-(interval(-Inf, 0.0), interval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), interval(-Inf, -8.0e-17)) + @test isequal_interval(-(bareinterval(-Inf, 0.0), bareinterval(0x170ef54646d497p-106, 0x170ef54646d497p-106)), bareinterval(-Inf, -8.0e-17)) - @test isequal_interval(-(interval(-Inf, 8.0), interval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), interval(-Inf, 0x16345785d8a00100p0)) + @test isequal_interval(-(bareinterval(-Inf, 8.0), bareinterval(-0x16345785d8a00000p0, -0x16345785d8a00000p0)), bareinterval(-Inf, 0x16345785d8a00100p0)) - @test isequal_interval(-(interval(-Inf, 8.0), interval(0.0, 0.0)), interval(-Inf, 8.0)) + @test isequal_interval(-(bareinterval(-Inf, 8.0), bareinterval(0.0, 0.0)), bareinterval(-Inf, 8.0)) - @test isequal_interval(-(interval(-Inf, 8.0), interval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), interval(-Inf, -0x16345785d89fff00p0)) + @test isequal_interval(-(bareinterval(-Inf, 8.0), bareinterval(0x16345785d8a00000p0, 0x16345785d8a00000p0)), bareinterval(-Inf, -0x16345785d89fff00p0)) - @test isequal_interval(-(entireinterval(), interval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(-0x170ef54646d497p-105, -0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), interval(0.0e-17, 0.0e-17)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(0.0e-17, 0.0e-17)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(entireinterval(), interval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval()) + @test isequal_interval(-(entireinterval(BareInterval{Float64}), bareinterval(+0x170ef54646d497p-105, +0x170ef54646d497p-105)), entireinterval(BareInterval{Float64})) - @test isequal_interval(-(interval(0.0, 0.0), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), interval(+0x170ef54646d497p-109, +0x170ef54646d497p-109)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)), bareinterval(+0x170ef54646d497p-109, +0x170ef54646d497p-109)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(-(interval(0.0, 0.0), interval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), interval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) + @test isequal_interval(-(bareinterval(0.0, 0.0), bareinterval(0x170ef54646d497p-109, 0x170ef54646d497p-109)), bareinterval(-0x170ef54646d497p-109, -0x170ef54646d497p-109)) - @test isequal_interval(-(interval(0.0, 8.0), interval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), interval(0x114b37f4b51f71p-107, 0x10000000000001p-49)) + @test isequal_interval(-(bareinterval(0.0, 8.0), bareinterval(-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107)), bareinterval(0x114b37f4b51f71p-107, 0x10000000000001p-49)) - @test isequal_interval(-(interval(0.0, 8.0), interval(0.0, 0.0)), interval(0.0, 8.0)) + @test isequal_interval(-(bareinterval(0.0, 8.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 8.0)) - @test isequal_interval(-(interval(0.0, 8.0), interval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107)), interval(-0x114b37f4b51f71p-107, 8.0)) + @test isequal_interval(-(bareinterval(0.0, 8.0), bareinterval(0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107)), bareinterval(-0x114b37f4b51f71p-107, 8.0)) - @test isequal_interval(-(interval(0.0, +Inf), interval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), interval(0x50b45a75f7e81p-104, +Inf)) + @test isequal_interval(-(bareinterval(0.0, +Inf), bareinterval(-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104)), bareinterval(0x50b45a75f7e81p-104, +Inf)) - @test isequal_interval(-(interval(0.0, +Inf), interval(0.0, 0.0)), interval(0.0, +Inf)) + @test isequal_interval(-(bareinterval(0.0, +Inf), bareinterval(0.0, 0.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(-(interval(0.0, +Inf), interval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), interval(-0x142d169d7dfa03p-106, +Inf)) + @test isequal_interval(-(bareinterval(0.0, +Inf), bareinterval(0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106)), bareinterval(-0x142d169d7dfa03p-106, +Inf)) - @test isequal_interval(-(interval(-32.0, -17.0), interval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47)), interval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) + @test isequal_interval(-(bareinterval(-32.0, -17.0), bareinterval(0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47)), bareinterval(-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47)) - @test isequal_interval(-(interval(-0xfb53d14aa9c2fp-47, -17.0), interval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47)), interval(0.0, 0x7353d14aa9c2fp-47)) + @test isequal_interval(-(bareinterval(-0xfb53d14aa9c2fp-47, -17.0), bareinterval(-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47)), bareinterval(0.0, 0x7353d14aa9c2fp-47)) - @test isequal_interval(-(interval(-32.0, -0xfb53d14aa9c2fp-48), interval(-0xfb53d14aa9c2fp-48, -0xfb53d14aa9c2fp-48)), interval(-0x104ac2eb5563d1p-48, 0.0)) + @test isequal_interval(-(bareinterval(-32.0, -0xfb53d14aa9c2fp-48), bareinterval(-0xfb53d14aa9c2fp-48, -0xfb53d14aa9c2fp-48)), bareinterval(-0x104ac2eb5563d1p-48, 0.0)) - @test isequal_interval(-(interval(0x123456789abcdfp-48, 0x123456789abcdfp-4), interval(-3.5, -3.5)), interval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) + @test isequal_interval(-(bareinterval(0x123456789abcdfp-48, 0x123456789abcdfp-4), bareinterval(-3.5, -3.5)), bareinterval(0x15b456789abcdfp-48, 0x123456789abd17p-4)) - @test isequal_interval(-(interval(0x123456789abcdfp-56, 0x123456789abcdfp-4), interval(-3.5, -3.5)), interval(0x3923456789abcdp-52, 0x123456789abd17p-4)) + @test isequal_interval(-(bareinterval(0x123456789abcdfp-56, 0x123456789abcdfp-4), bareinterval(-3.5, -3.5)), bareinterval(0x3923456789abcdp-52, 0x123456789abd17p-4)) - @test isequal_interval(-(interval(-0xffp0, 0x123456789abcdfp-52), interval(-256.5, -256.5)), interval(0x18p-4, 0x101a3456789abdp-44)) + @test isequal_interval(-(bareinterval(-0xffp0, 0x123456789abcdfp-52), bareinterval(-256.5, -256.5)), bareinterval(0x18p-4, 0x101a3456789abdp-44)) - @test isequal_interval(-(interval(-0x1fffffffffffffp-52, -0x1p-550), interval(-4097.5, -4097.5)), interval(0xfff8p-4, 0x10018p-4)) + @test isequal_interval(-(bareinterval(-0x1fffffffffffffp-52, -0x1p-550), bareinterval(-4097.5, -4097.5)), bareinterval(0xfff8p-4, 0x10018p-4)) - @test isequal_interval(-(interval(0x123456789abcdfp-48, 0x123456789abcdfp-4), interval(3.5, 3.5)), interval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) + @test isequal_interval(-(bareinterval(0x123456789abcdfp-48, 0x123456789abcdfp-4), bareinterval(3.5, 3.5)), bareinterval(0xeb456789abcdfp-48, 0x123456789abca7p-4)) - @test isequal_interval(-(interval(0x123456789abcdfp-56, 0x123456789abcdfp-4), interval(3.5, 3.5)), interval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) + @test isequal_interval(-(bareinterval(0x123456789abcdfp-56, 0x123456789abcdfp-4), bareinterval(3.5, 3.5)), bareinterval(-0x36dcba98765434p-52, 0x123456789abca7p-4)) - @test isequal_interval(-(interval(-0xffp0, 0x123456789abcdfp-52), interval(256.5, 256.5)), interval(-0x1ff8p-4, -0xff5cba9876543p-44)) + @test isequal_interval(-(bareinterval(-0xffp0, 0x123456789abcdfp-52), bareinterval(256.5, 256.5)), bareinterval(-0x1ff8p-4, -0xff5cba9876543p-44)) - @test isequal_interval(-(interval(-0x1fffffffffffffp-52, -0x1p-550), interval(4097.5, 4097.5)), interval(-0x10038p-4, -0x10018p-4)) + @test isequal_interval(-(bareinterval(-0x1fffffffffffffp-52, -0x1p-550), bareinterval(4097.5, 4097.5)), bareinterval(-0x10038p-4, -0x10018p-4)) end @testset "mpfi_tan" begin - @test isequal_interval(tan(interval(-Inf, -7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-Inf, -7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-Inf, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-Inf, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-Inf, +8.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-Inf, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(entireinterval()), entireinterval()) + @test isequal_interval(tan(entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 0.0)), interval(-0x18eb245cbee3a6p-52, 0.0)) + @test isequal_interval(tan(bareinterval(-1.0, 0.0)), bareinterval(-0x18eb245cbee3a6p-52, 0.0)) - @test isequal_interval(tan(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(tan(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(tan(interval(0.0, +1.0)), interval(0.0, 0x18eb245cbee3a6p-52)) + @test isequal_interval(tan(bareinterval(0.0, +1.0)), bareinterval(0.0, 0x18eb245cbee3a6p-52)) - @test isequal_interval(tan(interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.0, +Inf)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0.125, 17.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(0.125, 17.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(0x1921fb54442d18p-52, 0x1921fb54442d19p-52)), entireinterval()) + @test isequal_interval(tan(bareinterval(0x1921fb54442d18p-52, 0x1921fb54442d19p-52)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, -0.5)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, -0.5)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.5, 0.625)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.5, 0.625)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, -0.25)), interval(-0x18eb245cbee3a6p-52, -0x105785a43c4c55p-54)) + @test isequal_interval(tan(bareinterval(-1.0, -0.25)), bareinterval(-0x18eb245cbee3a6p-52, -0x105785a43c4c55p-54)) - @test isequal_interval(tan(interval(-0.5, 0.5)), interval(-0x117b4f5bf3474bp-53, 0x117b4f5bf3474bp-53)) + @test isequal_interval(tan(bareinterval(-0.5, 0.5)), bareinterval(-0x117b4f5bf3474bp-53, 0x117b4f5bf3474bp-53)) - @test isequal_interval(tan(interval(0x71p+76, 0x71p+76)), interval(-0x1c8dc87ddcc134p-55, -0x1c8dc87ddcc133p-55)) + @test isequal_interval(tan(bareinterval(0x71p+76, 0x71p+76)), bareinterval(-0x1c8dc87ddcc134p-55, -0x1c8dc87ddcc133p-55)) - @test isequal_interval(tan(interval(-7.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, -2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, -3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, -4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-7.0, -4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-7.0, -5.0)), interval(-0x1be2e6e13eea79p-53, 0x1b0b4b739bbb07p-51)) + @test isequal_interval(tan(bareinterval(-7.0, -5.0)), bareinterval(-0x1be2e6e13eea79p-53, 0x1b0b4b739bbb07p-51)) - @test isequal_interval(tan(interval(-7.0, -6.0)), interval(-0x1be2e6e13eea79p-53, 0x129fd86ebb95bfp-54)) + @test isequal_interval(tan(bareinterval(-7.0, -6.0)), bareinterval(-0x1be2e6e13eea79p-53, 0x129fd86ebb95bfp-54)) - @test isequal_interval(tan(interval(-7.0, -7.0)), interval(-0x1be2e6e13eea79p-53, -0x1be2e6e13eea78p-53)) + @test isequal_interval(tan(bareinterval(-7.0, -7.0)), bareinterval(-0x1be2e6e13eea79p-53, -0x1be2e6e13eea78p-53)) - @test isequal_interval(tan(interval(-6.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, -2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, -3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, -4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-6.0, -4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-6.0, -5.0)), interval(0x129fd86ebb95bep-54, 0x1b0b4b739bbb07p-51)) + @test isequal_interval(tan(bareinterval(-6.0, -5.0)), bareinterval(0x129fd86ebb95bep-54, 0x1b0b4b739bbb07p-51)) - @test isequal_interval(tan(interval(-6.0, -6.0)), interval(0x129fd86ebb95bep-54, 0x129fd86ebb95bfp-54)) + @test isequal_interval(tan(bareinterval(-6.0, -6.0)), bareinterval(0x129fd86ebb95bep-54, 0x129fd86ebb95bfp-54)) - @test isequal_interval(tan(interval(-5.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, -2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, -2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, -3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, -3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, -4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-5.0, -4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-5.0, -5.0)), interval(0x1b0b4b739bbb06p-51, 0x1b0b4b739bbb07p-51)) + @test isequal_interval(tan(bareinterval(-5.0, -5.0)), bareinterval(0x1b0b4b739bbb06p-51, 0x1b0b4b739bbb07p-51)) - @test isequal_interval(tan(interval(-4.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-4.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-4.0, -2.0)), interval(-0x12866f9be4de14p-52, 0x117af62e0950f9p-51)) + @test isequal_interval(tan(bareinterval(-4.0, -2.0)), bareinterval(-0x12866f9be4de14p-52, 0x117af62e0950f9p-51)) - @test isequal_interval(tan(interval(-4.0, -3.0)), interval(-0x12866f9be4de14p-52, 0x123ef71254b870p-55)) + @test isequal_interval(tan(bareinterval(-4.0, -3.0)), bareinterval(-0x12866f9be4de14p-52, 0x123ef71254b870p-55)) - @test isequal_interval(tan(interval(-4.0, -4.0)), interval(-0x12866f9be4de14p-52, -0x12866f9be4de13p-52)) + @test isequal_interval(tan(bareinterval(-4.0, -4.0)), bareinterval(-0x12866f9be4de14p-52, -0x12866f9be4de13p-52)) - @test isequal_interval(tan(interval(-3.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-3.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-3.0, -2.0)), interval(0x123ef71254b86fp-55, 0x117af62e0950f9p-51)) + @test isequal_interval(tan(bareinterval(-3.0, -2.0)), bareinterval(0x123ef71254b86fp-55, 0x117af62e0950f9p-51)) - @test isequal_interval(tan(interval(-3.0, -3.0)), interval(0x123ef71254b86fp-55, 0x123ef71254b870p-55)) + @test isequal_interval(tan(bareinterval(-3.0, -3.0)), bareinterval(0x123ef71254b86fp-55, 0x123ef71254b870p-55)) - @test isequal_interval(tan(interval(-2.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, 0.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, 0.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, -1.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-2.0, -1.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-2.0, -2.0)), interval(0x117af62e0950f8p-51, 0x117af62e0950f9p-51)) + @test isequal_interval(tan(bareinterval(-2.0, -2.0)), bareinterval(0x117af62e0950f8p-51, 0x117af62e0950f9p-51)) - @test isequal_interval(tan(interval(-1.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(-1.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(-1.0, 1.0)), interval(-0x18eb245cbee3a6p-52, 0x18eb245cbee3a6p-52)) + @test isequal_interval(tan(bareinterval(-1.0, 1.0)), bareinterval(-0x18eb245cbee3a6p-52, 0x18eb245cbee3a6p-52)) - @test isequal_interval(tan(interval(-1.0, 0.0)), interval(-0x18eb245cbee3a6p-52, 0.0)) + @test isequal_interval(tan(bareinterval(-1.0, 0.0)), bareinterval(-0x18eb245cbee3a6p-52, 0.0)) - @test isequal_interval(tan(interval(-1.0, -1.0)), interval(-0x18eb245cbee3a6p-52, -0x18eb245cbee3a5p-52)) + @test isequal_interval(tan(bareinterval(-1.0, -1.0)), bareinterval(-0x18eb245cbee3a6p-52, -0x18eb245cbee3a5p-52)) - @test isequal_interval(tan(interval(1.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 4.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 4.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 3.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 3.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 2.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(1.0, 2.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(1.0, 1.0)), interval(0x18eb245cbee3a5p-52, 0x18eb245cbee3a6p-52)) + @test isequal_interval(tan(bareinterval(1.0, 1.0)), bareinterval(0x18eb245cbee3a5p-52, 0x18eb245cbee3a6p-52)) - @test isequal_interval(tan(interval(2.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(2.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(2.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(2.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(2.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(2.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(2.0, 4.0)), interval(-0x117af62e0950f9p-51, 0x12866f9be4de14p-52)) + @test isequal_interval(tan(bareinterval(2.0, 4.0)), bareinterval(-0x117af62e0950f9p-51, 0x12866f9be4de14p-52)) - @test isequal_interval(tan(interval(2.0, 3.0)), interval(-0x117af62e0950f9p-51, -0x123ef71254b86fp-55)) + @test isequal_interval(tan(bareinterval(2.0, 3.0)), bareinterval(-0x117af62e0950f9p-51, -0x123ef71254b86fp-55)) - @test isequal_interval(tan(interval(2.0, 2.0)), interval(-0x117af62e0950f9p-51, -0x117af62e0950f8p-51)) + @test isequal_interval(tan(bareinterval(2.0, 2.0)), bareinterval(-0x117af62e0950f9p-51, -0x117af62e0950f8p-51)) - @test isequal_interval(tan(interval(3.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(3.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(3.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(3.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(3.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(3.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(3.0, 4.0)), interval(-0x123ef71254b870p-55, 0x12866f9be4de14p-52)) + @test isequal_interval(tan(bareinterval(3.0, 4.0)), bareinterval(-0x123ef71254b870p-55, 0x12866f9be4de14p-52)) - @test isequal_interval(tan(interval(3.0, 3.0)), interval(-0x123ef71254b870p-55, -0x123ef71254b86fp-55)) + @test isequal_interval(tan(bareinterval(3.0, 3.0)), bareinterval(-0x123ef71254b870p-55, -0x123ef71254b86fp-55)) - @test isequal_interval(tan(interval(4.0, 7.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(4.0, 7.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(4.0, 6.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(4.0, 6.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(4.0, 5.0)), entireinterval()) + @test isequal_interval(tan(bareinterval(4.0, 5.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(tan(interval(4.0, 4.0)), interval(0x12866f9be4de13p-52, 0x12866f9be4de14p-52)) + @test isequal_interval(tan(bareinterval(4.0, 4.0)), bareinterval(0x12866f9be4de13p-52, 0x12866f9be4de14p-52)) - @test isequal_interval(tan(interval(5.0, 7.0)), interval(-0x1b0b4b739bbb07p-51, 0x1be2e6e13eea79p-53)) + @test isequal_interval(tan(bareinterval(5.0, 7.0)), bareinterval(-0x1b0b4b739bbb07p-51, 0x1be2e6e13eea79p-53)) - @test isequal_interval(tan(interval(5.0, 6.0)), interval(-0x1b0b4b739bbb07p-51, -0x129fd86ebb95bep-54)) + @test isequal_interval(tan(bareinterval(5.0, 6.0)), bareinterval(-0x1b0b4b739bbb07p-51, -0x129fd86ebb95bep-54)) - @test isequal_interval(tan(interval(5.0, 5.0)), interval(-0x1b0b4b739bbb07p-51, -0x1b0b4b739bbb06p-51)) + @test isequal_interval(tan(bareinterval(5.0, 5.0)), bareinterval(-0x1b0b4b739bbb07p-51, -0x1b0b4b739bbb06p-51)) - @test isequal_interval(tan(interval(6.0, 7.0)), interval(-0x129fd86ebb95bfp-54, 0x1be2e6e13eea79p-53)) + @test isequal_interval(tan(bareinterval(6.0, 7.0)), bareinterval(-0x129fd86ebb95bfp-54, 0x1be2e6e13eea79p-53)) - @test isequal_interval(tan(interval(6.0, 6.0)), interval(-0x129fd86ebb95bfp-54, -0x129fd86ebb95bep-54)) + @test isequal_interval(tan(bareinterval(6.0, 6.0)), bareinterval(-0x129fd86ebb95bfp-54, -0x129fd86ebb95bep-54)) - @test isequal_interval(tan(interval(7.0, 7.0)), interval(0x1be2e6e13eea78p-53, 0x1be2e6e13eea79p-53)) + @test isequal_interval(tan(bareinterval(7.0, 7.0)), bareinterval(0x1be2e6e13eea78p-53, 0x1be2e6e13eea79p-53)) end @testset "mpfi_tanh" begin - @test isequal_interval(tanh(interval(-Inf, -7.0)), interval(-1.0, -0x1ffffc832750f1p-53)) + @test isequal_interval(tanh(bareinterval(-Inf, -7.0)), bareinterval(-1.0, -0x1ffffc832750f1p-53)) - @test isequal_interval(tanh(interval(-Inf, 0.0)), interval(-1.0, 0.0)) + @test isequal_interval(tanh(bareinterval(-Inf, 0.0)), bareinterval(-1.0, 0.0)) - @test isequal_interval(tanh(interval(-Inf, 8.0)), interval(-1.0, 0x1fffff872a91f9p-53)) + @test isequal_interval(tanh(bareinterval(-Inf, 8.0)), bareinterval(-1.0, 0x1fffff872a91f9p-53)) - @test isequal_interval(tanh(entireinterval()), interval(-1.0, +1.0)) + @test isequal_interval(tanh(entireinterval(BareInterval{Float64})), bareinterval(-1.0, +1.0)) - @test isequal_interval(tanh(interval(-1.0, 0.0)), interval(-0x185efab514f395p-53, 0.0)) + @test isequal_interval(tanh(bareinterval(-1.0, 0.0)), bareinterval(-0x185efab514f395p-53, 0.0)) - @test isequal_interval(tanh(interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(tanh(bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(tanh(interval(0.0, 1.0)), interval(0.0, 0x185efab514f395p-53)) + @test isequal_interval(tanh(bareinterval(0.0, 1.0)), bareinterval(0.0, 0x185efab514f395p-53)) - @test isequal_interval(tanh(interval(0.0, 8.0)), interval(0.0, 0x1fffff872a91f9p-53)) + @test isequal_interval(tanh(bareinterval(0.0, 8.0)), bareinterval(0.0, 0x1fffff872a91f9p-53)) - @test isequal_interval(tanh(interval(0.0, +Inf)), interval(0.0, +1.0)) + @test isequal_interval(tanh(bareinterval(0.0, +Inf)), bareinterval(0.0, +1.0)) - @test isequal_interval(tanh(interval(-0.125, 0.0)), interval(-0x1fd5992bc4b835p-56, 0.0)) + @test isequal_interval(tanh(bareinterval(-0.125, 0.0)), bareinterval(-0x1fd5992bc4b835p-56, 0.0)) - @test isequal_interval(tanh(interval(0.0, 0x10000000000001p-53)), interval(0.0, 0x1d9353d7568af5p-54)) + @test isequal_interval(tanh(bareinterval(0.0, 0x10000000000001p-53)), bareinterval(0.0, 0x1d9353d7568af5p-54)) - @test isequal_interval(tanh(interval(-4.5, -0.625)), interval(-0x1ffdfa72153984p-53, -0x11bf47eabb8f95p-53)) + @test isequal_interval(tanh(bareinterval(-4.5, -0.625)), bareinterval(-0x1ffdfa72153984p-53, -0x11bf47eabb8f95p-53)) - @test isequal_interval(tanh(interval(1.0, 3.0)), interval(0x185efab514f394p-53, 0x1fd77d111a0b00p-53)) + @test isequal_interval(tanh(bareinterval(1.0, 3.0)), bareinterval(0x185efab514f394p-53, 0x1fd77d111a0b00p-53)) - @test isequal_interval(tanh(interval(17.0, 18.0)), interval(0x1fffffffffffe1p-53, 0x1ffffffffffffcp-53)) + @test isequal_interval(tanh(bareinterval(17.0, 18.0)), bareinterval(0x1fffffffffffe1p-53, 0x1ffffffffffffcp-53)) end @testset "mpfi_union" begin - @test isequal_interval(hull(interval(-Inf, -7.0), interval(-1.0, +8.0)), interval(-Inf, +8.0)) + @test isequal_interval(hull(bareinterval(-Inf, -7.0), bareinterval(-1.0, +8.0)), bareinterval(-Inf, +8.0)) - @test isequal_interval(hull(interval(-Inf, 0.0), interval(+8.0, +Inf)), entireinterval()) + @test isequal_interval(hull(bareinterval(-Inf, 0.0), bareinterval(+8.0, +Inf)), entireinterval(BareInterval{Float64})) - @test isequal_interval(hull(interval(-Inf, +8.0), interval(0.0, +8.0)), interval(-Inf, +8.0)) + @test isequal_interval(hull(bareinterval(-Inf, +8.0), bareinterval(0.0, +8.0)), bareinterval(-Inf, +8.0)) - @test isequal_interval(hull(entireinterval(), interval(0.0, +8.0)), entireinterval()) + @test isequal_interval(hull(entireinterval(BareInterval{Float64}), bareinterval(0.0, +8.0)), entireinterval(BareInterval{Float64})) - @test isequal_interval(hull(interval(0.0, 0.0), interval(-Inf, -7.0)), interval(-Inf, 0.0)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(-Inf, -7.0)), bareinterval(-Inf, 0.0)) - @test isequal_interval(hull(interval(0.0, +8.0), interval(-7.0, 0.0)), interval(-7.0, +8.0)) + @test isequal_interval(hull(bareinterval(0.0, +8.0), bareinterval(-7.0, 0.0)), bareinterval(-7.0, +8.0)) - @test isequal_interval(hull(interval(0.0, 0.0), interval(0.0, +8.0)), interval(0.0, +8.0)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(0.0, +8.0)), bareinterval(0.0, +8.0)) - @test isequal_interval(hull(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(hull(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hull(interval(0.0, 0.0), interval(+8.0, +Inf)), interval(0.0, +Inf)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(+8.0, +Inf)), bareinterval(0.0, +Inf)) - @test isequal_interval(hull(interval(0.0, 0.0), entireinterval()), entireinterval()) + @test isequal_interval(hull(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})), entireinterval(BareInterval{Float64})) - @test isequal_interval(hull(interval(0.0, +8.0), interval(-7.0, +8.0)), interval(-7.0, +8.0)) + @test isequal_interval(hull(bareinterval(0.0, +8.0), bareinterval(-7.0, +8.0)), bareinterval(-7.0, +8.0)) - @test isequal_interval(hull(interval(0.0, 0.0), interval(0.0, 0.0)), interval(0.0, 0.0)) + @test isequal_interval(hull(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0)), bareinterval(0.0, 0.0)) - @test isequal_interval(hull(interval(0.0, +Inf), interval(0.0, +8.0)), interval(0.0, +Inf)) + @test isequal_interval(hull(bareinterval(0.0, +Inf), bareinterval(0.0, +8.0)), bareinterval(0.0, +Inf)) - @test isequal_interval(hull(interval(0x12p0, 0x90p0), interval(-0x0dp0, 0x34p0)), interval(-0x0dp0, 0x90p0)) + @test isequal_interval(hull(bareinterval(0x12p0, 0x90p0), bareinterval(-0x0dp0, 0x34p0)), bareinterval(-0x0dp0, 0x90p0)) end diff --git a/test/test_ITF1788/pow_rev.jl b/test/test_ITF1788/pow_rev.jl index d403431eb..026c9bdf2 100644 --- a/test/test_ITF1788/pow_rev.jl +++ b/test/test_ITF1788/pow_rev.jl @@ -1,1615 +1,1615 @@ @testset "minimal.powRev1_test" begin - @test pow_rev1(emptyinterval(), emptyinterval(), emptyinterval()) === emptyinterval() + @test pow_rev1(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(emptyinterval(), entireinterval(), emptyinterval()) === emptyinterval() + @test pow_rev1(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(entireinterval(), emptyinterval(), emptyinterval()) === emptyinterval() + @test pow_rev1(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(entireinterval(), entireinterval(), emptyinterval()) === emptyinterval() + @test pow_rev1(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(emptyinterval(), emptyinterval(), entireinterval()) === emptyinterval() + @test pow_rev1(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(emptyinterval(), entireinterval(), entireinterval()) === emptyinterval() + @test pow_rev1(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(entireinterval(), emptyinterval(), entireinterval()) === emptyinterval() + @test pow_rev1(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(entireinterval(), entireinterval(), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), entireinterval(), interval(-Inf,-1.0)) === emptyinterval() + @test pow_rev1(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), bareinterval(-Inf,-1.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(-Inf,-1.0), entireinterval(), interval(-Inf,0.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(-Inf,-1.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(-Inf,0.0), entireinterval(), interval(-Inf,0.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(-Inf,0.0), entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(-Inf,0.0), interval(-Inf,0.0), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(-Inf,0.0), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(-Inf,0.0), interval(-Inf,0.9), interval(0.0,1.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(-Inf,0.9), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(-Inf,0.0), interval(1.1,Inf), interval(1.0,Inf)) === emptyinterval() + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(1.1,Inf), bareinterval(1.0,Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.1,Inf), interval(0.0,1.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.1,Inf), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(-Inf,0.9), interval(1.0,Inf)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,0.9), bareinterval(1.0,Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,0.0), interval(1.0,1.0), interval(-Inf,0.0)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,1.0), bareinterval(-Inf,0.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(entireinterval(), interval(0.0,0.0), entireinterval()) === interval(0.0,0.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,0.0) - @test pow_rev1(entireinterval(), interval(-Inf,0.0), entireinterval()) === interval(0.0,0.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,0.0) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,0.0), entireinterval()) === interval(0.0,0.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,0.0) - @test pow_rev1(interval(0.0,Inf), interval(0.0,0.0), entireinterval()) === interval(0.0,0.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,0.0) - @test pow_rev1(interval(1.0,2.0), interval(0.0,0.0), entireinterval()) === interval(0.0,0.0) + @test pow_rev1(bareinterval(1.0,2.0), bareinterval(0.0,0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,0.0) - @test pow_rev1(interval(1.0,1.0), interval(0.0,0.0), interval(0.0,0.0)) === interval(0.0,0.0) + @test pow_rev1(bareinterval(1.0,1.0), bareinterval(0.0,0.0), bareinterval(0.0,0.0)) === bareinterval(0.0,0.0) - @test pow_rev1(entireinterval(), interval(1.0,1.0), interval(1.0,1.0)) === interval(1.0,1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), bareinterval(1.0,1.0)) === bareinterval(1.0,1.0) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,1.0), entireinterval()) === interval(0.0,Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,1.0), interval(2.0,3.0)) === interval(2.0,3.0) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,1.0), bareinterval(2.0,3.0)) === bareinterval(2.0,3.0) - @test_broken pow_rev1(entireinterval(), interval(1.0,1.0), entireinterval()) === interval(0.0,Inf) + @test_broken pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0,Inf) - @test_broken pow_rev1(entireinterval(), interval(1.0,1.0), interval(20.0,30.0)) === interval(20.0,30.0) + @test_broken pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), bareinterval(20.0,30.0)) === bareinterval(20.0,30.0) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,1.0), interval(1.0,1.0)) === interval(1.0,1.0) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,1.0), bareinterval(1.0,1.0)) === bareinterval(1.0,1.0) - @test pow_rev1(interval(-4.0,-2.0), interval(0.0,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(0.0,0.5), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(-Inf,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(-Inf,0.5), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(0.25,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, 2.0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, 2.0) - @test pow_rev1(interval(-Inf,-2.0), interval(0.25,0.5), entireinterval()) === interval(1.0, 2.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 2.0) - @test pow_rev1(interval(-4.0,-2.0), interval(0.25,1.0), entireinterval()) === interval(1.0, 2.0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 2.0) - @test pow_rev1(interval(-Inf,-2.0), interval(0.25,1.0), entireinterval()) === interval(1.0, 2.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 2.0) - @test pow_rev1(interval(-4.0,-2.0), interval(1.0,1.0), entireinterval()) === interval(1.0, 1.0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 1.0) - @test pow_rev1(interval(-Inf,-2.0), interval(1.0,1.0), entireinterval()) === interval(1.0, 1.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 1.0) - @test pow_rev1(interval(-4.0,-2.0), interval(0.0,1.0), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(0.0,1.0), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(0.0,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(0.0,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(-Inf,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(-Inf,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,-2.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,-2.0), interval(0.5,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(-Inf,-2.0), interval(0.5,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(-4.0,-2.0), interval(0.5,Inf), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(-Inf,-2.0), interval(0.5,Inf), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(-4.0,-2.0), interval(1.0,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 1.0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 1.0) - @test pow_rev1(interval(-Inf,-2.0), interval(1.0,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 1.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 1.0) - @test pow_rev1(interval(-4.0,-2.0), interval(1.0,Inf), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,-2.0), interval(1.0,Inf), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,-2.0), interval(2.0,4.0), entireinterval()) === interval(0.5, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,-2.0), interval(2.0,4.0), entireinterval()) === interval(0.5, 1.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 1.0) - @test pow_rev1(interval(-4.0,-2.0), interval(2.0,Inf), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(-4.0,-2.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,-2.0), interval(2.0,Inf), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,-2.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,0.0), interval(0.0,0.5), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,0.0), interval(-Inf,0.5), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,0.0), interval(0.25,0.5), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,0.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,0.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,0.0), interval(2.0,4.0), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,0.0), interval(2.0,Inf), entireinterval()) === emptyinterval() + @test pow_rev1(bareinterval(0.0,0.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(-4.0,0.0), interval(0.0,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.0,0.5), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(-Inf,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(-Inf,0.5), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(0.25,0.5), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.25,0.5), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,0.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,0.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,0.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,0.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,0.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,0.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,0.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,0.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,0.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,0.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,0.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,0.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,0.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,0.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,0.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,0.0), interval(2.0,4.0), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,0.0), interval(2.0,4.0), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,0.0), interval(2.0,Inf), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(-4.0,0.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,0.0), interval(2.0,Inf), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,0.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test_broken pow_rev1(interval(-Inf,4.0), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test_broken pow_rev1(interval(-4.0,4.0), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test_broken pow_rev1(interval(-Inf,4.0), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,4.0), interval(0.0,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(-Inf,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,Inf), interval(0.0,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,Inf), interval(-Inf,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.25,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.25,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.25,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.25,0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test_broken pow_rev1(interval(-Inf,4.0), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-4.0,Inf), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,4.0), interval(0.25,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.25,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,Inf), interval(0.25,0.5), interval(1.0, Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(entireinterval(), interval(0.25,0.5), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-Inf,4.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,Inf), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(entireinterval(), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,4.0), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-Inf,4.0), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,Inf), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(entireinterval(), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-Inf,4.0), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(-4.0,Inf), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(entireinterval(), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(entireinterval(), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(2.0,4.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(2.0,4.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,4.0), interval(2.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-Inf,4.0), interval(2.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(2.0,4.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(2.0,4.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(2.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(entireinterval(), interval(2.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(2.0,4.0), interval(0.0,1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,4.0), interval(2.0,4.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,4.0), interval(2.0,Inf), interval(0.0,1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(-Inf,4.0), interval(2.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,Inf), interval(2.0,4.0), interval(0.0,1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(entireinterval(), interval(2.0,4.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,Inf), interval(2.0,Inf), interval(0.0,1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test_broken pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(entireinterval(), interval(2.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(-4.0,4.0), interval(2.0,4.0), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test_broken pow_rev1(interval(-Inf,4.0), interval(2.0,4.0), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test_broken pow_rev1(interval(-4.0,4.0), interval(2.0,Inf), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-4.0,4.0), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test_broken pow_rev1(interval(-Inf,4.0), interval(2.0,Inf), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test_broken pow_rev1(bareinterval(-Inf,4.0), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(2.0,4.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(2.0,4.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(-4.0,Inf), interval(2.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(-4.0,Inf), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(entireinterval(), interval(2.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(entireinterval(BareInterval{Float64}), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,0.5), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,0.5), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,Inf), interval(0.0,0.5), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,0.5), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,Inf), interval(0.0,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.0,0.5), interval(1.0, Inf)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,0.5), interval(1.0, Inf)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.0,0.5), interval(1.0, Inf)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(-Inf,0.5), interval(1.0, Inf)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,4.0), interval(0.25,0.5), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,Inf), interval(0.25,0.5), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(0.0,Inf), interval(0.25,0.5), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,0.5), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.25,0.5), interval(1.0, Inf)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.25,0.5), interval(1.0, Inf)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,0.5), bareinterval(1.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,4.0), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.25,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.25,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,4.0), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.25,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.25,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.0,1.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.0,1.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,1.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,4.0), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(0.0,1.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,1.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.0,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.0,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.0,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,2.0), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,2.0), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,Inf), interval(0.0, 1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,Inf), bareinterval(0.0, 1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.0,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.0,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.0,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,2.0), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,2.0), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(-Inf,Inf), interval(1.0, Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(-Inf,Inf), bareinterval(1.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.5,2.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.5,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.5,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,Inf), interval(0.5,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.5,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(0.5,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(0.5,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,2.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,Inf), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,4.0), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,2.0), interval(0.0,1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,2.0), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test_broken pow_rev1(interval(0.0,Inf), interval(1.0,Inf), interval(0.0,1.0)) === interval(0.0, 1.0) + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,Inf), bareinterval(0.0,1.0)) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(0.0,4.0), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(1.0,2.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,2.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(1.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(1.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(2.0,4.0), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(2.0,Inf), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(2.0,4.0), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(2.0,Inf), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(2.0,4.0), interval(0.0,1.0)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,4.0), interval(2.0,Inf), interval(0.0,1.0)) === emptyinterval() + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(2.0,4.0), interval(0.0,1.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,4.0), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev1(interval(0.0,Inf), interval(2.0,Inf), interval(0.0,1.0)) === emptyinterval() + @test_broken pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,Inf), bareinterval(0.0,1.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev1(interval(0.0,4.0), interval(2.0,4.0), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(0.0,4.0), interval(2.0,Inf), interval(1.0,Inf)) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(0.0,4.0), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(2.0,4.0), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,4.0), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(0.0,Inf), interval(2.0,Inf), interval(1.0,Inf)) === interval(1.0, Inf) + @test pow_rev1(bareinterval(0.0,Inf), bareinterval(2.0,Inf), bareinterval(1.0,Inf)) === bareinterval(1.0, Inf) - @test pow_rev1(interval(2.0,4.0), interval(0.0,0.5), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(2.0,4.0), interval(-Inf,0.5), entireinterval()) === interval(0.0, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(2.0,Inf), interval(0.0,0.5), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.0,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(2.0,Inf), interval(-Inf,0.5), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(-Inf,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(2.0,4.0), interval(0.25,0.5), entireinterval()) === interval(0.5, 0x1.AE89F995AD3AEp-1) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 0x1.AE89F995AD3AEp-1) - @test pow_rev1(interval(2.0,Inf), interval(0.25,0.5), entireinterval()) === interval(0.5, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.25,0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 1.0) - @test pow_rev1(interval(2.0,4.0), interval(0.25,1.0), entireinterval()) === interval(0.5, 1.0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 1.0) - @test pow_rev1(interval(2.0,4.0), interval(1.0,1.0), entireinterval()) === interval(1.0, 1.0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 1.0) - @test pow_rev1(interval(2.0,Inf), interval(0.25,1.0), entireinterval()) === interval(0.5, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.25,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 1.0) - @test pow_rev1(interval(2.0,Inf), interval(1.0,1.0), entireinterval()) === interval(1.0, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(1.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 1.0) - @test pow_rev1(interval(2.0,4.0), interval(0.0,1.0), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(2.0,Inf), interval(0.0,1.0), entireinterval()) === interval(0.0, 1.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.0,1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev1(interval(2.0,4.0), interval(0.0,2.0), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,4.0), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(2.0,4.0), interval(-Inf,2.0), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,4.0), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(2.0,Inf), interval(0.0,2.0), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,Inf), interval(0.0,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(2.0,Inf), interval(-Inf,2.0), entireinterval()) === interval(0.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(-Inf,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,Inf), interval(-Inf,Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(-Inf,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev1(interval(2.0,4.0), interval(0.5,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,4.0), interval(0.5,Inf), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(2.0,Inf), interval(0.5,2.0), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.5,2.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,Inf), interval(0.5,Inf), entireinterval()) === interval(0x1.6A09E667F3BCCp-1, Inf) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(0.5,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0x1.6A09E667F3BCCp-1, Inf) - @test pow_rev1(interval(2.0,4.0), interval(1.0,2.0), entireinterval()) === interval(1.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,4.0), interval(1.0,Inf), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(2.0,Inf), interval(1.0,2.0), entireinterval()) === interval(1.0, 0x1.6A09E667F3BCDp0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(1.0,2.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 0x1.6A09E667F3BCDp0) - @test pow_rev1(interval(2.0,Inf), interval(1.0,Inf), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(1.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev1(interval(2.0,4.0), interval(2.0,4.0), entireinterval()) === interval(0x1.306FE0A31B715p0, 2.0) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, 2.0) - @test pow_rev1(interval(2.0,4.0), interval(2.0,Inf), entireinterval()) === interval(0x1.306FE0A31B715p0, Inf) + @test pow_rev1(bareinterval(2.0,4.0), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(0x1.306FE0A31B715p0, Inf) - @test pow_rev1(interval(2.0,Inf), interval(2.0,4.0), entireinterval()) === interval(1.0, 2.0) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(2.0,4.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, 2.0) - @test pow_rev1(interval(2.0,Inf), interval(2.0,Inf), entireinterval()) === interval(1.0, Inf) + @test pow_rev1(bareinterval(2.0,Inf), bareinterval(2.0,Inf), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) end @testset "minimal.powRev2_test" begin - @test pow_rev2(emptyinterval(), emptyinterval(), emptyinterval()) === emptyinterval() + @test pow_rev2(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(emptyinterval(), entireinterval(), emptyinterval()) === emptyinterval() + @test pow_rev2(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(entireinterval(), emptyinterval(), emptyinterval()) === emptyinterval() + @test pow_rev2(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(entireinterval(), entireinterval(), emptyinterval()) === emptyinterval() + @test pow_rev2(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(emptyinterval(), emptyinterval(), entireinterval()) === emptyinterval() + @test pow_rev2(emptyinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(emptyinterval(), entireinterval(), entireinterval()) === emptyinterval() + @test pow_rev2(emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(entireinterval(), emptyinterval(), entireinterval()) === emptyinterval() + @test pow_rev2(entireinterval(BareInterval{Float64}), emptyinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(entireinterval(), entireinterval(), entireinterval()) === entireinterval() + @test pow_rev2(entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 0.0), interval(-Inf, -0.1), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(0.0, 0.0), bareinterval(-Inf, -0.1), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 0.0), interval(0.1, Inf), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(0.0, 0.0), bareinterval(0.1, Inf), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 0.0), interval(0.0, 0.0), interval(-Inf, 0.0)) === emptyinterval() + @test pow_rev2(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(-Inf, 0.9), interval(0.0, 0.9), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(-Inf, 0.9), bareinterval(0.0, 0.9), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.1, Inf), interval(1.1, Inf), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(1.1, Inf), bareinterval(1.1, Inf), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(-Inf, 0.9), interval(1.1, Inf), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(-Inf, 0.9), bareinterval(1.1, Inf), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.1, Inf), interval(0.0, 0.9), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(1.1, Inf), bareinterval(0.0, 0.9), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 0.0), interval(0.0, 0.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 0.0), bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(-Inf, 0.0), interval(-Inf, 0.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(-Inf, 0.0), interval(-Inf, 0.0), interval(1.0, 2.0)) === interval(1.0, 2.0) + @test_broken pow_rev2(bareinterval(-Inf, 0.0), bareinterval(-Inf, 0.0), bareinterval(1.0, 2.0)) === bareinterval(1.0, 2.0) - @test_broken pow_rev2(entireinterval(), interval(0.0, 0.0), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev2(entireinterval(BareInterval{Float64}), bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(entireinterval(), interval(-Inf, 0.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(entireinterval(), interval(-Inf, 0.0), interval(1.0, 2.0)) === interval(1.0, 2.0) + @test_broken pow_rev2(entireinterval(BareInterval{Float64}), bareinterval(-Inf, 0.0), bareinterval(1.0, 2.0)) === bareinterval(1.0, 2.0) - @test_broken pow_rev2(interval(0.0, 0.0), entireinterval(), entireinterval()) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 0.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(-Inf, 0.0), entireinterval(), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(-Inf, 0.0), entireinterval(BareInterval{Float64}), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(-Inf, 0.0), entireinterval(), interval(1.0, 2.0)) === interval(1.0, 2.0) + @test_broken pow_rev2(bareinterval(-Inf, 0.0), entireinterval(BareInterval{Float64}), bareinterval(1.0, 2.0)) === bareinterval(1.0, 2.0) - @test_broken pow_rev2(interval(1.0, 1.0), entireinterval(), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64}), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(1.0, 1.0), interval(2.0, 3.0)) === interval(2.0, 3.0) + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(1.0, 1.0), bareinterval(2.0, 3.0)) === bareinterval(2.0, 3.0) - @test_broken pow_rev2(entireinterval(), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(entireinterval(BareInterval{Float64}), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(entireinterval(), interval(1.0, 1.0), interval(2.0, 3.0)) === interval(2.0, 3.0) + @test_broken pow_rev2(entireinterval(BareInterval{Float64}), bareinterval(1.0, 1.0), bareinterval(2.0, 3.0)) === bareinterval(2.0, 3.0) - @test pow_rev2(interval(2.0, 3.0), interval(1.0, 1.0), entireinterval()) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, 3.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(2.0, 3.0), interval(1.0, 1.0), interval(2.0, 3.0)) === emptyinterval() + @test pow_rev2(bareinterval(2.0, 3.0), bareinterval(1.0, 1.0), bareinterval(2.0, 3.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 0.5), interval(0.0, 0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 0.5), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 0.5), interval(0.0, 0.5), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 0.5), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 0.5), interval(0.25, 0.5), entireinterval()) === interval(0.0, 2.0) + @test_broken pow_rev2(bareinterval(0.0, 0.5), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 2.0) - @test_broken pow_rev2(interval(0.0, 0.25), interval(0.5, 1.0), entireinterval()) === interval(0.0, 0.5) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.5) - @test pow_rev2(interval(0.0, 0.25), interval(1.0, 1.0), entireinterval()) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(0.0, 0.25), interval(0.0, 1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 0.25), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(0.0, 0.0) - @test_broken pow_rev2(interval(0.0, 0.25), interval(0.0, 2.0), entireinterval()) === interval(-0.5, Inf) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-0.5, Inf) - @test pow_rev2(interval(0.0, 0.25), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 0.25), interval(0.5, 2.0), entireinterval()) === interval(-0.5, 0.5) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-0.5, 0.5) - @test_broken pow_rev2(interval(0.0, 0.25), interval(0.5, Inf), entireinterval()) === interval(-Inf, 0.5) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.5) - @test_broken pow_rev2(interval(0.0, 0.25), interval(1.0, 2.0), entireinterval()) === interval(-0.5, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-0.5, 0.0) - @test pow_rev2(interval(0.0, 0.25), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(0.0, 0.25), interval(1.0, Inf), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 0.25), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, 0.0) - @test_broken pow_rev2(interval(0.0, 0.25), interval(2.0, 4.0), entireinterval()) === interval(-1.0, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 0.0) - @test_broken pow_rev2(interval(0.0, 0.25), interval(2.0, 4.0), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 0.25), interval(2.0, Inf), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 0.25), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 0.25), interval(2.0, Inf), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 0.25), bareinterval(2.0, Inf), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.0, 0.5), entireinterval()) === interval(0.5, Inf) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, Inf) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.25, 0.5), entireinterval()) === interval(0.5, 2.0) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 2.0) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.5, 1.0), entireinterval()) === interval(0.0, 1.0) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev2(interval(0.25, 0.5), interval(1.0, 1.0), entireinterval()) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.25, 0.5), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(0.25, 0.5), interval(0.0, 1.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.25, 0.5), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(0.0, 0.0) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.0, 2.0), entireinterval()) === interval(-1.0, Inf) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, Inf) - @test pow_rev2(interval(0.25, 0.5), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.5, 2.0), entireinterval()) === interval(-1.0, 1.0) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 1.0) - @test_broken pow_rev2(interval(0.25, 0.5), interval(0.5, Inf), entireinterval()) === interval(-Inf, 1.0) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 1.0) - @test_broken pow_rev2(interval(0.25, 0.5), interval(1.0, 2.0), entireinterval()) === interval(-1.0, 0.0) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 0.0) - @test pow_rev2(interval(0.25, 0.5), interval(1.0, Inf), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.25, 0.5), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.25, 0.5), interval(2.0, 4.0), entireinterval()) === interval(-2.0, -0.5) + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(-2.0, -0.5) - @test_broken pow_rev2(interval(0.25, 0.5), interval(2.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 0.5), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(0.0, 0.5), entireinterval()) === interval(0.5, Inf) + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, Inf) - @test pow_rev2(interval(1.0, 1.0), interval(0.0, 0.5), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(0.25, 0.5), entireinterval()) === interval(0.5, Inf) + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.5, Inf) - @test pow_rev2(interval(1.0, 1.0), interval(0.25, 0.5), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.25, 1.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.25, 1.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.25, 1.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.25, 1.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.25, 1.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 1.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 1.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(2.0, 4.0), entireinterval()) === interval(-Inf, -0.5) + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, -0.5) - @test pow_rev2(interval(1.0, 1.0), interval(2.0, 4.0), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 1.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.25, 1.0), interval(2.0, Inf), entireinterval()) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.25, 1.0), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 1.0), interval(2.0, Inf), entireinterval()) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 1.0), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.0, 0.5), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(0.25, 0.5), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.25, 0.5), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.25, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 1.0), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(1.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 1.0), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 1.0), interval(2.0, 4.0), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(2.0, 4.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 1.0), interval(2.0, 4.0), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 1.0), interval(2.0, Inf), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 1.0), interval(2.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 1.0), interval(2.0, Inf), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(0.0, 1.0), bareinterval(2.0, Inf), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 2.0), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.25, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 2.0), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.25, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.25, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.25, 0.5), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, 2.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 2.0), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, 2.0), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.0, Inf), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, Inf), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.0, Inf), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, 2.0), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(1.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(1.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(2.0, 4.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(2.0, 4.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 2.0), interval(2.0, 4.0), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(2.0, 4.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(2.0, 4.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(2.0, 4.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.0, 2.0), interval(2.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, 2.0), interval(2.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.0, 2.0), interval(2.0, Inf), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.0, 2.0), bareinterval(2.0, Inf), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.0, Inf), interval(2.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.0, Inf), interval(2.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.0, Inf), interval(2.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.0, Inf), bareinterval(2.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, 2.0), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test_broken pow_rev2(interval(0.5, 2.0), interval(0.0, 0.5), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.5, Inf), interval(0.0, 0.5), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.25, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, 2.0), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test_broken pow_rev2(interval(0.5, 2.0), interval(0.25, 0.5), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.25, 0.5), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.5, Inf), interval(0.25, 0.5), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, 2.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.5, 2.0), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.5, 2.0), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, Inf), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(0.5, Inf), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(0.5, Inf), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, 2.0), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(1.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(0.5, Inf), interval(1.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(0.5, Inf), interval(1.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(1.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(0.5, 2.0), interval(2.0, 4.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, 2.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, 2.0), interval(2.0, 4.0), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test_broken pow_rev2(interval(0.5, 2.0), interval(2.0, 4.0), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(0.5, 2.0), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(0.5, Inf), interval(2.0, 4.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(0.5, Inf), interval(2.0, 4.0), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(0.5, Inf), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test pow_rev2(interval(0.5, Inf), interval(2.0, 4.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(0.5, Inf), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.0, 0.5), entireinterval()) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, -1.0) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, 0.5), interval(0.0, Inf)) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 0.5), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 0.5), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.0, 0.5), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.25, 0.5), entireinterval()) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, -1.0) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, -1.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, -1.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.25, 0.5), interval(0.0, Inf)) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.25, 0.5), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.25, 0.5), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.25, 0.5), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.25, 0.5), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.5, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.5, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.5, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, 2.0), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.0, 1.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 1.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 1.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(0.0, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.0, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.0, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.0, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(0.5, 2.0), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.5, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.5, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 2.0), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(0.5, Inf), entireinterval()) === entireinterval() + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test pow_rev2(interval(1.0, Inf), interval(0.5, Inf), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, Inf), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, Inf), interval(0.5, Inf), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(0.5, Inf), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, Inf), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, Inf), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, 2.0), entireinterval()) === entireinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === entireinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(1.0, Inf), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(-Inf, 0.0) + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(1.0, 2.0), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(1.0, 2.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(1.0, 2.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(1.0, 2.0), interval(2.0, 4.0), entireinterval()) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(1.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(2.0, 4.0), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test pow_rev2(interval(1.0, 2.0), interval(2.0, 4.0), interval(-Inf, 0.0)) === emptyinterval() + @test pow_rev2(bareinterval(1.0, 2.0), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, Inf), interval(2.0, 4.0), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(1.0, Inf), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(1.0, 2.0), interval(2.0, 4.0), interval(0.0, Inf)) === interval(1.0, Inf) + @test_broken pow_rev2(bareinterval(1.0, 2.0), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(1.0, Inf) - @test pow_rev2(interval(1.0, Inf), interval(2.0, 4.0), interval(0.0, Inf)) === interval(0.0, Inf) + @test pow_rev2(bareinterval(1.0, Inf), bareinterval(2.0, 4.0), bareinterval(0.0, Inf)) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(2.0, 4.0), interval(0.0, 0.5), entireinterval()) === interval(-Inf, -0.5) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, -0.5) - @test pow_rev2(interval(2.0, Inf), interval(0.0, 0.5), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(0.0, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.0, 0.5), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.0, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(2.0, 4.0), interval(0.25, 0.5), entireinterval()) === interval(-2.0, -0.5) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-2.0, -0.5) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.25, 0.5), entireinterval()) === interval(-2.0, 0.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.25, 0.5), entireinterval(BareInterval{Float64})) === bareinterval(-2.0, 0.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.25, 0.5), interval(0.0, Inf)) === emptyinterval() + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.25, 0.5), bareinterval(0.0, Inf)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(2.0, 4.0), interval(0.5, 1.0), entireinterval()) === interval(-1.0, 0.0) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 0.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.5, 1.0), entireinterval()) === interval(-1.0, 0.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.5, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 0.0) - @test pow_rev2(interval(2.0, 4.0), interval(1.0, 1.0), entireinterval()) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, 4.0), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(2.0, Inf), interval(1.0, 1.0), entireinterval()) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(1.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(2.0, 4.0), interval(0.0, 1.0), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(2.0, Inf), interval(0.0, 1.0), entireinterval()) === interval(-Inf, 0.0) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(0.0, 1.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 0.0) - @test pow_rev2(interval(2.0, 4.0), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(2.0, Inf), interval(0.0, 1.0), interval(0.0, Inf)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(0.0, 1.0), bareinterval(0.0, Inf)) === bareinterval(0.0, 0.0) - @test_broken pow_rev2(interval(2.0, 4.0), interval(0.0, 2.0), entireinterval()) === interval(-Inf, 1.0) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 1.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.0, 2.0), entireinterval()) === interval(-Inf, 1.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-Inf, 1.0) - @test_broken pow_rev2(interval(2.0, 4.0), interval(0.5, 2.0), entireinterval()) === interval(-1.0, 1.0) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 1.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(0.5, 2.0), entireinterval()) === interval(-1.0, 1.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(0.5, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(-1.0, 1.0) - @test_broken pow_rev2(interval(2.0, 4.0), interval(1.0, 2.0), entireinterval()) === interval(0.0, 1.0) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(1.0, 2.0), entireinterval()) === interval(0.0, 1.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(1.0, 2.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 1.0) - @test pow_rev2(interval(2.0, 4.0), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, 4.0), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(0.0, 0.0) - @test pow_rev2(interval(2.0, Inf), interval(1.0, 2.0), interval(-Inf, 0.0)) === interval(0.0, 0.0) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(1.0, 2.0), bareinterval(-Inf, 0.0)) === bareinterval(0.0, 0.0) - @test_broken pow_rev2(interval(2.0, 4.0), interval(2.0, 4.0), entireinterval()) === interval(0.5, 2.0) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.5, 2.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(2.0, 4.0), entireinterval()) === interval(0.0, 2.0) + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(2.0, 4.0), entireinterval(BareInterval{Float64})) === bareinterval(0.0, 2.0) - @test_broken pow_rev2(interval(2.0, Inf), interval(2.0, 4.0), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(2.0, 4.0), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) - @test_broken pow_rev2(interval(2.0, 4.0), interval(2.0, Inf), entireinterval()) === interval(0.5, Inf) + @test_broken pow_rev2(bareinterval(2.0, 4.0), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.5, Inf) - @test pow_rev2(interval(2.0, Inf), interval(2.0, Inf), entireinterval()) === interval(0.0, Inf) + @test pow_rev2(bareinterval(2.0, Inf), bareinterval(2.0, Inf), entireinterval(BareInterval{Float64})) === bareinterval(0.0, Inf) - @test_broken pow_rev2(interval(2.0, Inf), interval(2.0, Inf), interval(-Inf, 0.0)) === emptyinterval() + @test_broken pow_rev2(bareinterval(2.0, Inf), bareinterval(2.0, Inf), bareinterval(-Inf, 0.0)) === emptyinterval(BareInterval{Float64}) end