From 0bcfe9318dec4bdd20bbdb28490544d5e98272a5 Mon Sep 17 00:00:00 2001 From: Christophe Troestler Date: Tue, 7 Mar 2023 11:44:14 +0100 Subject: [PATCH] Implement two-output division (#89) --- ITF1788 | 2 +- src/_docs/header.html | 2 + src/arith.rs | 84 +- src/basic.rs | 222 ++ src/simd/x86_64.rs | 2 +- tests/itf1788.rs | 2 +- tests/itf1788_tests/libieeep1788_mul_rev.rs | 2788 +++++++++++++++++++ 7 files changed, 3025 insertions(+), 77 deletions(-) create mode 100644 tests/itf1788_tests/libieeep1788_mul_rev.rs diff --git a/ITF1788 b/ITF1788 index d26ec82..52095ff 160000 --- a/ITF1788 +++ b/ITF1788 @@ -1 +1 @@ -Subproject commit d26ec82c9aef926c687e9f31c4f8efac12a2eb23 +Subproject commit 52095ffa7a3d7d6b1b2943849f2bb050e312f82a diff --git a/src/_docs/header.html b/src/_docs/header.html index 192eb3e..dc40552 100644 --- a/src/_docs/header.html +++ b/src/_docs/header.html @@ -110,6 +110,7 @@ "\\set": "{\\left\\{#1\\right\\}}", // enclose in {} to make it mathord "\\sgn": "\\operatorname{sgn}", "\\wid": "\\operatorname{wid}", + "\\setdiv": "\\mathbin{/^\\prime}", // Sets "\\D": "𝔻", "\\DIF": "{𝔻𝕀𝔽}", @@ -141,6 +142,7 @@ "𝒇": "{\\boldsymbol{f}}", "𝒙": "{\\boldsymbol{x}}", "𝒚": "{\\boldsymbol{y}}", + "𝒛": "{\\boldsymbol{z}}", "∅": "\\emptyset ", "∧": "\\mathrel{\\land}", // logical AND "∨": "\\mathrel{\\lor}", // logical OR diff --git a/src/arith.rs b/src/arith.rs index ff68893..bf1564f 100644 --- a/src/arith.rs +++ b/src/arith.rs @@ -154,80 +154,16 @@ impl Div for Interval { | P0_E | P0_Z | P1_E | P1_Z | Z_E | Z_Z => Self::EMPTY, M_M | M_N0 | M_P0 | N0_M | N1_M | P0_M | P1_M => Self::ENTIRE, Z_M | Z_N0 | Z_N1 | Z_P0 | Z_P1 => Self::zero(), - M_N1 => { - // M / N1 => [b/d, a/d] = [-b/d; a/d] = [b/-d; -a/-d] = [b; -a] ./ [-d; -d] - let x = swap(self.rep); // [b; -a] - let y = swap(rhs.rep); // [d; -c] - let y = neg0(y); // [-d; -c] - let y = shuffle02(y, y); // [-d; -d] - Self { rep: div_ru(x, y) } - } - M_P1 => { - // M / P1 => [a/c, b/c] = [-a/c; b/c] = [-a; b] ./ [c; c] - let x = self.rep; // [-a; b] - let y = neg0(rhs.rep); // [c; d] - let y = shuffle02(y, y); // [c; c] - Self { rep: div_ru(x, y) } - } - N0_N0 | N1_N0 => { - // N / N0 => [b/c, +∞] = [-b/c; +∞] = [b/-c; +∞] - let x = swap(self.rep); // [b; -a] - let y = rhs.rep; // [-c; d] - Self { - rep: shuffle02(div_ru(x, y), splat(f64::INFINITY)), - } - } - N0_N1 | N1_N1 => { - // N / N1 => [b/c, a/d] = [-b/c; a/d] = [b/-c; a/d] = [b; a] ./ [-c; d] - let x = neg0(self.rep); // [a; b] - let x = swap(x); // [b; a] - let y = rhs.rep; // [-c; d] - Self { rep: div_ru(x, y) } - } - N0_P0 | N1_P0 => { - // N / P0 => [-∞, b/d] = [+∞; b/d] - let x = self.rep; // [-a; b] - let y = rhs.rep; // [-c; d] - Self { - rep: shuffle03(splat(f64::INFINITY), div_ru(x, y)), - } - } - N0_P1 | N1_P1 => { - // N / P1 => [a/c, b/d] = [-a/c; b/d] = [-a; b] ./ [c; d] - let x = self.rep; // [-a; b] - let y = neg0(rhs.rep); // [c; d] - Self { rep: div_ru(x, y) } - } - P0_N0 | P1_N0 => { - // P / N0 => [-∞, a/c] = [+∞; a/c] = [+∞; -a/-c] - let x = self.rep; // [-a; b] - let y = rhs.rep; // [-c; d] - Self { - rep: shuffle02(splat(f64::INFINITY), div_ru(x, y)), - } - } - P0_N1 | P1_N1 => { - // P / N1 => [b/d, a/c] = [-b/d; a/c] = [-b/d; -a/-c] = [-b; -a] ./ [d; -c] - let x = swap(self.rep); // [b; -a] - let x = neg0(x); // [-b; -a] - let y = swap(rhs.rep); // [d; -c] - Self { rep: div_ru(x, y) } - } - P0_P0 | P1_P0 => { - // P / P0 => [a/d, +∞] = [-a/d; +∞] - let x = self.rep; // [-a; b] - let y = swap(rhs.rep); // [d; -c] - Self { - rep: shuffle02(div_ru(x, y), splat(f64::INFINITY)), - } - } - P0_P1 | P1_P1 => { - // P / P1 => [a/d, b/c] = [-a/d; b/c] = [-a; b] ./ [d; c] - let x = self.rep; // [-a; b] - let y = neg0(rhs.rep); // [c; d] - let y = swap(y); // [d; c] - Self { rep: div_ru(x, y) } - } + M_N1 => self.div_m_n1(rhs), + M_P1 => self.div_m_p1(rhs), + N0_N0 | N1_N0 => self.div_n_n0(rhs), + N0_N1 | N1_N1 => self.div_n_n1(rhs), + N0_P0 | N1_P0 => self.div_n_p0(rhs), + N0_P1 | N1_P1 => self.div_n_p1(rhs), + P0_N0 | P1_N0 => self.div_p_n0(rhs), + P0_N1 | P1_N1 => self.div_p_n1(rhs), + P0_P0 | P1_P0 => self.div_p_p0(rhs), + P0_P1 | P1_P1 => self.div_p_p1(rhs), } } } diff --git a/src/basic.rs b/src/basic.rs index adcedf4..b55b172 100644 --- a/src/basic.rs +++ b/src/basic.rs @@ -4,6 +4,192 @@ use std::{cmp::Ordering, unreachable}; // NOTE: `neg`, `add`, `sub`, `mul` and `div` are implemented in arith.rs impl Interval { + // Division functions [a, b] / [c, d] for various cases, shared + // between `mul_rev_to_pair` (below) and `Div` (in arith.rs). + #[inline] + pub(crate) fn div_m_n1(self, rhs: Self) -> Self { + // M / N1 => [b/d, a/d] = [-b/d; a/d] = [b/-d; -a/-d] = [b; -a] ./ [-d; -d] + let x = swap(self.rep); // [b; -a] + let y = swap(rhs.rep); // [d; -c] + let y = neg0(y); // [-d; -c] + let y = shuffle02(y, y); // [-d; -d] + Self { rep: div_ru(x, y) } + } + + #[inline] + pub(crate) fn div_m_p1(self, rhs: Self) -> Self { + // M / P1 => [a/c, b/c] = [-a/c; b/c] = [-a; b] ./ [c; c] + let x = self.rep; // [-a; b] + let y = neg0(rhs.rep); // [c; d] + let y = shuffle02(y, y); // [c; c] + Self { rep: div_ru(x, y) } + } + + #[inline] + pub(crate) fn div_n_n0(self, rhs: Self) -> Self { + // N / N0 => [b/c, +∞] = [-b/c; +∞] = [b/-c; +∞] + let x = swap(self.rep); // [b; -a] + let y = rhs.rep; // [-c; d] + Self { + rep: shuffle02(div_ru(x, y), splat(f64::INFINITY)), + } + } + + #[inline] + pub(crate) fn div_n_n1(self, rhs: Self) -> Self { + // N / N1 => [b/c, a/d] = [-b/c; a/d] = [b/-c; a/d] = [b; a] ./ [-c; d] + let x = neg0(self.rep); // [a; b] + let x = swap(x); // [b; a] + let y = rhs.rep; // [-c; d] + Self { rep: div_ru(x, y) } + } + + #[inline] + pub(crate) fn div_n_p0(self, rhs: Self) -> Self { + // N / P0 => [-∞, b/d] = [+∞; b/d] + let x = self.rep; // [-a; b] + let y = rhs.rep; // [-c; d] + Self { + rep: shuffle03(splat(f64::INFINITY), div_ru(x, y)), + } + } + + #[inline] + pub(crate) fn div_n_p1(self, rhs: Self) -> Self { + // N / P1 => [a/c, b/d] = [-a/c; b/d] = [-a; b] ./ [c; d] + let x = self.rep; // [-a; b] + let y = neg0(rhs.rep); // [c; d] + Self { rep: div_ru(x, y) } + } + + #[inline] + pub(crate) fn div_p_n0(self, rhs: Self) -> Self { + // P / N0 => [-∞, a/c] = [+∞; a/c] = [+∞; -a/-c] + let x = self.rep; // [-a; b] + let y = rhs.rep; // [-c; d] + Self { + rep: shuffle02(splat(f64::INFINITY), div_ru(x, y)), + } + } + + #[inline] + pub(crate) fn div_p_n1(self, rhs: Self) -> Self { + // P / N1 => [b/d, a/c] = [-b/d; a/c] = [-b/d; -a/-c] = [-b; -a] ./ [d; -c] + let x = swap(self.rep); // [b; -a] + let x = neg0(x); // [-b; -a] + let y = swap(rhs.rep); // [d; -c] + Self { rep: div_ru(x, y) } + } + + #[inline] + pub(crate) fn div_p_p0(self, rhs: Self) -> Self { + // P / P0 => [a/d, +∞] = [-a/d; +∞] + let x = self.rep; // [-a; b] + let y = swap(rhs.rep); // [d; -c] + Self { + rep: shuffle02(div_ru(x, y), splat(f64::INFINITY)), + } + } + + #[inline] + pub(crate) fn div_p_p1(self, rhs: Self) -> Self { + // P / P1 => [a/d, b/c] = [-a/d; b/c] = [-a; b] ./ [d; c] + let x = self.rep; // [-a; b] + let y = neg0(rhs.rep); // [c; d] + let y = swap(y); // [d; c] + Self { rep: div_ru(x, y) } + } + + /// Return the two-output reverse multiplication: + /// `numerator`$\setdiv \self$ (also called *two-output division* + /// in the IEEE 1788 standard). + /// + /// The set-division of two intervals $𝒙$ and $𝒚$ is defined as + /// $$𝒙 \setdiv 𝒚 := \set{z ∈ \R ∣ ∃y ∈ 𝒚,\ zy ∈ 𝒙}.$$ + /// Let us distinguish several cases. + /// - If $𝒙$ or $𝒚$ is empty, $𝒙 \setdiv 𝒚 = ∅$. Thus if `self` + /// or `numerator` is empty, this function returns `[EMPTY, EMPTY]`. + /// - If $0 ∉ 𝒚$, $𝒙 \setdiv 𝒚$ is a single interval $𝒛$ which + /// coincides with the standard interval division $𝒙 / 𝒚$. Then + /// $𝒚$`.mul_rev_to_pair`($𝒙$) returns `[z, EMPTY]` where `z` is + /// an encosure of $𝒛$. + /// - If $0 ∈ 𝒚$ and $0 ∉ 𝒙$, $𝒙 \setdiv 𝒚$ is a made of two + /// intervals $𝒛₁ ∪ 𝒛₂$. The standard division $𝒙 / 𝒚$ returns + /// the interval enclosure of the result, namely $ℝ$. Here, + /// $𝒚$`.mul_rev_to_pair`($𝒙$) returns $[𝒛₁, 𝒛₂]$ ordered such + /// that $𝒛₁ < 𝒛₂$. + /// - If $0 ∈ 𝒚$ and $0 ∈ 𝒙$, $𝒙 \setdiv 𝒚 = ℝ$. Accordingly, + /// $𝒚$`.mul_rev_to_pair`($𝒙$) return `[ENTIRE, EMPTY]`. + /// + /// # Examples + /// + /// ``` + /// use inari::{Interval as I, const_interval as c}; + /// let zero = c!(0., 0.); + /// assert_eq!(zero.mul_rev_to_pair(c!(1., 2.)), [I::EMPTY; 2]); + /// assert_eq!(zero.mul_rev_to_pair(c!(0., 2.)), [I::ENTIRE, I::EMPTY]); + /// assert_eq!(zero.mul_rev_to_pair(zero), [I::ENTIRE, I::EMPTY]); + /// let x = c!(1., 2.); + /// assert_eq!(I::ENTIRE.mul_rev_to_pair(x), [c!(f64::NEG_INFINITY, 0.0), c!(0.0, f64::INFINITY)]); + /// assert_eq!(c!(1., 1.).mul_rev_to_pair(x), [x, I::EMPTY]); + /// assert_eq!(c!(1., f64::INFINITY).mul_rev_to_pair(c!(1., 1.)), + /// [c!(0., 1.), I::EMPTY]); + /// assert_eq!(c!(-1., 1.).mul_rev_to_pair(c!(1., 2.)), + /// [c!(f64::NEG_INFINITY, -1.), c!(1., f64::INFINITY)]); + /// assert_eq!(c!(-1., 1.).mul_rev_to_pair(zero), [I::ENTIRE, I::EMPTY]); + /// ``` + #[must_use] + pub fn mul_rev_to_pair(self, numerator: Self) -> [Self; 2] { + use IntervalClass2::*; + match numerator.classify2(self) { + E_E | E_M | E_N0 | E_N1 | E_P0 | E_P1 | E_Z | M_E | N0_E | N1_E | N1_Z | P0_E + | P1_E | P1_Z | Z_E => [Self::EMPTY; 2], + M_Z | N0_Z | P0_Z | Z_Z | M_M | M_N0 | M_P0 | N0_M | P0_M | Z_M | Z_N0 | Z_P0 + | N0_N0 | N0_P0 | P0_N0 | P0_P0 => [Self::ENTIRE, Self::EMPTY], + Z_N1 | Z_P1 => [Self::zero(), Self::EMPTY], + N1_M => { + // N1 / M => [-∞, b/d] ∪ [b/c, +∞] = [+∞; b/d] ∪ [-b/c; +∞] + // [-b/c, b/d] = [b; b] ./ [-c; d] + let x = numerator.rep; // [-a; b] + let x = shuffle13(x, x); // [b; b] + let q = div_ru(x, self.rep); // [b/(-c); b/d] + [ + Self { + rep: shuffle13(splat(f64::INFINITY), q), + }, + Self { + rep: shuffle02(q, splat(f64::INFINITY)), + }, + ] + } + P1_M => { + // P1 / M => [-∞, a/c] ∪ [a/d, +∞] = [+∞; a/c] ∪ [-a/d; +∞] + // [a/c; -a/d] = [-a; -a] ./ [-c; d] + let x = numerator.rep; // [-a; b] + let x = shuffle02(x, x); // [-a; -a] + let q = div_ru(x, self.rep); // [a/c; -a/d] + [ + Self { + rep: shuffle02(splat(f64::INFINITY), q), + }, + Self { + rep: shuffle13(q, splat(f64::INFINITY)), + }, + ] + } + M_N1 => [numerator.div_m_n1(self), Self::EMPTY], + M_P1 => [numerator.div_m_p1(self), Self::EMPTY], + N1_N0 => [numerator.div_n_n0(self), Self::EMPTY], + N0_N1 | N1_N1 => [numerator.div_n_n1(self), Self::EMPTY], + N1_P0 => [numerator.div_n_p0(self), Self::EMPTY], + N0_P1 | N1_P1 => [numerator.div_n_p1(self), Self::EMPTY], + P1_N0 => [numerator.div_p_n0(self), Self::EMPTY], + P0_N1 | P1_N1 => [numerator.div_p_n1(self), Self::EMPTY], + P1_P0 => [numerator.div_p_p0(self), Self::EMPTY], + P0_P1 | P1_P1 => [numerator.div_p_p1(self), Self::EMPTY], + } + } + /// Returns the tightest interval `z` such that `rhs` $+$ `z` $⊇$ `self`, /// if both `self` and `rhs` are bounded and the width of `self` is greater than or equal to /// that of `rhs`. Otherwise, returns [`Interval::ENTIRE`]. @@ -383,6 +569,28 @@ impl Interval { } impl DecInterval { + /// The decorated version of [`Interval::mul_rev_to_pair`]. + /// + /// The array `[Self::NAI, Self::NAI]` is returned if `self` or + /// `numerator` is NaI. When neither `self` nor `numerator` are + /// empty and $0 ∉ \self ,$ `[z,`[`Self::EMPTY`]`]` is returned + /// with `z` being the same as `numerator / self` and is decorated + /// the same way. In all other cases, both output are decorated + /// with [`Trv`](Decoration::Trv). + #[must_use] + pub fn mul_rev_to_pair(self, numerator: Self) -> [Self; 2] { + if self.is_nai() || numerator.is_nai() { + return [Self::NAI; 2]; + } + let [u, v] = self.x.mul_rev_to_pair(numerator.x); + let d = if self.x.contains(0.0) { + Decoration::Trv + } else { + self.d.min(numerator.d) + }; + [Self::set_dec(u, d), Self::set_dec(v, Decoration::Trv)] + } + /// The decorated version of [`Interval::cancel_minus`]. /// /// A NaI is returned if `self` or `rhs` is NaI. @@ -503,6 +711,20 @@ mod tests { assert!(DI::NAI.sqr().is_nai()); } + #[test] + fn mul_rev_to_pair() { + let zero = const_interval!(0., 0.); + assert_eq!(zero.mul_rev_to_pair(const_interval!(1., 2.)), [I::EMPTY; 2]); + let pos = const_interval!(0., f64::INFINITY); + let neg = const_interval!(f64::NEG_INFINITY, 0.); + assert_eq!( + I::ENTIRE.mul_rev_to_pair(const_interval!(1., 1.)), + [neg, pos] + ); + assert_eq!(pos.mul_rev_to_pair(pos), [I::ENTIRE, I::EMPTY]); + assert_eq!(neg.mul_rev_to_pair(pos), [I::ENTIRE, I::EMPTY]); + } + #[test] fn cancel_minus() { assert_eq!( diff --git a/src/simd/x86_64.rs b/src/simd/x86_64.rs index 93fc4e0..16c2c3e 100644 --- a/src/simd/x86_64.rs +++ b/src/simd/x86_64.rs @@ -154,7 +154,7 @@ pub(crate) fn trunc(x: F64X2) -> F64X2 { unsafe { _mm_round_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) } } -/// `shuffle13([x0, x1], [x2, x3]) = [x1, x2]` +/// `shuffle12([x0, x1], [x2, x3]) = [x1, x2]` fn shuffle12(x: F64X2, y: F64X2) -> F64X2 { unsafe { _mm_shuffle_pd(x, y, 1) } } diff --git a/tests/itf1788.rs b/tests/itf1788.rs index fcd5d0a..fc85f58 100644 --- a/tests/itf1788.rs +++ b/tests/itf1788.rs @@ -19,7 +19,7 @@ mod itf1788_tests { mod libieeep1788_cancel; mod libieeep1788_class; mod libieeep1788_elem; - //mod libieeep1788_mul_rev; + mod libieeep1788_mul_rev; mod libieeep1788_num; mod libieeep1788_overlap; mod libieeep1788_rec_bool; diff --git a/tests/itf1788_tests/libieeep1788_mul_rev.rs b/tests/itf1788_tests/libieeep1788_mul_rev.rs new file mode 100644 index 0000000..493cc47 --- /dev/null +++ b/tests/itf1788_tests/libieeep1788_mul_rev.rs @@ -0,0 +1,2788 @@ +/* + * + * Unit tests from libieeep1788 for interval reverse multiplication + * (Original author: Marco Nehmeier) + * converted into portable ITL format by Oliver Heimlich. + * + * Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) + * Copyright 2015-2017 Oliver Heimlich (oheim@posteo.de) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +//Language imports + +//Test library imports + +//Arithmetic library imports + +//Preamble +use crate::*; +use inari::{DecInterval as DI, Decoration as D, Interval as I, Overlap as O}; + +#[test] +fn minimal_mulrevtopair_test() { + assert_eq2!(I::EMPTY.mul_rev_to_pair(n2i(1.0, 2.0))[0], I::EMPTY); + assert_eq2!(I::EMPTY.mul_rev_to_pair(n2i(1.0, 2.0))[1], I::EMPTY); + assert_eq2!(n2i(1.0, 2.0).mul_rev_to_pair(I::EMPTY)[0], I::EMPTY); + assert_eq2!(n2i(1.0, 2.0).mul_rev_to_pair(I::EMPTY)[1], I::EMPTY); + assert_eq2!(I::EMPTY.mul_rev_to_pair(I::EMPTY)[0], I::EMPTY); + assert_eq2!(I::EMPTY.mul_rev_to_pair(I::EMPTY)[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(0.2, 21.0) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(0.2, f64::INFINITY) + ); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, -0.3636363636363636) + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + n2i(0.2, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, -0.3636363636363636) + ); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(-210.00000000000003, -0.3636363636363636) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[0], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(0.0, 21.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, -0.3636363636363636) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + n2i(0.2, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(-210.00000000000003, 0.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, -0.4))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(-2.1, -0.4))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(-2.1, -0.4))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + n2i(0.0, 21.0) + ); + assert_eq2!(n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + n2i(-210.00000000000003, 0.0) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + n2i(0.0, 21.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[0], + n2i(-210.00000000000003, 0.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.0))[1], + I::EMPTY + ); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(-2.1, 0.0))[0], I::ENTIRE); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(-2.1, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + n2i(-1.2, 21.0) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + n2i(-210.00000000000003, 12.0) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + n2i(-1.2, 21.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[0], + n2i(-210.00000000000003, 12.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-2.1, 0.12))[1], + I::EMPTY + ); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(-2.1, 0.12))[0], I::ENTIRE); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(-2.1, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], + n2i(-1.2, 0.0) + ); + assert_eq2!(n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], + n2i(0.0, 12.0) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], + n2i(-1.2, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[0], + n2i(0.0, 12.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.12))[1], + I::EMPTY + ); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(0.0, 0.12))[0], I::ENTIRE); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(0.0, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(-1.2, -0.005) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, -0.005) + ); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, -0.005) + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], + n2i(0.009090909090909089, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(0.009090909090909089, f64::INFINITY) + ); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(0.009090909090909089, 12.0) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[0], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(-1.2, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.01, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.01, 0.12))[1], + n2i(0.009090909090909089, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, -0.005) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(0.0, 12.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.01, 0.12))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.01, 0.12))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.01, 0.12))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], + n2i(0.0, 0.0) + ); + assert_eq2!(n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], + n2i(0.0, 0.0) + ); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], + n2i(0.0, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[0], + n2i(0.0, 0.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, 0.0))[1], + I::EMPTY + ); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(0.0, 0.0))[0], I::ENTIRE); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(n2i(0.0, 0.0))[1], I::EMPTY); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(0.05, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(0.05, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, -0.0909090909090909) + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + n2i(0.05, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, -0.0909090909090909) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, -0.0909090909090909) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, -0.0909090909090909) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + n2i(0.05, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, -0.1))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[0], + I::ENTIRE + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.0))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + n2i(-3.0, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + n2i(f64::NEG_INFINITY, 30.0) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + n2i(-3.0, f64::INFINITY) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + n2i(f64::NEG_INFINITY, 30.0) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[0], + I::ENTIRE + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(f64::NEG_INFINITY, 0.3))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 2.1) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + n2i(-21.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 2.1) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + n2i(-21.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(-0.21, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.0, f64::INFINITY))[0], + I::ENTIRE + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.0, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, -0.02) + ); + assert_eq2!( + n2i(-2.0, -0.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, -0.02) + ); + assert_eq2!( + n2i(-2.0, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, -0.02) + ); + assert_eq2!( + n2i(-2.0, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + n2i(0.036363636363636355, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(0.036363636363636355, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(0.036363636363636355, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + n2i(0.036363636363636355, f64::INFINITY) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, -0.02) + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + I::EMPTY + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.04, f64::INFINITY))[0], + n2i(f64::NEG_INFINITY, 0.0) + ); + assert_eq2!( + I::ENTIRE.mul_rev_to_pair(n2i(0.04, f64::INFINITY))[1], + n2i(0.0, f64::INFINITY) + ); + assert_eq2!(n2i(-2.0, -0.1).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, -0.1).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 0.0).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(-2.0, 1.1).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 1.1).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(0.01, 1.1).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(n2i(0.0, 0.0).mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, -0.1).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 0.0).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(f64::NEG_INFINITY, 1.1).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(-2.0, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.0, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[0], + I::ENTIRE + ); + assert_eq2!( + n2i(0.01, f64::INFINITY).mul_rev_to_pair(I::ENTIRE)[1], + I::EMPTY + ); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(I::ENTIRE)[0], I::ENTIRE); + assert_eq2!(I::ENTIRE.mul_rev_to_pair(I::ENTIRE)[1], I::EMPTY); +} + +#[test] +fn minimal_mulrevtopair_dec_test() { + assert_eq2!(DI::NAI.mul_rev_to_pair(nd2di(1.0, 2.0, D::Def))[0], DI::NAI); + assert_eq2!(DI::NAI.mul_rev_to_pair(nd2di(1.0, 2.0, D::Def))[1], DI::NAI); + assert_eq2!(nd2di(1.0, 2.0, D::Com).mul_rev_to_pair(DI::NAI)[0], DI::NAI); + assert_eq2!(nd2di(1.0, 2.0, D::Com).mul_rev_to_pair(DI::NAI)[1], DI::NAI); + assert_eq2!(DI::NAI.mul_rev_to_pair(DI::NAI)[0], DI::NAI); + assert_eq2!(DI::NAI.mul_rev_to_pair(DI::NAI)[1], DI::NAI); + assert_eq2!( + DI::EMPTY.mul_rev_to_pair(nd2di(1.0, 2.0, D::Def))[0], + DI::EMPTY + ); + assert_eq2!( + DI::EMPTY.mul_rev_to_pair(nd2di(1.0, 2.0, D::Def))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(1.0, 2.0, D::Com).mul_rev_to_pair(DI::EMPTY)[0], + DI::EMPTY + ); + assert_eq2!( + nd2di(1.0, 2.0, D::Com).mul_rev_to_pair(DI::EMPTY)[1], + DI::EMPTY + ); + assert_eq2!(DI::EMPTY.mul_rev_to_pair(DI::EMPTY)[0], DI::EMPTY); + assert_eq2!(DI::EMPTY.mul_rev_to_pair(DI::EMPTY)[1], DI::EMPTY); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[0], + nd2di(0.2, 21.0, D::Com) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[0], + nd2di(0.2, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.3636363636363636, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[1], + nd2di(0.2, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Trv).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[0], + nd2di(f64::NEG_INFINITY, -0.3636363636363636, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Trv).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[0], + nd2di(-210.00000000000003, -0.3636363636363636, D::Com) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[0], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[0], + nd2di(0.0, 21.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[0], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Trv).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[0], + nd2di(f64::NEG_INFINITY, -0.3636363636363636, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Trv).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac))[1], + nd2di(0.2, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[0], + nd2di(-210.00000000000003, 0.0, D::Def) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Def))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, -0.4, D::Dac)) + [1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(0.0, 21.0, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(-210.00000000000003, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(0.0, 21.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[0], + nd2di(-210.00000000000003, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-2.1, 0.0, D::Com)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(-1.2, 21.0, D::Def) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(-210.00000000000003, 12.0, D::Def) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(-1.2, 21.0, D::Def) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[0], + nd2di(-210.00000000000003, 12.0, D::Def) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Def).mul_rev_to_pair(nd2di(-2.1, 0.12, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(-1.2, 0.0, D::Com) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(0.0, 12.0, D::Com) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(-1.2, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[0], + nd2di(0.0, 12.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.12, D::Com)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(-1.2, -0.005, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.005, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.005, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + nd2di(0.009090909090909089, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(0.009090909090909089, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(0.009090909090909089, 12.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(-1.2, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + nd2di(0.009090909090909089, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.005, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[0], + nd2di(0.0, 12.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.01, 0.12, D::Dac)) + [1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(0.0, 0.0, D::Com) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(0.0, 0.0, D::Com) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Com).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(0.0, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(0.0, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, 0.0, D::Com))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + nd2di(0.05, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + nd2di(0.05, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.0909090909090909, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + nd2di(0.05, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.0909090909090909, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.0909090909090909, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[0], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[0], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, -0.0909090909090909, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [1], + nd2di(0.05, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, -0.1, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + -0.1, + D::Dac + ))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.0, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.0, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(-3.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 30.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[0], + nd2di(-3.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 30.0, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, 0.3, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + 0.3, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 2.1, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(-21.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 2.1, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[0], + nd2di(-21.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(-0.21, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + -0.21, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + -0.21, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.0, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + 0.0, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + 0.0, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.02, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.02, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.02, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + nd2di(0.036363636363636355, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(0.036363636363636355, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(0.036363636363636355, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac)) + [1], + nd2di(0.036363636363636355, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, -0.02, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[0], + nd2di(0.0, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di(0.04, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + 0.04, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, 0.0, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + 0.04, + f64::INFINITY, + D::Dac + ))[1], + nd2di(0.0, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(-2.0, -0.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, 1.1, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac)) + [1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, 0.0, D::Dac).mul_rev_to_pair(nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, -0.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 0.0, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, 1.1, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(-2.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(0.0, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac) + ); + assert_eq2!( + nd2di(0.01, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[0], + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Trv) + ); + assert_eq2!( + nd2di(f64::NEG_INFINITY, f64::INFINITY, D::Dac).mul_rev_to_pair(nd2di( + f64::NEG_INFINITY, + f64::INFINITY, + D::Dac + ))[1], + DI::EMPTY + ); +}