
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
(FPCore (x y z t a b c) :precision binary64 (if (<= (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) INFINITY) (+ (+ (* x y) (fma a (* b -0.25) c)) (* t (* z 0.0625))) (* x y)))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) <= ((double) INFINITY)) {
tmp = ((x * y) + fma(a, (b * -0.25), c)) + (t * (z * 0.0625));
} else {
tmp = x * y;
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) <= Inf) tmp = Float64(Float64(Float64(x * y) + fma(a, Float64(b * -0.25), c)) + Float64(t * Float64(z * 0.0625))); else tmp = Float64(x * y); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(x * y), $MachinePrecision] + N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4} \leq \infty:\\
\;\;\;\;\left(x \cdot y + \mathsf{fma}\left(a, b \cdot -0.25, c\right)\right) + t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) 16)) (/.f64 (*.f64 a b) 4)) < +inf.0Initial program 100.0%
associate-+l-100.0%
associate--l+100.0%
fma-def100.0%
associate-*l/100.0%
fma-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
associate-/l*99.9%
distribute-frac-neg99.9%
associate-/r/100.0%
fma-def100.0%
neg-mul-1100.0%
*-commutative100.0%
associate-/l*100.0%
metadata-eval100.0%
Simplified100.0%
fma-udef100.0%
fma-udef100.0%
associate-*l/100.0%
fma-udef100.0%
associate-/r/99.9%
associate-+r+99.9%
associate-*l/99.9%
fma-udef99.9%
+-commutative99.9%
fma-udef99.9%
associate-*l/99.9%
associate-+r+99.9%
div-inv99.9%
fma-def100.0%
clear-num100.0%
div-inv100.0%
metadata-eval100.0%
associate-*l/100.0%
Applied egg-rr100.0%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) 16)) (/.f64 (*.f64 a b) 4)) Initial program 0.0%
associate-+l-0.0%
associate--l+0.0%
fma-def40.0%
associate-*l/40.0%
fma-neg40.0%
sub-neg40.0%
distribute-neg-in40.0%
remove-double-neg40.0%
associate-/l*40.0%
distribute-frac-neg40.0%
associate-/r/40.0%
fma-def40.0%
neg-mul-140.0%
*-commutative40.0%
associate-/l*40.0%
metadata-eval40.0%
Simplified40.0%
fma-udef0.0%
fma-udef0.0%
associate-*l/0.0%
fma-udef0.0%
associate-/r/0.0%
associate-+r+0.0%
associate-*l/0.0%
fma-udef10.0%
+-commutative10.0%
fma-udef0.0%
associate-*l/0.0%
associate-+r+0.0%
div-inv0.0%
fma-def0.0%
clear-num0.0%
div-inv0.0%
metadata-eval0.0%
associate-*l/0.0%
Applied egg-rr0.0%
Taylor expanded in x around inf 40.6%
Final simplification97.7%
(FPCore (x y z t a b c) :precision binary64 (fma x y (fma (/ z 16.0) t (fma (/ a -4.0) b c))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return fma(x, y, fma((z / 16.0), t, fma((a / -4.0), b, c)));
}
function code(x, y, z, t, a, b, c) return fma(x, y, fma(Float64(z / 16.0), t, fma(Float64(a / -4.0), b, c))) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(x * y + N[(N[(z / 16.0), $MachinePrecision] * t + N[(N[(a / -4.0), $MachinePrecision] * b + c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y, \mathsf{fma}\left(\frac{z}{16}, t, \mathsf{fma}\left(\frac{a}{-4}, b, c\right)\right)\right)
\end{array}
Initial program 96.1%
associate-+l-96.1%
associate--l+96.1%
fma-def97.6%
associate-*l/97.6%
fma-neg97.6%
sub-neg97.6%
distribute-neg-in97.6%
remove-double-neg97.6%
associate-/l*97.6%
distribute-frac-neg97.6%
associate-/r/97.6%
fma-def97.7%
neg-mul-197.7%
*-commutative97.7%
associate-/l*97.7%
metadata-eval97.7%
Simplified97.7%
Final simplification97.7%
(FPCore (x y z t a b c) :precision binary64 (+ (fma x y (* (/ z 16.0) t)) (+ c (/ a (/ -4.0 b)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return fma(x, y, ((z / 16.0) * t)) + (c + (a / (-4.0 / b)));
}
function code(x, y, z, t, a, b, c) return Float64(fma(x, y, Float64(Float64(z / 16.0) * t)) + Float64(c + Float64(a / Float64(-4.0 / b)))) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(x * y + N[(N[(z / 16.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(c + N[(a / N[(-4.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y, \frac{z}{16} \cdot t\right) + \left(c + \frac{a}{\frac{-4}{b}}\right)
\end{array}
Initial program 96.1%
sub-neg96.1%
associate-+l+96.1%
fma-def96.5%
associate-*l/96.5%
distribute-frac-neg96.5%
distribute-rgt-neg-out96.5%
associate-/l*96.4%
neg-mul-196.4%
associate-/r*96.4%
metadata-eval96.4%
Simplified96.4%
Final simplification96.4%
(FPCore (x y z t a b c) :precision binary64 (let* ((t_1 (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)))) (if (<= t_1 INFINITY) (+ c t_1) (* x y))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = ((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0);
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = c + t_1;
} else {
tmp = x * y;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = ((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0);
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = c + t_1;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = ((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0) tmp = 0 if t_1 <= math.inf: tmp = c + t_1 else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) tmp = 0.0 if (t_1 <= Inf) tmp = Float64(c + t_1); else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = ((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0); tmp = 0.0; if (t_1 <= Inf) tmp = c + t_1; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], N[(c + t$95$1), $MachinePrecision], N[(x * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;c + t_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) 16)) (/.f64 (*.f64 a b) 4)) < +inf.0Initial program 100.0%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) 16)) (/.f64 (*.f64 a b) 4)) Initial program 0.0%
associate-+l-0.0%
associate--l+0.0%
fma-def40.0%
associate-*l/40.0%
fma-neg40.0%
sub-neg40.0%
distribute-neg-in40.0%
remove-double-neg40.0%
associate-/l*40.0%
distribute-frac-neg40.0%
associate-/r/40.0%
fma-def40.0%
neg-mul-140.0%
*-commutative40.0%
associate-/l*40.0%
metadata-eval40.0%
Simplified40.0%
fma-udef0.0%
fma-udef0.0%
associate-*l/0.0%
fma-udef0.0%
associate-/r/0.0%
associate-+r+0.0%
associate-*l/0.0%
fma-udef10.0%
+-commutative10.0%
fma-udef0.0%
associate-*l/0.0%
associate-+r+0.0%
div-inv0.0%
fma-def0.0%
clear-num0.0%
div-inv0.0%
metadata-eval0.0%
associate-*l/0.0%
Applied egg-rr0.0%
Taylor expanded in x around inf 40.6%
Final simplification97.7%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* x y) -6.6e+90)
(* x y)
(if (<= (* x y) -5.2e-97)
c
(if (<= (* x y) -6.2e-131)
(* a (* b -0.25))
(if (<= (* x y) 1.7e-90)
(* t (* z 0.0625))
(if (<= (* x y) 1.35e+112) c (* x y)))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -6.6e+90) {
tmp = x * y;
} else if ((x * y) <= -5.2e-97) {
tmp = c;
} else if ((x * y) <= -6.2e-131) {
tmp = a * (b * -0.25);
} else if ((x * y) <= 1.7e-90) {
tmp = t * (z * 0.0625);
} else if ((x * y) <= 1.35e+112) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((x * y) <= (-6.6d+90)) then
tmp = x * y
else if ((x * y) <= (-5.2d-97)) then
tmp = c
else if ((x * y) <= (-6.2d-131)) then
tmp = a * (b * (-0.25d0))
else if ((x * y) <= 1.7d-90) then
tmp = t * (z * 0.0625d0)
else if ((x * y) <= 1.35d+112) then
tmp = c
else
tmp = x * y
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 tmp;
if ((x * y) <= -6.6e+90) {
tmp = x * y;
} else if ((x * y) <= -5.2e-97) {
tmp = c;
} else if ((x * y) <= -6.2e-131) {
tmp = a * (b * -0.25);
} else if ((x * y) <= 1.7e-90) {
tmp = t * (z * 0.0625);
} else if ((x * y) <= 1.35e+112) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -6.6e+90: tmp = x * y elif (x * y) <= -5.2e-97: tmp = c elif (x * y) <= -6.2e-131: tmp = a * (b * -0.25) elif (x * y) <= 1.7e-90: tmp = t * (z * 0.0625) elif (x * y) <= 1.35e+112: tmp = c else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -6.6e+90) tmp = Float64(x * y); elseif (Float64(x * y) <= -5.2e-97) tmp = c; elseif (Float64(x * y) <= -6.2e-131) tmp = Float64(a * Float64(b * -0.25)); elseif (Float64(x * y) <= 1.7e-90) tmp = Float64(t * Float64(z * 0.0625)); elseif (Float64(x * y) <= 1.35e+112) tmp = c; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((x * y) <= -6.6e+90) tmp = x * y; elseif ((x * y) <= -5.2e-97) tmp = c; elseif ((x * y) <= -6.2e-131) tmp = a * (b * -0.25); elseif ((x * y) <= 1.7e-90) tmp = t * (z * 0.0625); elseif ((x * y) <= 1.35e+112) tmp = c; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -6.6e+90], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -5.2e-97], c, If[LessEqual[N[(x * y), $MachinePrecision], -6.2e-131], N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.7e-90], N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.35e+112], c, N[(x * y), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -6.6 \cdot 10^{+90}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq -5.2 \cdot 10^{-97}:\\
\;\;\;\;c\\
\mathbf{elif}\;x \cdot y \leq -6.2 \cdot 10^{-131}:\\
\;\;\;\;a \cdot \left(b \cdot -0.25\right)\\
\mathbf{elif}\;x \cdot y \leq 1.7 \cdot 10^{-90}:\\
\;\;\;\;t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{elif}\;x \cdot y \leq 1.35 \cdot 10^{+112}:\\
\;\;\;\;c\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -6.60000000000000016e90 or 1.3500000000000001e112 < (*.f64 x y) Initial program 90.9%
associate-+l-90.9%
associate--l+90.9%
fma-def94.9%
associate-*l/94.9%
fma-neg94.9%
sub-neg94.9%
distribute-neg-in94.9%
remove-double-neg94.9%
associate-/l*94.9%
distribute-frac-neg94.9%
associate-/r/94.9%
fma-def94.9%
neg-mul-194.9%
*-commutative94.9%
associate-/l*94.9%
metadata-eval94.9%
Simplified94.9%
fma-udef90.9%
fma-udef90.9%
associate-*l/90.9%
fma-udef90.9%
associate-/r/90.8%
associate-+r+90.8%
associate-*l/90.8%
fma-udef91.9%
+-commutative91.9%
fma-udef90.8%
associate-*l/90.8%
associate-+r+90.8%
div-inv90.9%
fma-def90.9%
clear-num90.9%
div-inv90.9%
metadata-eval90.9%
associate-*l/90.9%
Applied egg-rr90.9%
Taylor expanded in x around inf 66.7%
if -6.60000000000000016e90 < (*.f64 x y) < -5.20000000000000014e-97 or 1.69999999999999997e-90 < (*.f64 x y) < 1.3500000000000001e112Initial program 100.0%
Taylor expanded in c around inf 40.2%
if -5.20000000000000014e-97 < (*.f64 x y) < -6.20000000000000041e-131Initial program 100.0%
associate-+l-100.0%
associate--l+100.0%
fma-def100.0%
associate-*l/100.0%
fma-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
associate-/l*99.7%
distribute-frac-neg99.7%
associate-/r/100.0%
fma-def100.0%
neg-mul-1100.0%
*-commutative100.0%
associate-/l*100.0%
metadata-eval100.0%
Simplified100.0%
fma-udef100.0%
fma-udef100.0%
associate-*l/100.0%
fma-udef100.0%
associate-/r/99.7%
associate-+r+99.7%
associate-*l/99.7%
fma-udef99.7%
+-commutative99.7%
fma-udef99.7%
associate-*l/99.7%
associate-+r+99.7%
div-inv100.0%
fma-def100.0%
clear-num100.0%
div-inv100.0%
metadata-eval100.0%
associate-*l/100.0%
Applied egg-rr100.0%
Taylor expanded in a around inf 83.8%
*-commutative83.8%
associate-*r*83.8%
*-commutative83.8%
Simplified83.8%
if -6.20000000000000041e-131 < (*.f64 x y) < 1.69999999999999997e-90Initial program 98.9%
associate-+l-98.9%
associate--l+98.9%
fma-def98.9%
associate-*l/98.9%
fma-neg98.9%
sub-neg98.9%
distribute-neg-in98.9%
remove-double-neg98.9%
associate-/l*98.8%
distribute-frac-neg98.8%
associate-/r/98.9%
fma-def98.9%
neg-mul-198.9%
*-commutative98.9%
associate-/l*98.9%
metadata-eval98.9%
Simplified98.9%
fma-udef98.9%
fma-udef98.9%
associate-*l/98.9%
fma-udef98.9%
associate-/r/98.8%
associate-+r+98.8%
associate-*l/98.8%
fma-udef98.8%
+-commutative98.8%
fma-udef98.8%
associate-*l/98.8%
associate-+r+98.8%
div-inv98.8%
fma-def98.8%
clear-num98.9%
div-inv98.9%
metadata-eval98.9%
associate-*l/98.9%
Applied egg-rr98.9%
Taylor expanded in t around inf 44.7%
*-commutative44.7%
associate-*r*44.7%
*-commutative44.7%
Simplified44.7%
Final simplification53.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (- (* x y) (* (* a b) 0.25))))
(if (<= (* x y) -1.65e+168)
t_1
(if (<= (* x y) 1.6e-188)
(+ c (* 0.0625 (* z t)))
(if (<= (* x y) 1.15e+112) (+ c (* a (* b -0.25))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) - ((a * b) * 0.25);
double tmp;
if ((x * y) <= -1.65e+168) {
tmp = t_1;
} else if ((x * y) <= 1.6e-188) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 1.15e+112) {
tmp = c + (a * (b * -0.25));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = (x * y) - ((a * b) * 0.25d0)
if ((x * y) <= (-1.65d+168)) then
tmp = t_1
else if ((x * y) <= 1.6d-188) then
tmp = c + (0.0625d0 * (z * t))
else if ((x * y) <= 1.15d+112) then
tmp = c + (a * (b * (-0.25d0)))
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 t_1 = (x * y) - ((a * b) * 0.25);
double tmp;
if ((x * y) <= -1.65e+168) {
tmp = t_1;
} else if ((x * y) <= 1.6e-188) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 1.15e+112) {
tmp = c + (a * (b * -0.25));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (x * y) - ((a * b) * 0.25) tmp = 0 if (x * y) <= -1.65e+168: tmp = t_1 elif (x * y) <= 1.6e-188: tmp = c + (0.0625 * (z * t)) elif (x * y) <= 1.15e+112: tmp = c + (a * (b * -0.25)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * y) - Float64(Float64(a * b) * 0.25)) tmp = 0.0 if (Float64(x * y) <= -1.65e+168) tmp = t_1; elseif (Float64(x * y) <= 1.6e-188) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); elseif (Float64(x * y) <= 1.15e+112) tmp = Float64(c + Float64(a * Float64(b * -0.25))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (x * y) - ((a * b) * 0.25); tmp = 0.0; if ((x * y) <= -1.65e+168) tmp = t_1; elseif ((x * y) <= 1.6e-188) tmp = c + (0.0625 * (z * t)); elseif ((x * y) <= 1.15e+112) tmp = c + (a * (b * -0.25)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1.65e+168], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.6e-188], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.15e+112], N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y - \left(a \cdot b\right) \cdot 0.25\\
\mathbf{if}\;x \cdot y \leq -1.65 \cdot 10^{+168}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 1.6 \cdot 10^{-188}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq 1.15 \cdot 10^{+112}:\\
\;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if (*.f64 x y) < -1.6499999999999999e168 or 1.15e112 < (*.f64 x y) Initial program 89.8%
Taylor expanded in z around 0 83.6%
Taylor expanded in c around 0 80.0%
if -1.6499999999999999e168 < (*.f64 x y) < 1.60000000000000011e-188Initial program 99.2%
Taylor expanded in z around inf 65.5%
if 1.60000000000000011e-188 < (*.f64 x y) < 1.15e112Initial program 100.0%
Taylor expanded in a around inf 70.7%
*-commutative70.7%
associate-*r*70.7%
Simplified70.7%
Final simplification71.3%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) 0.25)))
(if (or (<= (* x y) -4.6e+157) (not (<= (* x y) 4.3e+102)))
(- (+ c (* x y)) t_1)
(- (+ c (* 0.0625 (* z t))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (a * b) * 0.25;
double tmp;
if (((x * y) <= -4.6e+157) || !((x * y) <= 4.3e+102)) {
tmp = (c + (x * y)) - t_1;
} else {
tmp = (c + (0.0625 * (z * t))) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = (a * b) * 0.25d0
if (((x * y) <= (-4.6d+157)) .or. (.not. ((x * y) <= 4.3d+102))) then
tmp = (c + (x * y)) - t_1
else
tmp = (c + (0.0625d0 * (z * t))) - 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 t_1 = (a * b) * 0.25;
double tmp;
if (((x * y) <= -4.6e+157) || !((x * y) <= 4.3e+102)) {
tmp = (c + (x * y)) - t_1;
} else {
tmp = (c + (0.0625 * (z * t))) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) * 0.25 tmp = 0 if ((x * y) <= -4.6e+157) or not ((x * y) <= 4.3e+102): tmp = (c + (x * y)) - t_1 else: tmp = (c + (0.0625 * (z * t))) - t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) * 0.25) tmp = 0.0 if ((Float64(x * y) <= -4.6e+157) || !(Float64(x * y) <= 4.3e+102)) tmp = Float64(Float64(c + Float64(x * y)) - t_1); else tmp = Float64(Float64(c + Float64(0.0625 * Float64(z * t))) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (a * b) * 0.25; tmp = 0.0; if (((x * y) <= -4.6e+157) || ~(((x * y) <= 4.3e+102))) tmp = (c + (x * y)) - t_1; else tmp = (c + (0.0625 * (z * t))) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * b), $MachinePrecision] * 0.25), $MachinePrecision]}, If[Or[LessEqual[N[(x * y), $MachinePrecision], -4.6e+157], N[Not[LessEqual[N[(x * y), $MachinePrecision], 4.3e+102]], $MachinePrecision]], N[(N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot b\right) \cdot 0.25\\
\mathbf{if}\;x \cdot y \leq -4.6 \cdot 10^{+157} \lor \neg \left(x \cdot y \leq 4.3 \cdot 10^{+102}\right):\\
\;\;\;\;\left(c + x \cdot y\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;\left(c + 0.0625 \cdot \left(z \cdot t\right)\right) - t_1\\
\end{array}
\end{array}
if (*.f64 x y) < -4.60000000000000008e157 or 4.3000000000000001e102 < (*.f64 x y) Initial program 90.5%
Taylor expanded in z around 0 83.8%
if -4.60000000000000008e157 < (*.f64 x y) < 4.3000000000000001e102Initial program 99.4%
Taylor expanded in x around 0 96.4%
Final simplification91.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) 0.25)) (t_2 (* 0.0625 (* z t))))
(if (<= t -2.5e+30)
(+ c t_2)
(if (or (<= t 7.8e+40) (and (not (<= t 4.8e+118)) (<= t 5.8e+169)))
(- (+ c (* x y)) t_1)
(- t_2 t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (a * b) * 0.25;
double t_2 = 0.0625 * (z * t);
double tmp;
if (t <= -2.5e+30) {
tmp = c + t_2;
} else if ((t <= 7.8e+40) || (!(t <= 4.8e+118) && (t <= 5.8e+169))) {
tmp = (c + (x * y)) - t_1;
} else {
tmp = t_2 - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (a * b) * 0.25d0
t_2 = 0.0625d0 * (z * t)
if (t <= (-2.5d+30)) then
tmp = c + t_2
else if ((t <= 7.8d+40) .or. (.not. (t <= 4.8d+118)) .and. (t <= 5.8d+169)) then
tmp = (c + (x * y)) - t_1
else
tmp = t_2 - 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 t_1 = (a * b) * 0.25;
double t_2 = 0.0625 * (z * t);
double tmp;
if (t <= -2.5e+30) {
tmp = c + t_2;
} else if ((t <= 7.8e+40) || (!(t <= 4.8e+118) && (t <= 5.8e+169))) {
tmp = (c + (x * y)) - t_1;
} else {
tmp = t_2 - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) * 0.25 t_2 = 0.0625 * (z * t) tmp = 0 if t <= -2.5e+30: tmp = c + t_2 elif (t <= 7.8e+40) or (not (t <= 4.8e+118) and (t <= 5.8e+169)): tmp = (c + (x * y)) - t_1 else: tmp = t_2 - t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) * 0.25) t_2 = Float64(0.0625 * Float64(z * t)) tmp = 0.0 if (t <= -2.5e+30) tmp = Float64(c + t_2); elseif ((t <= 7.8e+40) || (!(t <= 4.8e+118) && (t <= 5.8e+169))) tmp = Float64(Float64(c + Float64(x * y)) - t_1); else tmp = Float64(t_2 - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (a * b) * 0.25; t_2 = 0.0625 * (z * t); tmp = 0.0; if (t <= -2.5e+30) tmp = c + t_2; elseif ((t <= 7.8e+40) || (~((t <= 4.8e+118)) && (t <= 5.8e+169))) tmp = (c + (x * y)) - t_1; else tmp = t_2 - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * b), $MachinePrecision] * 0.25), $MachinePrecision]}, Block[{t$95$2 = N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.5e+30], N[(c + t$95$2), $MachinePrecision], If[Or[LessEqual[t, 7.8e+40], And[N[Not[LessEqual[t, 4.8e+118]], $MachinePrecision], LessEqual[t, 5.8e+169]]], N[(N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(t$95$2 - t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot b\right) \cdot 0.25\\
t_2 := 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{if}\;t \leq -2.5 \cdot 10^{+30}:\\
\;\;\;\;c + t_2\\
\mathbf{elif}\;t \leq 7.8 \cdot 10^{+40} \lor \neg \left(t \leq 4.8 \cdot 10^{+118}\right) \land t \leq 5.8 \cdot 10^{+169}:\\
\;\;\;\;\left(c + x \cdot y\right) - t_1\\
\mathbf{else}:\\
\;\;\;\;t_2 - t_1\\
\end{array}
\end{array}
if t < -2.4999999999999999e30Initial program 92.9%
Taylor expanded in z around inf 69.4%
if -2.4999999999999999e30 < t < 7.8000000000000002e40 or 4.8e118 < t < 5.8000000000000001e169Initial program 98.6%
Taylor expanded in z around 0 92.1%
if 7.8000000000000002e40 < t < 4.8e118 or 5.8000000000000001e169 < t Initial program 93.6%
Taylor expanded in x around 0 79.3%
Taylor expanded in c around 0 72.3%
Final simplification82.3%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) 0.25)) (t_2 (- (* 0.0625 (* z t)) t_1)))
(if (<= y -3.1e-107)
(+ c (* x y))
(if (<= y 1.3e-221)
t_2
(if (<= y 5.2e-138)
(+ c (* a (* b -0.25)))
(if (<= y 5.8e+142) t_2 (- (* x y) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (a * b) * 0.25;
double t_2 = (0.0625 * (z * t)) - t_1;
double tmp;
if (y <= -3.1e-107) {
tmp = c + (x * y);
} else if (y <= 1.3e-221) {
tmp = t_2;
} else if (y <= 5.2e-138) {
tmp = c + (a * (b * -0.25));
} else if (y <= 5.8e+142) {
tmp = t_2;
} else {
tmp = (x * y) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (a * b) * 0.25d0
t_2 = (0.0625d0 * (z * t)) - t_1
if (y <= (-3.1d-107)) then
tmp = c + (x * y)
else if (y <= 1.3d-221) then
tmp = t_2
else if (y <= 5.2d-138) then
tmp = c + (a * (b * (-0.25d0)))
else if (y <= 5.8d+142) then
tmp = t_2
else
tmp = (x * y) - 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 t_1 = (a * b) * 0.25;
double t_2 = (0.0625 * (z * t)) - t_1;
double tmp;
if (y <= -3.1e-107) {
tmp = c + (x * y);
} else if (y <= 1.3e-221) {
tmp = t_2;
} else if (y <= 5.2e-138) {
tmp = c + (a * (b * -0.25));
} else if (y <= 5.8e+142) {
tmp = t_2;
} else {
tmp = (x * y) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) * 0.25 t_2 = (0.0625 * (z * t)) - t_1 tmp = 0 if y <= -3.1e-107: tmp = c + (x * y) elif y <= 1.3e-221: tmp = t_2 elif y <= 5.2e-138: tmp = c + (a * (b * -0.25)) elif y <= 5.8e+142: tmp = t_2 else: tmp = (x * y) - t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) * 0.25) t_2 = Float64(Float64(0.0625 * Float64(z * t)) - t_1) tmp = 0.0 if (y <= -3.1e-107) tmp = Float64(c + Float64(x * y)); elseif (y <= 1.3e-221) tmp = t_2; elseif (y <= 5.2e-138) tmp = Float64(c + Float64(a * Float64(b * -0.25))); elseif (y <= 5.8e+142) tmp = t_2; else tmp = Float64(Float64(x * y) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (a * b) * 0.25; t_2 = (0.0625 * (z * t)) - t_1; tmp = 0.0; if (y <= -3.1e-107) tmp = c + (x * y); elseif (y <= 1.3e-221) tmp = t_2; elseif (y <= 5.2e-138) tmp = c + (a * (b * -0.25)); elseif (y <= 5.8e+142) tmp = t_2; else tmp = (x * y) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * b), $MachinePrecision] * 0.25), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]}, If[LessEqual[y, -3.1e-107], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.3e-221], t$95$2, If[LessEqual[y, 5.2e-138], N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e+142], t$95$2, N[(N[(x * y), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot b\right) \cdot 0.25\\
t_2 := 0.0625 \cdot \left(z \cdot t\right) - t_1\\
\mathbf{if}\;y \leq -3.1 \cdot 10^{-107}:\\
\;\;\;\;c + x \cdot y\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{-221}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 5.2 \cdot 10^{-138}:\\
\;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+142}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;x \cdot y - t_1\\
\end{array}
\end{array}
if y < -3.10000000000000022e-107Initial program 93.4%
Taylor expanded in x around inf 54.4%
if -3.10000000000000022e-107 < y < 1.3000000000000001e-221 or 5.2e-138 < y < 5.80000000000000027e142Initial program 98.2%
Taylor expanded in x around 0 88.0%
Taylor expanded in c around 0 70.8%
if 1.3000000000000001e-221 < y < 5.2e-138Initial program 100.0%
Taylor expanded in a around inf 87.5%
*-commutative87.5%
associate-*r*87.5%
Simplified87.5%
if 5.80000000000000027e142 < y Initial program 94.7%
Taylor expanded in z around 0 94.7%
Taylor expanded in c around 0 81.0%
Final simplification67.4%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* x y) -1.32e+156)
(+ c (* x y))
(if (<= (* x y) 2.15e-188)
(+ c (* 0.0625 (* z t)))
(if (<= (* x y) 2.4e+113) (+ c (* a (* b -0.25))) (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -1.32e+156) {
tmp = c + (x * y);
} else if ((x * y) <= 2.15e-188) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 2.4e+113) {
tmp = c + (a * (b * -0.25));
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((x * y) <= (-1.32d+156)) then
tmp = c + (x * y)
else if ((x * y) <= 2.15d-188) then
tmp = c + (0.0625d0 * (z * t))
else if ((x * y) <= 2.4d+113) then
tmp = c + (a * (b * (-0.25d0)))
else
tmp = x * y
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 tmp;
if ((x * y) <= -1.32e+156) {
tmp = c + (x * y);
} else if ((x * y) <= 2.15e-188) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 2.4e+113) {
tmp = c + (a * (b * -0.25));
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -1.32e+156: tmp = c + (x * y) elif (x * y) <= 2.15e-188: tmp = c + (0.0625 * (z * t)) elif (x * y) <= 2.4e+113: tmp = c + (a * (b * -0.25)) else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -1.32e+156) tmp = Float64(c + Float64(x * y)); elseif (Float64(x * y) <= 2.15e-188) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); elseif (Float64(x * y) <= 2.4e+113) tmp = Float64(c + Float64(a * Float64(b * -0.25))); else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((x * y) <= -1.32e+156) tmp = c + (x * y); elseif ((x * y) <= 2.15e-188) tmp = c + (0.0625 * (z * t)); elseif ((x * y) <= 2.4e+113) tmp = c + (a * (b * -0.25)); else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -1.32e+156], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2.15e-188], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2.4e+113], N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.32 \cdot 10^{+156}:\\
\;\;\;\;c + x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 2.15 \cdot 10^{-188}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq 2.4 \cdot 10^{+113}:\\
\;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -1.3199999999999999e156Initial program 92.9%
Taylor expanded in x around inf 81.3%
if -1.3199999999999999e156 < (*.f64 x y) < 2.14999999999999994e-188Initial program 99.2%
Taylor expanded in z around inf 65.4%
if 2.14999999999999994e-188 < (*.f64 x y) < 2.39999999999999983e113Initial program 100.0%
Taylor expanded in a around inf 70.7%
*-commutative70.7%
associate-*r*70.7%
Simplified70.7%
if 2.39999999999999983e113 < (*.f64 x y) Initial program 87.7%
associate-+l-87.7%
associate--l+87.7%
fma-def91.8%
associate-*l/91.8%
fma-neg91.8%
sub-neg91.8%
distribute-neg-in91.8%
remove-double-neg91.8%
associate-/l*91.8%
distribute-frac-neg91.8%
associate-/r/91.8%
fma-def91.8%
neg-mul-191.8%
*-commutative91.8%
associate-/l*91.8%
metadata-eval91.8%
Simplified91.8%
fma-udef87.8%
fma-udef87.8%
associate-*l/87.8%
fma-udef87.7%
associate-/r/87.7%
associate-+r+87.7%
associate-*l/87.7%
fma-udef89.7%
+-commutative89.7%
fma-udef87.7%
associate-*l/87.7%
associate-+r+87.7%
div-inv87.7%
fma-def87.7%
clear-num87.8%
div-inv87.8%
metadata-eval87.8%
associate-*l/87.8%
Applied egg-rr87.8%
Taylor expanded in x around inf 67.8%
Final simplification69.3%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* x y) -5.6e+88)
(* x y)
(if (<= (* x y) -5.8e-99)
c
(if (<= (* x y) 3.5e+110) (* a (* b -0.25)) (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -5.6e+88) {
tmp = x * y;
} else if ((x * y) <= -5.8e-99) {
tmp = c;
} else if ((x * y) <= 3.5e+110) {
tmp = a * (b * -0.25);
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((x * y) <= (-5.6d+88)) then
tmp = x * y
else if ((x * y) <= (-5.8d-99)) then
tmp = c
else if ((x * y) <= 3.5d+110) then
tmp = a * (b * (-0.25d0))
else
tmp = x * y
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 tmp;
if ((x * y) <= -5.6e+88) {
tmp = x * y;
} else if ((x * y) <= -5.8e-99) {
tmp = c;
} else if ((x * y) <= 3.5e+110) {
tmp = a * (b * -0.25);
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -5.6e+88: tmp = x * y elif (x * y) <= -5.8e-99: tmp = c elif (x * y) <= 3.5e+110: tmp = a * (b * -0.25) else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -5.6e+88) tmp = Float64(x * y); elseif (Float64(x * y) <= -5.8e-99) tmp = c; elseif (Float64(x * y) <= 3.5e+110) tmp = Float64(a * Float64(b * -0.25)); else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((x * y) <= -5.6e+88) tmp = x * y; elseif ((x * y) <= -5.8e-99) tmp = c; elseif ((x * y) <= 3.5e+110) tmp = a * (b * -0.25); else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -5.6e+88], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -5.8e-99], c, If[LessEqual[N[(x * y), $MachinePrecision], 3.5e+110], N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision], N[(x * y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -5.6 \cdot 10^{+88}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq -5.8 \cdot 10^{-99}:\\
\;\;\;\;c\\
\mathbf{elif}\;x \cdot y \leq 3.5 \cdot 10^{+110}:\\
\;\;\;\;a \cdot \left(b \cdot -0.25\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -5.59999999999999977e88 or 3.4999999999999999e110 < (*.f64 x y) Initial program 91.1%
associate-+l-91.1%
associate--l+91.1%
fma-def95.0%
associate-*l/95.0%
fma-neg95.0%
sub-neg95.0%
distribute-neg-in95.0%
remove-double-neg95.0%
associate-/l*95.0%
distribute-frac-neg95.0%
associate-/r/95.0%
fma-def95.0%
neg-mul-195.0%
*-commutative95.0%
associate-/l*95.0%
metadata-eval95.0%
Simplified95.0%
fma-udef91.1%
fma-udef91.1%
associate-*l/91.1%
fma-udef91.1%
associate-/r/91.0%
associate-+r+91.0%
associate-*l/91.0%
fma-udef92.0%
+-commutative92.0%
fma-udef91.0%
associate-*l/91.0%
associate-+r+91.0%
div-inv91.0%
fma-def91.0%
clear-num91.1%
div-inv91.1%
metadata-eval91.1%
associate-*l/91.1%
Applied egg-rr91.1%
Taylor expanded in x around inf 65.4%
if -5.59999999999999977e88 < (*.f64 x y) < -5.79999999999999971e-99Initial program 100.0%
Taylor expanded in c around inf 42.3%
if -5.79999999999999971e-99 < (*.f64 x y) < 3.4999999999999999e110Initial program 99.2%
associate-+l-99.2%
associate--l+99.2%
fma-def99.2%
associate-*l/99.2%
fma-neg99.2%
sub-neg99.2%
distribute-neg-in99.2%
remove-double-neg99.2%
associate-/l*99.1%
distribute-frac-neg99.1%
associate-/r/99.2%
fma-def99.2%
neg-mul-199.2%
*-commutative99.2%
associate-/l*99.2%
metadata-eval99.2%
Simplified99.2%
fma-udef99.2%
fma-udef99.2%
associate-*l/99.2%
fma-udef99.2%
associate-/r/99.1%
associate-+r+99.1%
associate-*l/99.1%
fma-udef99.1%
+-commutative99.1%
fma-udef99.1%
associate-*l/99.1%
associate-+r+99.1%
div-inv99.2%
fma-def99.2%
clear-num99.2%
div-inv99.2%
metadata-eval99.2%
associate-*l/99.2%
Applied egg-rr99.2%
Taylor expanded in a around inf 37.6%
*-commutative37.6%
associate-*r*37.6%
*-commutative37.6%
Simplified37.6%
Final simplification49.1%
(FPCore (x y z t a b c) :precision binary64 (+ (+ c (/ a (/ -4.0 b))) (+ (* x y) (* t (* z 0.0625)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (c + (a / (-4.0 / b))) + ((x * y) + (t * (z * 0.0625)));
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (c + (a / ((-4.0d0) / b))) + ((x * y) + (t * (z * 0.0625d0)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (c + (a / (-4.0 / b))) + ((x * y) + (t * (z * 0.0625)));
}
def code(x, y, z, t, a, b, c): return (c + (a / (-4.0 / b))) + ((x * y) + (t * (z * 0.0625)))
function code(x, y, z, t, a, b, c) return Float64(Float64(c + Float64(a / Float64(-4.0 / b))) + Float64(Float64(x * y) + Float64(t * Float64(z * 0.0625)))) end
function tmp = code(x, y, z, t, a, b, c) tmp = (c + (a / (-4.0 / b))) + ((x * y) + (t * (z * 0.0625))); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(c + N[(a / N[(-4.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(c + \frac{a}{\frac{-4}{b}}\right) + \left(x \cdot y + t \cdot \left(z \cdot 0.0625\right)\right)
\end{array}
Initial program 96.1%
sub-neg96.1%
associate-+l+96.1%
fma-def96.5%
associate-*l/96.5%
distribute-frac-neg96.5%
distribute-rgt-neg-out96.5%
associate-/l*96.4%
neg-mul-196.4%
associate-/r*96.4%
metadata-eval96.4%
Simplified96.4%
fma-udef96.0%
*-commutative96.0%
div-inv96.0%
metadata-eval96.0%
Applied egg-rr96.0%
Final simplification96.0%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* x y) -3.65e+155) (not (<= (* x y) 2.05e+107))) (+ c (* x y)) (+ c (* 0.0625 (* z t)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (((x * y) <= -3.65e+155) || !((x * y) <= 2.05e+107)) {
tmp = c + (x * y);
} else {
tmp = c + (0.0625 * (z * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if (((x * y) <= (-3.65d+155)) .or. (.not. ((x * y) <= 2.05d+107))) then
tmp = c + (x * y)
else
tmp = c + (0.0625d0 * (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 tmp;
if (((x * y) <= -3.65e+155) || !((x * y) <= 2.05e+107)) {
tmp = c + (x * y);
} else {
tmp = c + (0.0625 * (z * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if ((x * y) <= -3.65e+155) or not ((x * y) <= 2.05e+107): tmp = c + (x * y) else: tmp = c + (0.0625 * (z * t)) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((Float64(x * y) <= -3.65e+155) || !(Float64(x * y) <= 2.05e+107)) tmp = Float64(c + Float64(x * y)); else tmp = Float64(c + Float64(0.0625 * Float64(z * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if (((x * y) <= -3.65e+155) || ~(((x * y) <= 2.05e+107))) tmp = c + (x * y); else tmp = c + (0.0625 * (z * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -3.65e+155], N[Not[LessEqual[N[(x * y), $MachinePrecision], 2.05e+107]], $MachinePrecision]], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -3.65 \cdot 10^{+155} \lor \neg \left(x \cdot y \leq 2.05 \cdot 10^{+107}\right):\\
\;\;\;\;c + x \cdot y\\
\mathbf{else}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -3.65000000000000019e155 or 2.05e107 < (*.f64 x y) Initial program 90.5%
Taylor expanded in x around inf 73.9%
if -3.65000000000000019e155 < (*.f64 x y) < 2.05e107Initial program 99.4%
Taylor expanded in z around inf 63.7%
Final simplification67.5%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (* x y))) (t_2 (* a (* b -0.25))))
(if (<= a -2.9e+108)
t_2
(if (<= a -2.7e-129)
t_1
(if (<= a -1.1e-182)
(* t (* z 0.0625))
(if (<= a 1.55e+61) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = c + (x * y);
double t_2 = a * (b * -0.25);
double tmp;
if (a <= -2.9e+108) {
tmp = t_2;
} else if (a <= -2.7e-129) {
tmp = t_1;
} else if (a <= -1.1e-182) {
tmp = t * (z * 0.0625);
} else if (a <= 1.55e+61) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = c + (x * y)
t_2 = a * (b * (-0.25d0))
if (a <= (-2.9d+108)) then
tmp = t_2
else if (a <= (-2.7d-129)) then
tmp = t_1
else if (a <= (-1.1d-182)) then
tmp = t * (z * 0.0625d0)
else if (a <= 1.55d+61) 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 t_1 = c + (x * y);
double t_2 = a * (b * -0.25);
double tmp;
if (a <= -2.9e+108) {
tmp = t_2;
} else if (a <= -2.7e-129) {
tmp = t_1;
} else if (a <= -1.1e-182) {
tmp = t * (z * 0.0625);
} else if (a <= 1.55e+61) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = c + (x * y) t_2 = a * (b * -0.25) tmp = 0 if a <= -2.9e+108: tmp = t_2 elif a <= -2.7e-129: tmp = t_1 elif a <= -1.1e-182: tmp = t * (z * 0.0625) elif a <= 1.55e+61: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(c + Float64(x * y)) t_2 = Float64(a * Float64(b * -0.25)) tmp = 0.0 if (a <= -2.9e+108) tmp = t_2; elseif (a <= -2.7e-129) tmp = t_1; elseif (a <= -1.1e-182) tmp = Float64(t * Float64(z * 0.0625)); elseif (a <= 1.55e+61) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = c + (x * y); t_2 = a * (b * -0.25); tmp = 0.0; if (a <= -2.9e+108) tmp = t_2; elseif (a <= -2.7e-129) tmp = t_1; elseif (a <= -1.1e-182) tmp = t * (z * 0.0625); elseif (a <= 1.55e+61) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.9e+108], t$95$2, If[LessEqual[a, -2.7e-129], t$95$1, If[LessEqual[a, -1.1e-182], N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.55e+61], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + x \cdot y\\
t_2 := a \cdot \left(b \cdot -0.25\right)\\
\mathbf{if}\;a \leq -2.9 \cdot 10^{+108}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;a \leq -2.7 \cdot 10^{-129}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -1.1 \cdot 10^{-182}:\\
\;\;\;\;t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{+61}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if a < -2.90000000000000007e108 or 1.55e61 < a Initial program 94.0%
associate-+l-94.0%
associate--l+94.0%
fma-def97.6%
associate-*l/97.6%
fma-neg97.6%
sub-neg97.6%
distribute-neg-in97.6%
remove-double-neg97.6%
associate-/l*97.5%
distribute-frac-neg97.5%
associate-/r/97.6%
fma-def97.6%
neg-mul-197.6%
*-commutative97.6%
associate-/l*97.6%
metadata-eval97.6%
Simplified97.6%
fma-udef94.0%
fma-udef94.0%
associate-*l/94.0%
fma-udef94.0%
associate-/r/93.9%
associate-+r+93.9%
associate-*l/93.9%
fma-udef93.9%
+-commutative93.9%
fma-udef93.9%
associate-*l/93.9%
associate-+r+93.9%
div-inv93.9%
fma-def94.0%
clear-num94.0%
div-inv94.0%
metadata-eval94.0%
associate-*l/94.0%
Applied egg-rr94.0%
Taylor expanded in a around inf 51.9%
*-commutative51.9%
associate-*r*51.9%
*-commutative51.9%
Simplified51.9%
if -2.90000000000000007e108 < a < -2.69999999999999999e-129 or -1.1e-182 < a < 1.55e61Initial program 96.8%
Taylor expanded in x around inf 56.6%
if -2.69999999999999999e-129 < a < -1.1e-182Initial program 100.0%
associate-+l-100.0%
associate--l+100.0%
fma-def100.0%
associate-*l/100.0%
fma-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
associate-/l*100.0%
distribute-frac-neg100.0%
associate-/r/100.0%
fma-def100.0%
neg-mul-1100.0%
*-commutative100.0%
associate-/l*100.0%
metadata-eval100.0%
Simplified100.0%
fma-udef100.0%
fma-udef100.0%
associate-*l/100.0%
fma-udef100.0%
associate-/r/100.0%
associate-+r+100.0%
associate-*l/100.0%
fma-udef100.0%
+-commutative100.0%
fma-udef100.0%
associate-*l/100.0%
associate-+r+100.0%
div-inv100.0%
fma-def100.0%
clear-num100.0%
div-inv100.0%
metadata-eval100.0%
associate-*l/100.0%
Applied egg-rr100.0%
Taylor expanded in t around inf 51.3%
*-commutative51.3%
associate-*r*51.3%
*-commutative51.3%
Simplified51.3%
Final simplification54.8%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* x y) -1.06e+89) (not (<= (* x y) 1.2e+112))) (* x y) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (((x * y) <= -1.06e+89) || !((x * y) <= 1.2e+112)) {
tmp = x * y;
} else {
tmp = c;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if (((x * y) <= (-1.06d+89)) .or. (.not. ((x * y) <= 1.2d+112))) then
tmp = x * y
else
tmp = c
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 tmp;
if (((x * y) <= -1.06e+89) || !((x * y) <= 1.2e+112)) {
tmp = x * y;
} else {
tmp = c;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if ((x * y) <= -1.06e+89) or not ((x * y) <= 1.2e+112): tmp = x * y else: tmp = c return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((Float64(x * y) <= -1.06e+89) || !(Float64(x * y) <= 1.2e+112)) tmp = Float64(x * y); else tmp = c; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if (((x * y) <= -1.06e+89) || ~(((x * y) <= 1.2e+112))) tmp = x * y; else tmp = c; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -1.06e+89], N[Not[LessEqual[N[(x * y), $MachinePrecision], 1.2e+112]], $MachinePrecision]], N[(x * y), $MachinePrecision], c]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.06 \cdot 10^{+89} \lor \neg \left(x \cdot y \leq 1.2 \cdot 10^{+112}\right):\\
\;\;\;\;x \cdot y\\
\mathbf{else}:\\
\;\;\;\;c\\
\end{array}
\end{array}
if (*.f64 x y) < -1.05999999999999997e89 or 1.2e112 < (*.f64 x y) Initial program 90.9%
associate-+l-90.9%
associate--l+90.9%
fma-def94.9%
associate-*l/94.9%
fma-neg94.9%
sub-neg94.9%
distribute-neg-in94.9%
remove-double-neg94.9%
associate-/l*94.9%
distribute-frac-neg94.9%
associate-/r/94.9%
fma-def94.9%
neg-mul-194.9%
*-commutative94.9%
associate-/l*94.9%
metadata-eval94.9%
Simplified94.9%
fma-udef90.9%
fma-udef90.9%
associate-*l/90.9%
fma-udef90.9%
associate-/r/90.8%
associate-+r+90.8%
associate-*l/90.8%
fma-udef91.9%
+-commutative91.9%
fma-udef90.8%
associate-*l/90.8%
associate-+r+90.8%
div-inv90.9%
fma-def90.9%
clear-num90.9%
div-inv90.9%
metadata-eval90.9%
associate-*l/90.9%
Applied egg-rr90.9%
Taylor expanded in x around inf 66.7%
if -1.05999999999999997e89 < (*.f64 x y) < 1.2e112Initial program 99.4%
Taylor expanded in c around inf 29.4%
Final simplification43.8%
(FPCore (x y z t a b c) :precision binary64 c)
double code(double x, double y, double z, double t, double a, double b, double c) {
return c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return c;
}
def code(x, y, z, t, a, b, c): return c
function code(x, y, z, t, a, b, c) return c end
function tmp = code(x, y, z, t, a, b, c) tmp = c; end
code[x_, y_, z_, t_, a_, b_, c_] := c
\begin{array}{l}
\\
c
\end{array}
Initial program 96.1%
Taylor expanded in c around inf 20.5%
Final simplification20.5%
herbie shell --seed 2023312
(FPCore (x y z t a b c)
:name "Diagrams.Solve.Polynomial:quartForm from diagrams-solve-0.1, C"
:precision binary64
(+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))