
(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 (if (<= (- (+ (* y x) (* t z)) (* i (* (+ (* c b) a) c))) 1e+294) (* (fma (fma c b a) (* (- c) i) (fma t z (* y x))) 2.0) (* (fma y x (fma t z (* (* (fma c b a) i) (- c)))) 2.0)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((((y * x) + (t * z)) - (i * (((c * b) + a) * c))) <= 1e+294) {
tmp = fma(fma(c, b, a), (-c * i), fma(t, z, (y * x))) * 2.0;
} else {
tmp = fma(y, x, fma(t, z, ((fma(c, b, a) * i) * -c))) * 2.0;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(Float64(y * x) + Float64(t * z)) - Float64(i * Float64(Float64(Float64(c * b) + a) * c))) <= 1e+294) tmp = Float64(fma(fma(c, b, a), Float64(Float64(-c) * i), fma(t, z, Float64(y * x))) * 2.0); else tmp = Float64(fma(y, x, fma(t, z, Float64(Float64(fma(c, b, a) * i) * Float64(-c)))) * 2.0); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(N[(y * x), $MachinePrecision] + N[(t * z), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+294], N[(N[(N[(c * b + a), $MachinePrecision] * N[((-c) * i), $MachinePrecision] + N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(y * x + N[(t * z + N[(N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(y \cdot x + t \cdot z\right) - i \cdot \left(\left(c \cdot b + a\right) \cdot c\right) \leq 10^{+294}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(c, b, a\right), \left(-c\right) \cdot i, \mathsf{fma}\left(t, z, y \cdot x\right)\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \mathsf{fma}\left(t, z, \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right) \cdot \left(-c\right)\right)\right) \cdot 2\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < 1.00000000000000007e294Initial program 96.0%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.3
Applied rewrites99.3%
if 1.00000000000000007e294 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 75.3%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites93.2%
Final simplification97.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+197)
(* (fma (fma c b a) (* (- c) i) (* t z)) 2.0)
(if (<= t_1 2e+41)
(* (fma y x (fma t z (* (* i a) (- c)))) 2.0)
(if (<= t_1 2e+285)
(* (fma (- i) (* (fma c b a) c) (* y x)) 2.0)
(* (* -2.0 (* (fma c b a) i)) c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+197) {
tmp = fma(fma(c, b, a), (-c * i), (t * z)) * 2.0;
} else if (t_1 <= 2e+41) {
tmp = fma(y, x, fma(t, z, ((i * a) * -c))) * 2.0;
} else if (t_1 <= 2e+285) {
tmp = fma(-i, (fma(c, b, a) * c), (y * x)) * 2.0;
} else {
tmp = (-2.0 * (fma(c, b, a) * i)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+197) tmp = Float64(fma(fma(c, b, a), Float64(Float64(-c) * i), Float64(t * z)) * 2.0); elseif (t_1 <= 2e+41) tmp = Float64(fma(y, x, fma(t, z, Float64(Float64(i * a) * Float64(-c)))) * 2.0); elseif (t_1 <= 2e+285) tmp = Float64(fma(Float64(-i), Float64(fma(c, b, a) * c), Float64(y * x)) * 2.0); else tmp = Float64(Float64(-2.0 * Float64(fma(c, b, a) * i)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+197], N[(N[(N[(c * b + a), $MachinePrecision] * N[((-c) * i), $MachinePrecision] + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e+41], N[(N[(y * x + N[(t * z + N[(N[(i * a), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e+285], N[(N[((-i) * N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(-2.0 * N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+197}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(c, b, a\right), \left(-c\right) \cdot i, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+41}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \mathsf{fma}\left(t, z, \left(i \cdot a\right) \cdot \left(-c\right)\right)\right) \cdot 2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+285}:\\
\;\;\;\;\mathsf{fma}\left(-i, \mathsf{fma}\left(c, b, a\right) \cdot c, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(-2 \cdot \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right)\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999995e196Initial program 82.1%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6490.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6490.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6490.3
Applied rewrites90.3%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f6489.2
Applied rewrites89.2%
if -9.9999999999999995e196 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.00000000000000001e41Initial program 97.5%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites97.9%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f6496.2
Applied rewrites96.2%
if 2.00000000000000001e41 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e285Initial program 99.5%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6488.3
Applied rewrites88.3%
if 2e285 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 72.2%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6489.0
Applied rewrites89.0%
Final simplification92.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (fma c b a) c)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+197)
(* (fma (- i) t_1 (* t z)) 2.0)
(if (<= t_2 2e+41)
(* (fma y x (fma t z (* (* i a) (- c)))) 2.0)
(if (<= t_2 2e+285)
(* (fma (- i) t_1 (* y x)) 2.0)
(* (* -2.0 (* (fma c b a) i)) c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = fma(c, b, a) * c;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+197) {
tmp = fma(-i, t_1, (t * z)) * 2.0;
} else if (t_2 <= 2e+41) {
tmp = fma(y, x, fma(t, z, ((i * a) * -c))) * 2.0;
} else if (t_2 <= 2e+285) {
tmp = fma(-i, t_1, (y * x)) * 2.0;
} else {
tmp = (-2.0 * (fma(c, b, a) * i)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(fma(c, b, a) * c) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+197) tmp = Float64(fma(Float64(-i), t_1, Float64(t * z)) * 2.0); elseif (t_2 <= 2e+41) tmp = Float64(fma(y, x, fma(t, z, Float64(Float64(i * a) * Float64(-c)))) * 2.0); elseif (t_2 <= 2e+285) tmp = Float64(fma(Float64(-i), t_1, Float64(y * x)) * 2.0); else tmp = Float64(Float64(-2.0 * Float64(fma(c, b, a) * i)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+197], N[(N[((-i) * t$95$1 + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 2e+41], N[(N[(y * x + N[(t * z + N[(N[(i * a), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 2e+285], N[(N[((-i) * t$95$1 + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(-2.0 * N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(c, b, a\right) \cdot c\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+197}:\\
\;\;\;\;\mathsf{fma}\left(-i, t\_1, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+41}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \mathsf{fma}\left(t, z, \left(i \cdot a\right) \cdot \left(-c\right)\right)\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+285}:\\
\;\;\;\;\mathsf{fma}\left(-i, t\_1, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(-2 \cdot \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right)\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999995e196Initial program 82.1%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6485.2
Applied rewrites85.2%
if -9.9999999999999995e196 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.00000000000000001e41Initial program 97.5%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites97.9%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f6496.2
Applied rewrites96.2%
if 2.00000000000000001e41 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e285Initial program 99.5%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6488.3
Applied rewrites88.3%
if 2e285 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 72.2%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6489.0
Applied rewrites89.0%
Final simplification91.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (fma c b a) c)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+197)
(* (fma (- i) t_1 (* t z)) 2.0)
(if (<= t_2 2e+41)
(* (fma x y (* t z)) 2.0)
(if (<= t_2 2e+285)
(* (fma (- i) t_1 (* y x)) 2.0)
(* (* -2.0 (* (fma c b a) i)) c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = fma(c, b, a) * c;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+197) {
tmp = fma(-i, t_1, (t * z)) * 2.0;
} else if (t_2 <= 2e+41) {
tmp = fma(x, y, (t * z)) * 2.0;
} else if (t_2 <= 2e+285) {
tmp = fma(-i, t_1, (y * x)) * 2.0;
} else {
tmp = (-2.0 * (fma(c, b, a) * i)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(fma(c, b, a) * c) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+197) tmp = Float64(fma(Float64(-i), t_1, Float64(t * z)) * 2.0); elseif (t_2 <= 2e+41) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); elseif (t_2 <= 2e+285) tmp = Float64(fma(Float64(-i), t_1, Float64(y * x)) * 2.0); else tmp = Float64(Float64(-2.0 * Float64(fma(c, b, a) * i)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+197], N[(N[((-i) * t$95$1 + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 2e+41], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 2e+285], N[(N[((-i) * t$95$1 + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(-2.0 * N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(c, b, a\right) \cdot c\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+197}:\\
\;\;\;\;\mathsf{fma}\left(-i, t\_1, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+41}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+285}:\\
\;\;\;\;\mathsf{fma}\left(-i, t\_1, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(-2 \cdot \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right)\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999995e196Initial program 82.1%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6485.2
Applied rewrites85.2%
if -9.9999999999999995e196 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.00000000000000001e41Initial program 97.5%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.5
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.3
Applied rewrites98.3%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6490.3
Applied rewrites90.3%
if 2.00000000000000001e41 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e285Initial program 99.5%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6488.3
Applied rewrites88.3%
if 2e285 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 72.2%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6489.0
Applied rewrites89.0%
Final simplification88.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (fma (- i) (* (fma c b a) c) (* t z)) 2.0))
(t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+197)
t_1
(if (<= t_2 2e+90)
(* (fma x y (* t z)) 2.0)
(if (<= t_2 1e+277) t_1 (* (* -2.0 (* (fma c b a) i)) c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = fma(-i, (fma(c, b, a) * c), (t * z)) * 2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+197) {
tmp = t_1;
} else if (t_2 <= 2e+90) {
tmp = fma(x, y, (t * z)) * 2.0;
} else if (t_2 <= 1e+277) {
tmp = t_1;
} else {
tmp = (-2.0 * (fma(c, b, a) * i)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(fma(Float64(-i), Float64(fma(c, b, a) * c), Float64(t * z)) * 2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+197) tmp = t_1; elseif (t_2 <= 2e+90) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); elseif (t_2 <= 1e+277) tmp = t_1; else tmp = Float64(Float64(-2.0 * Float64(fma(c, b, a) * i)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[((-i) * N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision] + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+197], t$95$1, If[LessEqual[t$95$2, 2e+90], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 1e+277], t$95$1, N[(N[(-2.0 * N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, \mathsf{fma}\left(c, b, a\right) \cdot c, t \cdot z\right) \cdot 2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+197}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 10^{+277}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(-2 \cdot \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right)\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999995e196 or 1.99999999999999993e90 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e277Initial program 84.8%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6485.1
Applied rewrites85.1%
if -9.9999999999999995e196 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.99999999999999993e90Initial program 97.6%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.4
Applied rewrites98.4%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6489.2
Applied rewrites89.2%
if 1e277 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 72.8%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6487.1
Applied rewrites87.1%
Final simplification87.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* -2.0 (* (fma c b a) i)) c)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+276)
t_1
(if (<= t_2 2e+114) (* (fma x y (* t z)) 2.0) 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 * (fma(c, b, a) * i)) * c;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+276) {
tmp = t_1;
} else if (t_2 <= 2e+114) {
tmp = fma(x, y, (t * z)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(-2.0 * Float64(fma(c, b, a) * i)) * c) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+276) tmp = t_1; elseif (t_2 <= 2e+114) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(-2.0 * N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+276], t$95$1, If[LessEqual[t$95$2, 2e+114], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-2 \cdot \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right)\right) \cdot c\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+276}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+114}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1.0000000000000001e276 or 2e114 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 79.3%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6484.2
Applied rewrites84.2%
if -1.0000000000000001e276 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e114Initial program 97.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.4
Applied rewrites98.4%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6486.5
Applied rewrites86.5%
Final simplification85.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+295)
(* (* (* (* i c) c) b) -2.0)
(if (<= t_1 2e+114)
(* (fma x y (* t z)) 2.0)
(* (* (* (* i c) b) -2.0) c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+295) {
tmp = (((i * c) * c) * b) * -2.0;
} else if (t_1 <= 2e+114) {
tmp = fma(x, y, (t * z)) * 2.0;
} else {
tmp = (((i * c) * b) * -2.0) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+295) tmp = Float64(Float64(Float64(Float64(i * c) * c) * b) * -2.0); elseif (t_1 <= 2e+114) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); else tmp = Float64(Float64(Float64(Float64(i * c) * b) * -2.0) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+295], N[(N[(N[(N[(i * c), $MachinePrecision] * c), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e+114], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(N[(i * c), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision] * c), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+295}:\\
\;\;\;\;\left(\left(\left(i \cdot c\right) \cdot c\right) \cdot b\right) \cdot -2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+114}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(i \cdot c\right) \cdot b\right) \cdot -2\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999998e294Initial program 79.5%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6488.8
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6488.8
Applied rewrites88.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6476.2
Applied rewrites76.2%
Applied rewrites77.6%
if -9.9999999999999998e294 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e114Initial program 97.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.5
Applied rewrites98.5%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6485.2
Applied rewrites85.2%
if 2e114 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 78.3%
Taylor expanded in b around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6463.5
Applied rewrites63.5%
Final simplification78.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+295)
(* (* (* (* c c) i) b) -2.0)
(if (<= t_1 2e+114)
(* (fma x y (* t z)) 2.0)
(* (* (* (* i c) b) -2.0) c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+295) {
tmp = (((c * c) * i) * b) * -2.0;
} else if (t_1 <= 2e+114) {
tmp = fma(x, y, (t * z)) * 2.0;
} else {
tmp = (((i * c) * b) * -2.0) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+295) tmp = Float64(Float64(Float64(Float64(c * c) * i) * b) * -2.0); elseif (t_1 <= 2e+114) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); else tmp = Float64(Float64(Float64(Float64(i * c) * b) * -2.0) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+295], N[(N[(N[(N[(c * c), $MachinePrecision] * i), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e+114], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(N[(i * c), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision] * c), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+295}:\\
\;\;\;\;\left(\left(\left(c \cdot c\right) \cdot i\right) \cdot b\right) \cdot -2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+114}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(i \cdot c\right) \cdot b\right) \cdot -2\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999998e294Initial program 79.5%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6488.9
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6488.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6488.9
Applied rewrites88.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6476.2
Applied rewrites76.2%
if -9.9999999999999998e294 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e114Initial program 97.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.5
Applied rewrites98.5%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6485.2
Applied rewrites85.2%
if 2e114 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 78.3%
Taylor expanded in b around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6463.5
Applied rewrites63.5%
Final simplification78.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* (* c c) i) b) -2.0)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+295)
t_1
(if (<= t_2 2e+114) (* (fma x y (* t z)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (((c * c) * i) * b) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+295) {
tmp = t_1;
} else if (t_2 <= 2e+114) {
tmp = fma(x, y, (t * z)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(Float64(c * c) * i) * b) * -2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+295) tmp = t_1; elseif (t_2 <= 2e+114) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(c * c), $MachinePrecision] * i), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+295], t$95$1, If[LessEqual[t$95$2, 2e+114], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\left(c \cdot c\right) \cdot i\right) \cdot b\right) \cdot -2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+295}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+114}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.9999999999999998e294 or 2e114 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 78.9%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6489.2
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6489.2
Applied rewrites89.2%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6468.4
Applied rewrites68.4%
if -9.9999999999999998e294 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2e114Initial program 97.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.5
Applied rewrites98.5%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6485.2
Applied rewrites85.2%
Final simplification77.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -5e+270)
(* (* (* i c) a) -2.0)
(if (<= t_1 2e+90) (* (fma x y (* t z)) 2.0) (* (* (* c a) i) -2.0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -5e+270) {
tmp = ((i * c) * a) * -2.0;
} else if (t_1 <= 2e+90) {
tmp = fma(x, y, (t * z)) * 2.0;
} else {
tmp = ((c * a) * i) * -2.0;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -5e+270) tmp = Float64(Float64(Float64(i * c) * a) * -2.0); elseif (t_1 <= 2e+90) tmp = Float64(fma(x, y, Float64(t * z)) * 2.0); else tmp = Float64(Float64(Float64(c * a) * i) * -2.0); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+270], N[(N[(N[(i * c), $MachinePrecision] * a), $MachinePrecision] * -2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e+90], N[(N[(x * y + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(c * a), $MachinePrecision] * i), $MachinePrecision] * -2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+270}:\\
\;\;\;\;\left(\left(i \cdot c\right) \cdot a\right) \cdot -2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(x, y, t \cdot z\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(c \cdot a\right) \cdot i\right) \cdot -2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.99999999999999976e270Initial program 80.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6441.3
Applied rewrites41.3%
if -4.99999999999999976e270 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.99999999999999993e90Initial program 97.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6498.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.4
Applied rewrites98.4%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6487.6
Applied rewrites87.6%
if 1.99999999999999993e90 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 78.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6488.1
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6488.1
Applied rewrites88.1%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6439.5
Applied rewrites39.5%
Applied rewrites39.7%
Final simplification65.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* 2.0 (* t z))))
(if (<= (* t z) -2e+86)
t_1
(if (<= (* t z) 4e+16)
(* (* y x) 2.0)
(if (<= (* t z) 1e+110) (* (* (* c a) i) -2.0) 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 * (t * z);
double tmp;
if ((t * z) <= -2e+86) {
tmp = t_1;
} else if ((t * z) <= 4e+16) {
tmp = (y * x) * 2.0;
} else if ((t * z) <= 1e+110) {
tmp = ((c * a) * i) * -2.0;
} 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 * (t * z)
if ((t * z) <= (-2d+86)) then
tmp = t_1
else if ((t * z) <= 4d+16) then
tmp = (y * x) * 2.0d0
else if ((t * z) <= 1d+110) then
tmp = ((c * a) * i) * (-2.0d0)
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 * (t * z);
double tmp;
if ((t * z) <= -2e+86) {
tmp = t_1;
} else if ((t * z) <= 4e+16) {
tmp = (y * x) * 2.0;
} else if ((t * z) <= 1e+110) {
tmp = ((c * a) * i) * -2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = 2.0 * (t * z) tmp = 0 if (t * z) <= -2e+86: tmp = t_1 elif (t * z) <= 4e+16: tmp = (y * x) * 2.0 elif (t * z) <= 1e+110: tmp = ((c * a) * i) * -2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * Float64(t * z)) tmp = 0.0 if (Float64(t * z) <= -2e+86) tmp = t_1; elseif (Float64(t * z) <= 4e+16) tmp = Float64(Float64(y * x) * 2.0); elseif (Float64(t * z) <= 1e+110) tmp = Float64(Float64(Float64(c * a) * i) * -2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = 2.0 * (t * z); tmp = 0.0; if ((t * z) <= -2e+86) tmp = t_1; elseif ((t * z) <= 4e+16) tmp = (y * x) * 2.0; elseif ((t * z) <= 1e+110) tmp = ((c * a) * i) * -2.0; 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[(t * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t * z), $MachinePrecision], -2e+86], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], 4e+16], N[(N[(y * x), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+110], N[(N[(N[(c * a), $MachinePrecision] * i), $MachinePrecision] * -2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \left(t \cdot z\right)\\
\mathbf{if}\;t \cdot z \leq -2 \cdot 10^{+86}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq 4 \cdot 10^{+16}:\\
\;\;\;\;\left(y \cdot x\right) \cdot 2\\
\mathbf{elif}\;t \cdot z \leq 10^{+110}:\\
\;\;\;\;\left(\left(c \cdot a\right) \cdot i\right) \cdot -2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -2e86 or 1e110 < (*.f64 z t) Initial program 84.6%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6460.9
Applied rewrites60.9%
if -2e86 < (*.f64 z t) < 4e16Initial program 90.7%
Taylor expanded in x around inf
lower-*.f64N/A
*-commutativeN/A
lower-*.f6443.1
Applied rewrites43.1%
if 4e16 < (*.f64 z t) < 1e110Initial program 94.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6444.9
Applied rewrites44.9%
Applied rewrites50.3%
Final simplification49.4%
(FPCore (x y z t a b c i) :precision binary64 (* (fma y x (fma t z (* (* (fma c b a) i) (- c)))) 2.0))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return fma(y, x, fma(t, z, ((fma(c, b, a) * i) * -c))) * 2.0;
}
function code(x, y, z, t, a, b, c, i) return Float64(fma(y, x, fma(t, z, Float64(Float64(fma(c, b, a) * i) * Float64(-c)))) * 2.0) end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(y * x + N[(t * z + N[(N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y, x, \mathsf{fma}\left(t, z, \left(\mathsf{fma}\left(c, b, a\right) \cdot i\right) \cdot \left(-c\right)\right)\right) \cdot 2
\end{array}
Initial program 89.0%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites93.0%
Final simplification93.0%
(FPCore (x y z t a b c i) :precision binary64 (let* ((t_1 (* 2.0 (* t z)))) (if (<= (* t z) -2e+86) t_1 (if (<= (* t z) 1e+110) (* (* y x) 2.0) 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 * (t * z);
double tmp;
if ((t * z) <= -2e+86) {
tmp = t_1;
} else if ((t * z) <= 1e+110) {
tmp = (y * x) * 2.0;
} 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 * (t * z)
if ((t * z) <= (-2d+86)) then
tmp = t_1
else if ((t * z) <= 1d+110) then
tmp = (y * x) * 2.0d0
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 * (t * z);
double tmp;
if ((t * z) <= -2e+86) {
tmp = t_1;
} else if ((t * z) <= 1e+110) {
tmp = (y * x) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = 2.0 * (t * z) tmp = 0 if (t * z) <= -2e+86: tmp = t_1 elif (t * z) <= 1e+110: tmp = (y * x) * 2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * Float64(t * z)) tmp = 0.0 if (Float64(t * z) <= -2e+86) tmp = t_1; elseif (Float64(t * z) <= 1e+110) tmp = Float64(Float64(y * x) * 2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = 2.0 * (t * z); tmp = 0.0; if ((t * z) <= -2e+86) tmp = t_1; elseif ((t * z) <= 1e+110) tmp = (y * x) * 2.0; 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[(t * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t * z), $MachinePrecision], -2e+86], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], 1e+110], N[(N[(y * x), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \left(t \cdot z\right)\\
\mathbf{if}\;t \cdot z \leq -2 \cdot 10^{+86}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq 10^{+110}:\\
\;\;\;\;\left(y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -2e86 or 1e110 < (*.f64 z t) Initial program 84.6%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6460.9
Applied rewrites60.9%
if -2e86 < (*.f64 z t) < 1e110Initial program 91.1%
Taylor expanded in x around inf
lower-*.f64N/A
*-commutativeN/A
lower-*.f6441.2
Applied rewrites41.2%
Final simplification47.6%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (* t z)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (t * 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 = 2.0d0 * (t * z)
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 * (t * z);
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (t * z)
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(t * z)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (t * z); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(t * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(t \cdot z\right)
\end{array}
Initial program 89.0%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6426.8
Applied rewrites26.8%
(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 2024331
(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))))