
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))))
(if (<= (* (* c t_1) i) 1e+207)
(* 2.0 (- (fma x y (* z t)) (* t_1 (* c i))))
(* -2.0 (* c (* t_1 i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double tmp;
if (((c * t_1) * i) <= 1e+207) {
tmp = 2.0 * (fma(x, y, (z * t)) - (t_1 * (c * i)));
} else {
tmp = -2.0 * (c * (t_1 * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) tmp = 0.0 if (Float64(Float64(c * t_1) * i) <= 1e+207) tmp = Float64(2.0 * Float64(fma(x, y, Float64(z * t)) - Float64(t_1 * Float64(c * i)))); else tmp = Float64(-2.0 * Float64(c * Float64(t_1 * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision], 1e+207], N[(2.0 * N[(N[(x * y + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(c * N[(t$95$1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
\mathbf{if}\;\left(c \cdot t\_1\right) \cdot i \leq 10^{+207}:\\
\;\;\;\;2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - t\_1 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(t\_1 \cdot i\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e207Initial program 96.1%
fma-define96.6%
associate-*l*98.5%
Simplified98.5%
if 1e207 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 79.4%
associate--l+79.4%
*-commutative79.4%
associate--l+79.4%
associate--l+79.4%
*-commutative79.4%
associate--l+79.4%
fma-define79.4%
*-commutative79.4%
associate-*l*83.0%
+-commutative83.0%
fma-define83.0%
Simplified83.0%
Taylor expanded in i around inf 90.7%
Final simplification96.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))) (t_2 (* (* c t_1) i)))
(if (<= t_2 -1e+72)
(* 2.0 (- (* x y) t_2))
(if (<= t_2 1e+207)
(* 2.0 (- (+ (* x y) (* z t)) (* a (* c i))))
(* -2.0 (* c (* t_1 i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * t_1) * i;
double tmp;
if (t_2 <= -1e+72) {
tmp = 2.0 * ((x * y) - t_2);
} else if (t_2 <= 1e+207) {
tmp = 2.0 * (((x * y) + (z * t)) - (a * (c * i)));
} else {
tmp = -2.0 * (c * (t_1 * i));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a + (b * c)
t_2 = (c * t_1) * i
if (t_2 <= (-1d+72)) then
tmp = 2.0d0 * ((x * y) - t_2)
else if (t_2 <= 1d+207) then
tmp = 2.0d0 * (((x * y) + (z * t)) - (a * (c * i)))
else
tmp = (-2.0d0) * (c * (t_1 * i))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * t_1) * i;
double tmp;
if (t_2 <= -1e+72) {
tmp = 2.0 * ((x * y) - t_2);
} else if (t_2 <= 1e+207) {
tmp = 2.0 * (((x * y) + (z * t)) - (a * (c * i)));
} else {
tmp = -2.0 * (c * (t_1 * i));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = (c * t_1) * i tmp = 0 if t_2 <= -1e+72: tmp = 2.0 * ((x * y) - t_2) elif t_2 <= 1e+207: tmp = 2.0 * (((x * y) + (z * t)) - (a * (c * i))) else: tmp = -2.0 * (c * (t_1 * i)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(Float64(c * t_1) * i) tmp = 0.0 if (t_2 <= -1e+72) tmp = Float64(2.0 * Float64(Float64(x * y) - t_2)); elseif (t_2 <= 1e+207) tmp = Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(a * Float64(c * i)))); else tmp = Float64(-2.0 * Float64(c * Float64(t_1 * i))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = (c * t_1) * i; tmp = 0.0; if (t_2 <= -1e+72) tmp = 2.0 * ((x * y) - t_2); elseif (t_2 <= 1e+207) tmp = 2.0 * (((x * y) + (z * t)) - (a * (c * i))); else tmp = -2.0 * (c * (t_1 * i)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+72], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+207], N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(a * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(c * N[(t$95$1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := \left(c \cdot t\_1\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+72}:\\
\;\;\;\;2 \cdot \left(x \cdot y - t\_2\right)\\
\mathbf{elif}\;t\_2 \leq 10^{+207}:\\
\;\;\;\;2 \cdot \left(\left(x \cdot y + z \cdot t\right) - a \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(t\_1 \cdot i\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.99999999999999944e71Initial program 91.6%
Taylor expanded in x around inf 87.9%
if -9.99999999999999944e71 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e207Initial program 99.1%
Taylor expanded in a around inf 92.9%
if 1e207 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 79.4%
associate--l+79.4%
*-commutative79.4%
associate--l+79.4%
associate--l+79.4%
*-commutative79.4%
associate--l+79.4%
fma-define79.4%
*-commutative79.4%
associate-*l*83.0%
+-commutative83.0%
fma-define83.0%
Simplified83.0%
Taylor expanded in i around inf 90.7%
Final simplification90.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))) (t_2 (+ (* x y) (* z t))))
(if (<= (- t_2 (* (* c t_1) i)) INFINITY)
(* 2.0 (- t_2 (* t_1 (* c i))))
(* -2.0 (* c (* c (* b i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (x * y) + (z * t);
double tmp;
if ((t_2 - ((c * t_1) * i)) <= ((double) INFINITY)) {
tmp = 2.0 * (t_2 - (t_1 * (c * i)));
} else {
tmp = -2.0 * (c * (c * (b * i)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (x * y) + (z * t);
double tmp;
if ((t_2 - ((c * t_1) * i)) <= Double.POSITIVE_INFINITY) {
tmp = 2.0 * (t_2 - (t_1 * (c * i)));
} else {
tmp = -2.0 * (c * (c * (b * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = (x * y) + (z * t) tmp = 0 if (t_2 - ((c * t_1) * i)) <= math.inf: tmp = 2.0 * (t_2 - (t_1 * (c * i))) else: tmp = -2.0 * (c * (c * (b * i))) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(Float64(x * y) + Float64(z * t)) tmp = 0.0 if (Float64(t_2 - Float64(Float64(c * t_1) * i)) <= Inf) tmp = Float64(2.0 * Float64(t_2 - Float64(t_1 * Float64(c * i)))); else tmp = Float64(-2.0 * Float64(c * Float64(c * Float64(b * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = (x * y) + (z * t); tmp = 0.0; if ((t_2 - ((c * t_1) * i)) <= Inf) tmp = 2.0 * (t_2 - (t_1 * (c * i))); else tmp = -2.0 * (c * (c * (b * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$2 - N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], Infinity], N[(2.0 * N[(t$95$2 - N[(t$95$1 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(c * N[(c * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := x \cdot y + z \cdot t\\
\mathbf{if}\;t\_2 - \left(c \cdot t\_1\right) \cdot i \leq \infty:\\
\;\;\;\;2 \cdot \left(t\_2 - t\_1 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(c \cdot \left(b \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < +inf.0Initial program 96.5%
fma-define96.5%
associate-*l*98.0%
Simplified98.0%
fma-define98.0%
+-commutative98.0%
Applied egg-rr98.0%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 0.0%
associate--l+0.0%
*-commutative0.0%
associate--l+0.0%
associate--l+0.0%
*-commutative0.0%
associate--l+0.0%
fma-define10.0%
*-commutative10.0%
associate-*l*10.0%
+-commutative10.0%
fma-define10.0%
Simplified10.0%
Taylor expanded in i around inf 50.1%
Taylor expanded in a around 0 51.1%
associate-*r*51.1%
*-commutative51.1%
associate-*l*60.2%
*-commutative60.2%
Simplified60.2%
Final simplification96.6%
(FPCore (x y z t a b c i) :precision binary64 (let* ((t_1 (- (+ (* x y) (* z t)) (* (* c (+ a (* b c))) i)))) (if (<= t_1 INFINITY) (* 2.0 t_1) (* -2.0 (* c (* c (* b i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((x * y) + (z * t)) - ((c * (a + (b * c))) * i);
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = 2.0 * t_1;
} else {
tmp = -2.0 * (c * (c * (b * i)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((x * y) + (z * t)) - ((c * (a + (b * c))) * i);
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = 2.0 * t_1;
} else {
tmp = -2.0 * (c * (c * (b * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = ((x * y) + (z * t)) - ((c * (a + (b * c))) * i) tmp = 0 if t_1 <= math.inf: tmp = 2.0 * t_1 else: tmp = -2.0 * (c * (c * (b * i))) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(c * Float64(a + Float64(b * c))) * i)) tmp = 0.0 if (t_1 <= Inf) tmp = Float64(2.0 * t_1); else tmp = Float64(-2.0 * Float64(c * Float64(c * Float64(b * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = ((x * y) + (z * t)) - ((c * (a + (b * c))) * i); tmp = 0.0; if (t_1 <= Inf) tmp = 2.0 * t_1; else tmp = -2.0 * (c * (c * (b * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], N[(2.0 * t$95$1), $MachinePrecision], N[(-2.0 * N[(c * N[(c * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot y + z \cdot t\right) - \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;2 \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(c \cdot \left(b \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < +inf.0Initial program 96.5%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 0.0%
associate--l+0.0%
*-commutative0.0%
associate--l+0.0%
associate--l+0.0%
*-commutative0.0%
associate--l+0.0%
fma-define10.0%
*-commutative10.0%
associate-*l*10.0%
+-commutative10.0%
fma-define10.0%
Simplified10.0%
Taylor expanded in i around inf 50.1%
Taylor expanded in a around 0 51.1%
associate-*r*51.1%
*-commutative51.1%
associate-*l*60.2%
*-commutative60.2%
Simplified60.2%
Final simplification95.1%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= (* x y) -2e+29) (not (<= (* x y) 4e+175))) (* 2.0 (- (* x y) (* c (* b (* c i))))) (* 2.0 (- (* z t) (* c (* (+ a (* b c)) i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (((x * y) <= -2e+29) || !((x * y) <= 4e+175)) {
tmp = 2.0 * ((x * y) - (c * (b * (c * i))));
} else {
tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (((x * y) <= (-2d+29)) .or. (.not. ((x * y) <= 4d+175))) then
tmp = 2.0d0 * ((x * y) - (c * (b * (c * i))))
else
tmp = 2.0d0 * ((z * t) - (c * ((a + (b * c)) * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (((x * y) <= -2e+29) || !((x * y) <= 4e+175)) {
tmp = 2.0 * ((x * y) - (c * (b * (c * i))));
} else {
tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if ((x * y) <= -2e+29) or not ((x * y) <= 4e+175): tmp = 2.0 * ((x * y) - (c * (b * (c * i)))) else: tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((Float64(x * y) <= -2e+29) || !(Float64(x * y) <= 4e+175)) tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(b * Float64(c * i))))); else tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(Float64(a + Float64(b * c)) * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (((x * y) <= -2e+29) || ~(((x * y) <= 4e+175))) tmp = 2.0 * ((x * y) - (c * (b * (c * i)))); else tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -2e+29], N[Not[LessEqual[N[(x * y), $MachinePrecision], 4e+175]], $MachinePrecision]], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+29} \lor \neg \left(x \cdot y \leq 4 \cdot 10^{+175}\right):\\
\;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -1.99999999999999983e29 or 3.9999999999999997e175 < (*.f64 x y) Initial program 89.6%
Taylor expanded in a around 0 85.1%
*-commutative85.1%
Simplified85.1%
Taylor expanded in x around inf 80.5%
sub-neg80.5%
associate-*r*81.6%
associate-*l*83.8%
Applied egg-rr83.8%
if -1.99999999999999983e29 < (*.f64 x y) < 3.9999999999999997e175Initial program 94.3%
associate--l+94.3%
*-commutative94.3%
associate--l+94.3%
associate--l+94.3%
*-commutative94.3%
associate--l+94.3%
fma-define94.3%
*-commutative94.3%
associate-*l*95.9%
+-commutative95.9%
fma-define95.9%
Simplified95.9%
Taylor expanded in x around 0 90.1%
Final simplification88.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))))
(if (<= (* x y) -200.0)
(* 2.0 (- (* x y) (* (* c t_1) i)))
(if (<= (* x y) 4e+175)
(* 2.0 (- (* z t) (* c (* t_1 i))))
(* 2.0 (- (* x y) (* c (* b (* c i)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double tmp;
if ((x * y) <= -200.0) {
tmp = 2.0 * ((x * y) - ((c * t_1) * i));
} else if ((x * y) <= 4e+175) {
tmp = 2.0 * ((z * t) - (c * (t_1 * i)));
} else {
tmp = 2.0 * ((x * y) - (c * (b * (c * i))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = a + (b * c)
if ((x * y) <= (-200.0d0)) then
tmp = 2.0d0 * ((x * y) - ((c * t_1) * i))
else if ((x * y) <= 4d+175) then
tmp = 2.0d0 * ((z * t) - (c * (t_1 * i)))
else
tmp = 2.0d0 * ((x * y) - (c * (b * (c * i))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double tmp;
if ((x * y) <= -200.0) {
tmp = 2.0 * ((x * y) - ((c * t_1) * i));
} else if ((x * y) <= 4e+175) {
tmp = 2.0 * ((z * t) - (c * (t_1 * i)));
} else {
tmp = 2.0 * ((x * y) - (c * (b * (c * i))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) tmp = 0 if (x * y) <= -200.0: tmp = 2.0 * ((x * y) - ((c * t_1) * i)) elif (x * y) <= 4e+175: tmp = 2.0 * ((z * t) - (c * (t_1 * i))) else: tmp = 2.0 * ((x * y) - (c * (b * (c * i)))) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) tmp = 0.0 if (Float64(x * y) <= -200.0) tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(Float64(c * t_1) * i))); elseif (Float64(x * y) <= 4e+175) tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(t_1 * i)))); else tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(b * Float64(c * i))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); tmp = 0.0; if ((x * y) <= -200.0) tmp = 2.0 * ((x * y) - ((c * t_1) * i)); elseif ((x * y) <= 4e+175) tmp = 2.0 * ((z * t) - (c * (t_1 * i))); else tmp = 2.0 * ((x * y) - (c * (b * (c * i)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -200.0], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 4e+175], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(t$95$1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
\mathbf{if}\;x \cdot y \leq -200:\\
\;\;\;\;2 \cdot \left(x \cdot y - \left(c \cdot t\_1\right) \cdot i\right)\\
\mathbf{elif}\;x \cdot y \leq 4 \cdot 10^{+175}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(t\_1 \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -200Initial program 95.2%
Taylor expanded in x around inf 87.0%
if -200 < (*.f64 x y) < 3.9999999999999997e175Initial program 94.1%
associate--l+94.1%
*-commutative94.1%
associate--l+94.1%
associate--l+94.1%
*-commutative94.1%
associate--l+94.1%
fma-define94.1%
*-commutative94.1%
associate-*l*96.3%
+-commutative96.3%
fma-define96.3%
Simplified96.3%
Taylor expanded in x around 0 91.0%
if 3.9999999999999997e175 < (*.f64 x y) Initial program 81.3%
Taylor expanded in a around 0 81.3%
*-commutative81.3%
Simplified81.3%
Taylor expanded in x around inf 81.3%
sub-neg81.3%
associate-*r*81.3%
associate-*l*84.4%
Applied egg-rr84.4%
Final simplification89.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* -2.0 (* i (* a c)))) (t_2 (* t (* 2.0 z))))
(if (<= z -5.6e+66)
t_2
(if (<= z -7.6e-6)
t_1
(if (<= z 1.15e-270) (* x (* 2.0 y)) (if (<= z 1.1e-109) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = -2.0 * (i * (a * c));
double t_2 = t * (2.0 * z);
double tmp;
if (z <= -5.6e+66) {
tmp = t_2;
} else if (z <= -7.6e-6) {
tmp = t_1;
} else if (z <= 1.15e-270) {
tmp = x * (2.0 * y);
} else if (z <= 1.1e-109) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (-2.0d0) * (i * (a * c))
t_2 = t * (2.0d0 * z)
if (z <= (-5.6d+66)) then
tmp = t_2
else if (z <= (-7.6d-6)) then
tmp = t_1
else if (z <= 1.15d-270) then
tmp = x * (2.0d0 * y)
else if (z <= 1.1d-109) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = -2.0 * (i * (a * c));
double t_2 = t * (2.0 * z);
double tmp;
if (z <= -5.6e+66) {
tmp = t_2;
} else if (z <= -7.6e-6) {
tmp = t_1;
} else if (z <= 1.15e-270) {
tmp = x * (2.0 * y);
} else if (z <= 1.1e-109) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = -2.0 * (i * (a * c)) t_2 = t * (2.0 * z) tmp = 0 if z <= -5.6e+66: tmp = t_2 elif z <= -7.6e-6: tmp = t_1 elif z <= 1.15e-270: tmp = x * (2.0 * y) elif z <= 1.1e-109: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(-2.0 * Float64(i * Float64(a * c))) t_2 = Float64(t * Float64(2.0 * z)) tmp = 0.0 if (z <= -5.6e+66) tmp = t_2; elseif (z <= -7.6e-6) tmp = t_1; elseif (z <= 1.15e-270) tmp = Float64(x * Float64(2.0 * y)); elseif (z <= 1.1e-109) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = -2.0 * (i * (a * c)); t_2 = t * (2.0 * z); tmp = 0.0; if (z <= -5.6e+66) tmp = t_2; elseif (z <= -7.6e-6) tmp = t_1; elseif (z <= 1.15e-270) tmp = x * (2.0 * y); elseif (z <= 1.1e-109) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(-2.0 * N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(2.0 * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.6e+66], t$95$2, If[LessEqual[z, -7.6e-6], t$95$1, If[LessEqual[z, 1.15e-270], N[(x * N[(2.0 * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e-109], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -2 \cdot \left(i \cdot \left(a \cdot c\right)\right)\\
t_2 := t \cdot \left(2 \cdot z\right)\\
\mathbf{if}\;z \leq -5.6 \cdot 10^{+66}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -7.6 \cdot 10^{-6}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{-270}:\\
\;\;\;\;x \cdot \left(2 \cdot y\right)\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-109}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -5.6000000000000001e66 or 1.1e-109 < z Initial program 93.4%
associate--l+93.4%
*-commutative93.4%
associate--l+93.4%
associate--l+93.4%
*-commutative93.4%
associate--l+93.4%
fma-define94.1%
*-commutative94.1%
associate-*l*92.0%
+-commutative92.0%
fma-define92.0%
Simplified92.0%
Taylor expanded in z around inf 41.8%
associate-*r*41.8%
*-commutative41.8%
associate-*l*41.8%
*-commutative41.8%
Simplified41.8%
if -5.6000000000000001e66 < z < -7.6000000000000001e-6 or 1.1500000000000001e-270 < z < 1.1e-109Initial program 89.8%
associate--l+89.8%
*-commutative89.8%
associate--l+89.8%
associate--l+89.8%
*-commutative89.8%
associate--l+89.8%
fma-define89.8%
*-commutative89.8%
associate-*l*93.1%
+-commutative93.1%
fma-define93.1%
Simplified93.1%
Taylor expanded in a around inf 30.2%
*-commutative30.2%
*-commutative30.2%
associate-*l*26.9%
*-commutative26.9%
associate-*l*26.9%
associate-*l*26.9%
Simplified26.9%
Taylor expanded in c around 0 30.2%
associate-*r*30.3%
Simplified30.3%
if -7.6000000000000001e-6 < z < 1.1500000000000001e-270Initial program 93.8%
associate--l+93.8%
*-commutative93.8%
associate--l+93.8%
associate--l+93.8%
*-commutative93.8%
associate--l+93.8%
fma-define93.8%
*-commutative93.8%
associate-*l*95.3%
+-commutative95.3%
fma-define95.3%
Simplified95.3%
Taylor expanded in x around inf 47.8%
*-commutative47.8%
associate-*l*47.8%
Simplified47.8%
Final simplification40.7%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= c -5e-17)
(* -2.0 (* c (* (* b c) i)))
(if (<= c 3.4e-71)
(* t (* 2.0 z))
(if (<= c 3.75e+24) (* x (* 2.0 y)) (* -2.0 (* c (* b (* c i))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -5e-17) {
tmp = -2.0 * (c * ((b * c) * i));
} else if (c <= 3.4e-71) {
tmp = t * (2.0 * z);
} else if (c <= 3.75e+24) {
tmp = x * (2.0 * y);
} else {
tmp = -2.0 * (c * (b * (c * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (c <= (-5d-17)) then
tmp = (-2.0d0) * (c * ((b * c) * i))
else if (c <= 3.4d-71) then
tmp = t * (2.0d0 * z)
else if (c <= 3.75d+24) then
tmp = x * (2.0d0 * y)
else
tmp = (-2.0d0) * (c * (b * (c * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -5e-17) {
tmp = -2.0 * (c * ((b * c) * i));
} else if (c <= 3.4e-71) {
tmp = t * (2.0 * z);
} else if (c <= 3.75e+24) {
tmp = x * (2.0 * y);
} else {
tmp = -2.0 * (c * (b * (c * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if c <= -5e-17: tmp = -2.0 * (c * ((b * c) * i)) elif c <= 3.4e-71: tmp = t * (2.0 * z) elif c <= 3.75e+24: tmp = x * (2.0 * y) else: tmp = -2.0 * (c * (b * (c * i))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (c <= -5e-17) tmp = Float64(-2.0 * Float64(c * Float64(Float64(b * c) * i))); elseif (c <= 3.4e-71) tmp = Float64(t * Float64(2.0 * z)); elseif (c <= 3.75e+24) tmp = Float64(x * Float64(2.0 * y)); else tmp = Float64(-2.0 * Float64(c * Float64(b * Float64(c * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (c <= -5e-17) tmp = -2.0 * (c * ((b * c) * i)); elseif (c <= 3.4e-71) tmp = t * (2.0 * z); elseif (c <= 3.75e+24) tmp = x * (2.0 * y); else tmp = -2.0 * (c * (b * (c * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -5e-17], N[(-2.0 * N[(c * N[(N[(b * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.4e-71], N[(t * N[(2.0 * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.75e+24], N[(x * N[(2.0 * y), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -5 \cdot 10^{-17}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(\left(b \cdot c\right) \cdot i\right)\right)\\
\mathbf{elif}\;c \leq 3.4 \cdot 10^{-71}:\\
\;\;\;\;t \cdot \left(2 \cdot z\right)\\
\mathbf{elif}\;c \leq 3.75 \cdot 10^{+24}:\\
\;\;\;\;x \cdot \left(2 \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if c < -4.9999999999999999e-17Initial program 86.5%
associate--l+86.5%
*-commutative86.5%
associate--l+86.5%
associate--l+86.5%
*-commutative86.5%
associate--l+86.5%
fma-define86.5%
*-commutative86.5%
associate-*l*91.7%
+-commutative91.7%
fma-define91.7%
Simplified91.7%
Taylor expanded in i around inf 79.8%
Taylor expanded in a around 0 68.4%
*-commutative75.6%
Simplified68.4%
if -4.9999999999999999e-17 < c < 3.40000000000000003e-71Initial program 98.1%
associate--l+98.1%
*-commutative98.1%
associate--l+98.1%
associate--l+98.1%
*-commutative98.1%
associate--l+98.1%
fma-define99.0%
*-commutative99.0%
associate-*l*92.8%
+-commutative92.8%
fma-define92.8%
Simplified92.8%
Taylor expanded in z around inf 48.1%
associate-*r*48.1%
*-commutative48.1%
associate-*l*48.1%
*-commutative48.1%
Simplified48.1%
if 3.40000000000000003e-71 < c < 3.75000000000000007e24Initial program 100.0%
associate--l+100.0%
*-commutative100.0%
associate--l+100.0%
associate--l+100.0%
*-commutative100.0%
associate--l+100.0%
fma-define100.0%
*-commutative100.0%
associate-*l*100.0%
+-commutative100.0%
fma-define100.0%
Simplified100.0%
Taylor expanded in x around inf 49.3%
*-commutative49.3%
associate-*l*49.3%
Simplified49.3%
if 3.75000000000000007e24 < c Initial program 87.6%
associate--l+87.6%
*-commutative87.6%
associate--l+87.6%
associate--l+87.6%
*-commutative87.6%
associate--l+87.6%
fma-define87.6%
*-commutative87.6%
associate-*l*92.8%
+-commutative92.8%
fma-define92.8%
Simplified92.8%
Taylor expanded in i around inf 80.0%
Taylor expanded in a around 0 74.7%
Final simplification59.6%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* -2.0 (* c (* b (* c i))))))
(if (<= c -3.2e-19)
t_1
(if (<= c 2.05e-69)
(* t (* 2.0 z))
(if (<= c 3.2e+24) (* x (* 2.0 y)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = -2.0 * (c * (b * (c * i)));
double tmp;
if (c <= -3.2e-19) {
tmp = t_1;
} else if (c <= 2.05e-69) {
tmp = t * (2.0 * z);
} else if (c <= 3.2e+24) {
tmp = x * (2.0 * y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (-2.0d0) * (c * (b * (c * i)))
if (c <= (-3.2d-19)) then
tmp = t_1
else if (c <= 2.05d-69) then
tmp = t * (2.0d0 * z)
else if (c <= 3.2d+24) then
tmp = x * (2.0d0 * y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = -2.0 * (c * (b * (c * i)));
double tmp;
if (c <= -3.2e-19) {
tmp = t_1;
} else if (c <= 2.05e-69) {
tmp = t * (2.0 * z);
} else if (c <= 3.2e+24) {
tmp = x * (2.0 * y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = -2.0 * (c * (b * (c * i))) tmp = 0 if c <= -3.2e-19: tmp = t_1 elif c <= 2.05e-69: tmp = t * (2.0 * z) elif c <= 3.2e+24: tmp = x * (2.0 * y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(-2.0 * Float64(c * Float64(b * Float64(c * i)))) tmp = 0.0 if (c <= -3.2e-19) tmp = t_1; elseif (c <= 2.05e-69) tmp = Float64(t * Float64(2.0 * z)); elseif (c <= 3.2e+24) tmp = Float64(x * Float64(2.0 * y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = -2.0 * (c * (b * (c * i))); tmp = 0.0; if (c <= -3.2e-19) tmp = t_1; elseif (c <= 2.05e-69) tmp = t * (2.0 * z); elseif (c <= 3.2e+24) tmp = x * (2.0 * y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(-2.0 * N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.2e-19], t$95$1, If[LessEqual[c, 2.05e-69], N[(t * N[(2.0 * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.2e+24], N[(x * N[(2.0 * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := -2 \cdot \left(c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\mathbf{if}\;c \leq -3.2 \cdot 10^{-19}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 2.05 \cdot 10^{-69}:\\
\;\;\;\;t \cdot \left(2 \cdot z\right)\\
\mathbf{elif}\;c \leq 3.2 \cdot 10^{+24}:\\
\;\;\;\;x \cdot \left(2 \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -3.19999999999999982e-19 or 3.1999999999999997e24 < c Initial program 87.0%
associate--l+87.0%
*-commutative87.0%
associate--l+87.0%
associate--l+87.0%
*-commutative87.0%
associate--l+87.0%
fma-define87.0%
*-commutative87.0%
associate-*l*92.2%
+-commutative92.2%
fma-define92.2%
Simplified92.2%
Taylor expanded in i around inf 79.9%
Taylor expanded in a around 0 71.1%
if -3.19999999999999982e-19 < c < 2.04999999999999995e-69Initial program 98.1%
associate--l+98.1%
*-commutative98.1%
associate--l+98.1%
associate--l+98.1%
*-commutative98.1%
associate--l+98.1%
fma-define99.0%
*-commutative99.0%
associate-*l*92.8%
+-commutative92.8%
fma-define92.8%
Simplified92.8%
Taylor expanded in z around inf 48.1%
associate-*r*48.1%
*-commutative48.1%
associate-*l*48.1%
*-commutative48.1%
Simplified48.1%
if 2.04999999999999995e-69 < c < 3.1999999999999997e24Initial program 100.0%
associate--l+100.0%
*-commutative100.0%
associate--l+100.0%
associate--l+100.0%
*-commutative100.0%
associate--l+100.0%
fma-define100.0%
*-commutative100.0%
associate-*l*100.0%
+-commutative100.0%
fma-define100.0%
Simplified100.0%
Taylor expanded in x around inf 49.3%
*-commutative49.3%
associate-*l*49.3%
Simplified49.3%
Final simplification59.6%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= c -3.5e+18)
(* -2.0 (* c (* (+ a (* b c)) i)))
(if (<= c 3.3e+24)
(* 2.0 (+ (* x y) (* z t)))
(* 2.0 (- (* z t) (* c (* b (* c i))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -3.5e+18) {
tmp = -2.0 * (c * ((a + (b * c)) * i));
} else if (c <= 3.3e+24) {
tmp = 2.0 * ((x * y) + (z * t));
} else {
tmp = 2.0 * ((z * t) - (c * (b * (c * i))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (c <= (-3.5d+18)) then
tmp = (-2.0d0) * (c * ((a + (b * c)) * i))
else if (c <= 3.3d+24) then
tmp = 2.0d0 * ((x * y) + (z * t))
else
tmp = 2.0d0 * ((z * t) - (c * (b * (c * i))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -3.5e+18) {
tmp = -2.0 * (c * ((a + (b * c)) * i));
} else if (c <= 3.3e+24) {
tmp = 2.0 * ((x * y) + (z * t));
} else {
tmp = 2.0 * ((z * t) - (c * (b * (c * i))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if c <= -3.5e+18: tmp = -2.0 * (c * ((a + (b * c)) * i)) elif c <= 3.3e+24: tmp = 2.0 * ((x * y) + (z * t)) else: tmp = 2.0 * ((z * t) - (c * (b * (c * i)))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (c <= -3.5e+18) tmp = Float64(-2.0 * Float64(c * Float64(Float64(a + Float64(b * c)) * i))); elseif (c <= 3.3e+24) tmp = Float64(2.0 * Float64(Float64(x * y) + Float64(z * t))); else tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(b * Float64(c * i))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (c <= -3.5e+18) tmp = -2.0 * (c * ((a + (b * c)) * i)); elseif (c <= 3.3e+24) tmp = 2.0 * ((x * y) + (z * t)); else tmp = 2.0 * ((z * t) - (c * (b * (c * i)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -3.5e+18], N[(-2.0 * N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.3e+24], N[(2.0 * N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.5 \cdot 10^{+18}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\
\mathbf{elif}\;c \leq 3.3 \cdot 10^{+24}:\\
\;\;\;\;2 \cdot \left(x \cdot y + z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if c < -3.5e18Initial program 85.2%
associate--l+85.2%
*-commutative85.2%
associate--l+85.2%
associate--l+85.2%
*-commutative85.2%
associate--l+85.2%
fma-define85.2%
*-commutative85.2%
associate-*l*91.0%
+-commutative91.0%
fma-define91.0%
Simplified91.0%
Taylor expanded in i around inf 83.0%
if -3.5e18 < c < 3.2999999999999999e24Initial program 98.5%
associate--l+98.5%
*-commutative98.5%
associate--l+98.5%
associate--l+98.5%
*-commutative98.5%
associate--l+98.5%
fma-define99.2%
*-commutative99.2%
associate-*l*94.1%
+-commutative94.1%
fma-define94.1%
Simplified94.1%
Taylor expanded in c around 0 77.0%
if 3.2999999999999999e24 < c Initial program 87.6%
associate--l+87.6%
*-commutative87.6%
associate--l+87.6%
associate--l+87.6%
*-commutative87.6%
associate--l+87.6%
fma-define87.6%
*-commutative87.6%
associate-*l*92.8%
+-commutative92.8%
fma-define92.8%
Simplified92.8%
Taylor expanded in x around 0 88.8%
Taylor expanded in a around 0 83.5%
Final simplification79.9%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= c -3.5e+18) (not (<= c 2.3e+20))) (* -2.0 (* c (* (+ a (* b c)) i))) (* 2.0 (+ (* x y) (* z t)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((c <= -3.5e+18) || !(c <= 2.3e+20)) {
tmp = -2.0 * (c * ((a + (b * c)) * i));
} else {
tmp = 2.0 * ((x * y) + (z * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((c <= (-3.5d+18)) .or. (.not. (c <= 2.3d+20))) then
tmp = (-2.0d0) * (c * ((a + (b * c)) * i))
else
tmp = 2.0d0 * ((x * y) + (z * t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((c <= -3.5e+18) || !(c <= 2.3e+20)) {
tmp = -2.0 * (c * ((a + (b * c)) * i));
} else {
tmp = 2.0 * ((x * y) + (z * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (c <= -3.5e+18) or not (c <= 2.3e+20): tmp = -2.0 * (c * ((a + (b * c)) * i)) else: tmp = 2.0 * ((x * y) + (z * t)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((c <= -3.5e+18) || !(c <= 2.3e+20)) tmp = Float64(-2.0 * Float64(c * Float64(Float64(a + Float64(b * c)) * i))); else tmp = Float64(2.0 * Float64(Float64(x * y) + Float64(z * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((c <= -3.5e+18) || ~((c <= 2.3e+20))) tmp = -2.0 * (c * ((a + (b * c)) * i)); else tmp = 2.0 * ((x * y) + (z * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[c, -3.5e+18], N[Not[LessEqual[c, 2.3e+20]], $MachinePrecision]], N[(-2.0 * N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.5 \cdot 10^{+18} \lor \neg \left(c \leq 2.3 \cdot 10^{+20}\right):\\
\;\;\;\;-2 \cdot \left(c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(x \cdot y + z \cdot t\right)\\
\end{array}
\end{array}
if c < -3.5e18 or 2.3e20 < c Initial program 86.7%
associate--l+86.7%
*-commutative86.7%
associate--l+86.7%
associate--l+86.7%
*-commutative86.7%
associate--l+86.7%
fma-define86.7%
*-commutative86.7%
associate-*l*92.0%
+-commutative92.0%
fma-define92.0%
Simplified92.0%
Taylor expanded in i around inf 81.3%
if -3.5e18 < c < 2.3e20Initial program 98.4%
associate--l+98.4%
*-commutative98.4%
associate--l+98.4%
associate--l+98.4%
*-commutative98.4%
associate--l+98.4%
fma-define99.2%
*-commutative99.2%
associate-*l*94.0%
+-commutative94.0%
fma-define94.0%
Simplified94.0%
Taylor expanded in c around 0 77.9%
Final simplification79.6%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= c -3.35e+18)
(* -2.0 (* c (* (* b c) i)))
(if (<= c 9.5e+40)
(* 2.0 (+ (* x y) (* z t)))
(* -2.0 (* c (* b (* c i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -3.35e+18) {
tmp = -2.0 * (c * ((b * c) * i));
} else if (c <= 9.5e+40) {
tmp = 2.0 * ((x * y) + (z * t));
} else {
tmp = -2.0 * (c * (b * (c * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (c <= (-3.35d+18)) then
tmp = (-2.0d0) * (c * ((b * c) * i))
else if (c <= 9.5d+40) then
tmp = 2.0d0 * ((x * y) + (z * t))
else
tmp = (-2.0d0) * (c * (b * (c * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -3.35e+18) {
tmp = -2.0 * (c * ((b * c) * i));
} else if (c <= 9.5e+40) {
tmp = 2.0 * ((x * y) + (z * t));
} else {
tmp = -2.0 * (c * (b * (c * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if c <= -3.35e+18: tmp = -2.0 * (c * ((b * c) * i)) elif c <= 9.5e+40: tmp = 2.0 * ((x * y) + (z * t)) else: tmp = -2.0 * (c * (b * (c * i))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (c <= -3.35e+18) tmp = Float64(-2.0 * Float64(c * Float64(Float64(b * c) * i))); elseif (c <= 9.5e+40) tmp = Float64(2.0 * Float64(Float64(x * y) + Float64(z * t))); else tmp = Float64(-2.0 * Float64(c * Float64(b * Float64(c * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (c <= -3.35e+18) tmp = -2.0 * (c * ((b * c) * i)); elseif (c <= 9.5e+40) tmp = 2.0 * ((x * y) + (z * t)); else tmp = -2.0 * (c * (b * (c * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -3.35e+18], N[(-2.0 * N[(c * N[(N[(b * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 9.5e+40], N[(2.0 * N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.35 \cdot 10^{+18}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(\left(b \cdot c\right) \cdot i\right)\right)\\
\mathbf{elif}\;c \leq 9.5 \cdot 10^{+40}:\\
\;\;\;\;2 \cdot \left(x \cdot y + z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \left(c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\end{array}
\end{array}
if c < -3.35e18Initial program 85.2%
associate--l+85.2%
*-commutative85.2%
associate--l+85.2%
associate--l+85.2%
*-commutative85.2%
associate--l+85.2%
fma-define85.2%
*-commutative85.2%
associate-*l*91.0%
+-commutative91.0%
fma-define91.0%
Simplified91.0%
Taylor expanded in i around inf 83.0%
Taylor expanded in a around 0 72.2%
*-commutative74.9%
Simplified72.2%
if -3.35e18 < c < 9.5000000000000003e40Initial program 98.5%
associate--l+98.5%
*-commutative98.5%
associate--l+98.5%
associate--l+98.5%
*-commutative98.5%
associate--l+98.5%
fma-define99.2%
*-commutative99.2%
associate-*l*94.3%
+-commutative94.3%
fma-define94.3%
Simplified94.3%
Taylor expanded in c around 0 76.8%
if 9.5000000000000003e40 < c Initial program 86.9%
associate--l+86.9%
*-commutative86.9%
associate--l+86.9%
associate--l+86.9%
*-commutative86.9%
associate--l+86.9%
fma-define86.9%
*-commutative86.9%
associate-*l*92.4%
+-commutative92.4%
fma-define92.4%
Simplified92.4%
Taylor expanded in i around inf 82.6%
Taylor expanded in a around 0 76.9%
Final simplification75.6%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= x -3.1e+21) (not (<= x 7e+14))) (* x (* 2.0 y)) (* t (* 2.0 z))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((x <= -3.1e+21) || !(x <= 7e+14)) {
tmp = x * (2.0 * y);
} else {
tmp = t * (2.0 * z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((x <= (-3.1d+21)) .or. (.not. (x <= 7d+14))) then
tmp = x * (2.0d0 * y)
else
tmp = t * (2.0d0 * z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((x <= -3.1e+21) || !(x <= 7e+14)) {
tmp = x * (2.0 * y);
} else {
tmp = t * (2.0 * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (x <= -3.1e+21) or not (x <= 7e+14): tmp = x * (2.0 * y) else: tmp = t * (2.0 * z) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((x <= -3.1e+21) || !(x <= 7e+14)) tmp = Float64(x * Float64(2.0 * y)); else tmp = Float64(t * Float64(2.0 * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((x <= -3.1e+21) || ~((x <= 7e+14))) tmp = x * (2.0 * y); else tmp = t * (2.0 * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[x, -3.1e+21], N[Not[LessEqual[x, 7e+14]], $MachinePrecision]], N[(x * N[(2.0 * y), $MachinePrecision]), $MachinePrecision], N[(t * N[(2.0 * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.1 \cdot 10^{+21} \lor \neg \left(x \leq 7 \cdot 10^{+14}\right):\\
\;\;\;\;x \cdot \left(2 \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(2 \cdot z\right)\\
\end{array}
\end{array}
if x < -3.1e21 or 7e14 < x Initial program 89.2%
associate--l+89.2%
*-commutative89.2%
associate--l+89.2%
associate--l+89.2%
*-commutative89.2%
associate--l+89.2%
fma-define90.0%
*-commutative90.0%
associate-*l*89.2%
+-commutative89.2%
fma-define89.2%
Simplified89.2%
Taylor expanded in x around inf 45.8%
*-commutative45.8%
associate-*l*45.8%
Simplified45.8%
if -3.1e21 < x < 7e14Initial program 95.8%
associate--l+95.8%
*-commutative95.8%
associate--l+95.8%
associate--l+95.8%
*-commutative95.8%
associate--l+95.8%
fma-define95.8%
*-commutative95.8%
associate-*l*96.3%
+-commutative96.3%
fma-define96.3%
Simplified96.3%
Taylor expanded in z around inf 37.5%
associate-*r*37.5%
*-commutative37.5%
associate-*l*37.5%
*-commutative37.5%
Simplified37.5%
Final simplification41.4%
(FPCore (x y z t a b c i) :precision binary64 (* t (* 2.0 z)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return t * (2.0 * z);
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = t * (2.0d0 * z)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return t * (2.0 * z);
}
def code(x, y, z, t, a, b, c, i): return t * (2.0 * z)
function code(x, y, z, t, a, b, c, i) return Float64(t * Float64(2.0 * z)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = t * (2.0 * z); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(t * N[(2.0 * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
t \cdot \left(2 \cdot z\right)
\end{array}
Initial program 92.7%
associate--l+92.7%
*-commutative92.7%
associate--l+92.7%
associate--l+92.7%
*-commutative92.7%
associate--l+92.7%
fma-define93.1%
*-commutative93.1%
associate-*l*93.0%
+-commutative93.0%
fma-define93.0%
Simplified93.0%
Taylor expanded in z around inf 28.4%
associate-*r*28.4%
*-commutative28.4%
associate-*l*28.4%
*-commutative28.4%
Simplified28.4%
Final simplification28.4%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(a + Float64(b * c)) * Float64(c * i)))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i))); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)
\end{array}
herbie shell --seed 2024148
(FPCore (x y z t a b c i)
:name "Diagrams.ThreeD.Shapes:frustum from diagrams-lib-1.3.0.3, A"
:precision binary64
:alt
(! :herbie-platform default (* 2 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
(* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))