
(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 14 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 (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 97.3%
associate-+l-97.3%
associate--l+97.3%
fma-def98.1%
associate-*l/98.4%
fma-neg98.8%
sub-neg98.8%
distribute-neg-in98.8%
remove-double-neg98.8%
associate-/l*98.8%
distribute-frac-neg98.8%
associate-/r/98.8%
fma-def98.8%
neg-mul-198.8%
*-commutative98.8%
associate-/l*98.8%
metadata-eval98.8%
Simplified98.8%
Final simplification98.8%
(FPCore (x y z t a b c) :precision binary64 (+ (+ (fma a (* b -0.25) c) (* x y)) (* t (* z 0.0625))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (fma(a, (b * -0.25), c) + (x * y)) + (t * (z * 0.0625));
}
function code(x, y, z, t, a, b, c) return Float64(Float64(fma(a, Float64(b * -0.25), c) + Float64(x * y)) + Float64(t * Float64(z * 0.0625))) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\mathsf{fma}\left(a, b \cdot -0.25, c\right) + x \cdot y\right) + t \cdot \left(z \cdot 0.0625\right)
\end{array}
Initial program 97.3%
associate-+l-97.3%
associate--l+97.3%
fma-def98.1%
associate-*l/98.4%
fma-neg98.8%
sub-neg98.8%
distribute-neg-in98.8%
remove-double-neg98.8%
associate-/l*98.8%
distribute-frac-neg98.8%
associate-/r/98.8%
fma-def98.8%
neg-mul-198.8%
*-commutative98.8%
associate-/l*98.8%
metadata-eval98.8%
Simplified98.8%
fma-udef98.0%
fma-udef97.7%
associate-*l/97.3%
fma-udef97.3%
associate-/r/97.3%
associate-+r+97.3%
associate-*l/97.6%
fma-udef97.6%
+-commutative97.6%
fma-udef97.6%
associate-*l/97.3%
associate-+r+97.3%
div-inv97.3%
fma-def97.3%
clear-num97.3%
div-inv97.3%
metadata-eval97.3%
associate-*l/97.7%
Applied egg-rr97.7%
Final simplification97.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (* z (* t 0.0625))))
(t_2 (+ c (* a (* b -0.25))))
(t_3 (+ c (* x y))))
(if (<= (* x y) -1.85e+76)
t_3
(if (<= (* x y) -1e-82)
t_1
(if (<= (* x y) 6.2e-289)
t_2
(if (<= (* x y) 3.1e-175)
t_1
(if (<= (* x y) 7.2e-101)
t_2
(if (<= (* x y) 4.2e+156) t_1 t_3))))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = c + (z * (t * 0.0625));
double t_2 = c + (a * (b * -0.25));
double t_3 = c + (x * y);
double tmp;
if ((x * y) <= -1.85e+76) {
tmp = t_3;
} else if ((x * y) <= -1e-82) {
tmp = t_1;
} else if ((x * y) <= 6.2e-289) {
tmp = t_2;
} else if ((x * y) <= 3.1e-175) {
tmp = t_1;
} else if ((x * y) <= 7.2e-101) {
tmp = t_2;
} else if ((x * y) <= 4.2e+156) {
tmp = t_1;
} else {
tmp = t_3;
}
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) :: t_3
real(8) :: tmp
t_1 = c + (z * (t * 0.0625d0))
t_2 = c + (a * (b * (-0.25d0)))
t_3 = c + (x * y)
if ((x * y) <= (-1.85d+76)) then
tmp = t_3
else if ((x * y) <= (-1d-82)) then
tmp = t_1
else if ((x * y) <= 6.2d-289) then
tmp = t_2
else if ((x * y) <= 3.1d-175) then
tmp = t_1
else if ((x * y) <= 7.2d-101) then
tmp = t_2
else if ((x * y) <= 4.2d+156) then
tmp = t_1
else
tmp = t_3
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 + (z * (t * 0.0625));
double t_2 = c + (a * (b * -0.25));
double t_3 = c + (x * y);
double tmp;
if ((x * y) <= -1.85e+76) {
tmp = t_3;
} else if ((x * y) <= -1e-82) {
tmp = t_1;
} else if ((x * y) <= 6.2e-289) {
tmp = t_2;
} else if ((x * y) <= 3.1e-175) {
tmp = t_1;
} else if ((x * y) <= 7.2e-101) {
tmp = t_2;
} else if ((x * y) <= 4.2e+156) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = c + (z * (t * 0.0625)) t_2 = c + (a * (b * -0.25)) t_3 = c + (x * y) tmp = 0 if (x * y) <= -1.85e+76: tmp = t_3 elif (x * y) <= -1e-82: tmp = t_1 elif (x * y) <= 6.2e-289: tmp = t_2 elif (x * y) <= 3.1e-175: tmp = t_1 elif (x * y) <= 7.2e-101: tmp = t_2 elif (x * y) <= 4.2e+156: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(c + Float64(z * Float64(t * 0.0625))) t_2 = Float64(c + Float64(a * Float64(b * -0.25))) t_3 = Float64(c + Float64(x * y)) tmp = 0.0 if (Float64(x * y) <= -1.85e+76) tmp = t_3; elseif (Float64(x * y) <= -1e-82) tmp = t_1; elseif (Float64(x * y) <= 6.2e-289) tmp = t_2; elseif (Float64(x * y) <= 3.1e-175) tmp = t_1; elseif (Float64(x * y) <= 7.2e-101) tmp = t_2; elseif (Float64(x * y) <= 4.2e+156) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = c + (z * (t * 0.0625)); t_2 = c + (a * (b * -0.25)); t_3 = c + (x * y); tmp = 0.0; if ((x * y) <= -1.85e+76) tmp = t_3; elseif ((x * y) <= -1e-82) tmp = t_1; elseif ((x * y) <= 6.2e-289) tmp = t_2; elseif ((x * y) <= 3.1e-175) tmp = t_1; elseif ((x * y) <= 7.2e-101) tmp = t_2; elseif ((x * y) <= 4.2e+156) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1.85e+76], t$95$3, If[LessEqual[N[(x * y), $MachinePrecision], -1e-82], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 6.2e-289], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 3.1e-175], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 7.2e-101], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 4.2e+156], t$95$1, t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + z \cdot \left(t \cdot 0.0625\right)\\
t_2 := c + a \cdot \left(b \cdot -0.25\right)\\
t_3 := c + x \cdot y\\
\mathbf{if}\;x \cdot y \leq -1.85 \cdot 10^{+76}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;x \cdot y \leq -1 \cdot 10^{-82}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 6.2 \cdot 10^{-289}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \cdot y \leq 3.1 \cdot 10^{-175}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 7.2 \cdot 10^{-101}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \cdot y \leq 4.2 \cdot 10^{+156}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if (*.f64 x y) < -1.85e76 or 4.19999999999999963e156 < (*.f64 x y) Initial program 93.8%
Taylor expanded in x around inf 79.2%
if -1.85e76 < (*.f64 x y) < -1e-82 or 6.2e-289 < (*.f64 x y) < 3.09999999999999999e-175 or 7.19999999999999999e-101 < (*.f64 x y) < 4.19999999999999963e156Initial program 99.2%
Taylor expanded in z around inf 71.3%
*-commutative71.3%
*-commutative71.3%
associate-*l*72.1%
Simplified72.1%
if -1e-82 < (*.f64 x y) < 6.2e-289 or 3.09999999999999999e-175 < (*.f64 x y) < 7.19999999999999999e-101Initial program 98.6%
Taylor expanded in a around inf 81.7%
*-commutative81.7%
associate-*r*81.7%
Simplified81.7%
Final simplification77.1%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* z (* t 0.0625))) (t_2 (* b (* a -0.25))))
(if (<= (* x y) -4.7e+86)
(* x y)
(if (<= (* x y) -5.5e-87)
t_1
(if (<= (* x y) 2.2e-287)
t_2
(if (<= (* x y) 3e-176)
t_1
(if (<= (* x y) 14000000000.0)
t_2
(if (<= (* x y) 8e+156) t_1 (* x y)))))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = z * (t * 0.0625);
double t_2 = b * (a * -0.25);
double tmp;
if ((x * y) <= -4.7e+86) {
tmp = x * y;
} else if ((x * y) <= -5.5e-87) {
tmp = t_1;
} else if ((x * y) <= 2.2e-287) {
tmp = t_2;
} else if ((x * y) <= 3e-176) {
tmp = t_1;
} else if ((x * y) <= 14000000000.0) {
tmp = t_2;
} else if ((x * y) <= 8e+156) {
tmp = t_1;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = z * (t * 0.0625d0)
t_2 = b * (a * (-0.25d0))
if ((x * y) <= (-4.7d+86)) then
tmp = x * y
else if ((x * y) <= (-5.5d-87)) then
tmp = t_1
else if ((x * y) <= 2.2d-287) then
tmp = t_2
else if ((x * y) <= 3d-176) then
tmp = t_1
else if ((x * y) <= 14000000000.0d0) then
tmp = t_2
else if ((x * y) <= 8d+156) then
tmp = t_1
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 t_1 = z * (t * 0.0625);
double t_2 = b * (a * -0.25);
double tmp;
if ((x * y) <= -4.7e+86) {
tmp = x * y;
} else if ((x * y) <= -5.5e-87) {
tmp = t_1;
} else if ((x * y) <= 2.2e-287) {
tmp = t_2;
} else if ((x * y) <= 3e-176) {
tmp = t_1;
} else if ((x * y) <= 14000000000.0) {
tmp = t_2;
} else if ((x * y) <= 8e+156) {
tmp = t_1;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = z * (t * 0.0625) t_2 = b * (a * -0.25) tmp = 0 if (x * y) <= -4.7e+86: tmp = x * y elif (x * y) <= -5.5e-87: tmp = t_1 elif (x * y) <= 2.2e-287: tmp = t_2 elif (x * y) <= 3e-176: tmp = t_1 elif (x * y) <= 14000000000.0: tmp = t_2 elif (x * y) <= 8e+156: tmp = t_1 else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(z * Float64(t * 0.0625)) t_2 = Float64(b * Float64(a * -0.25)) tmp = 0.0 if (Float64(x * y) <= -4.7e+86) tmp = Float64(x * y); elseif (Float64(x * y) <= -5.5e-87) tmp = t_1; elseif (Float64(x * y) <= 2.2e-287) tmp = t_2; elseif (Float64(x * y) <= 3e-176) tmp = t_1; elseif (Float64(x * y) <= 14000000000.0) tmp = t_2; elseif (Float64(x * y) <= 8e+156) tmp = t_1; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = z * (t * 0.0625); t_2 = b * (a * -0.25); tmp = 0.0; if ((x * y) <= -4.7e+86) tmp = x * y; elseif ((x * y) <= -5.5e-87) tmp = t_1; elseif ((x * y) <= 2.2e-287) tmp = t_2; elseif ((x * y) <= 3e-176) tmp = t_1; elseif ((x * y) <= 14000000000.0) tmp = t_2; elseif ((x * y) <= 8e+156) tmp = t_1; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(a * -0.25), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -4.7e+86], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -5.5e-87], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 2.2e-287], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 3e-176], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 14000000000.0], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 8e+156], t$95$1, N[(x * y), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(t \cdot 0.0625\right)\\
t_2 := b \cdot \left(a \cdot -0.25\right)\\
\mathbf{if}\;x \cdot y \leq -4.7 \cdot 10^{+86}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq -5.5 \cdot 10^{-87}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 2.2 \cdot 10^{-287}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \cdot y \leq 3 \cdot 10^{-176}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 14000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \cdot y \leq 8 \cdot 10^{+156}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -4.7000000000000002e86 or 7.9999999999999999e156 < (*.f64 x y) Initial program 93.8%
Taylor expanded in z around 0 82.8%
Taylor expanded in c around 0 78.9%
Taylor expanded in x around inf 74.9%
if -4.7000000000000002e86 < (*.f64 x y) < -5.5000000000000004e-87 or 2.2e-287 < (*.f64 x y) < 3e-176 or 1.4e10 < (*.f64 x y) < 7.9999999999999999e156Initial program 99.0%
associate-+l-99.0%
associate--l+99.0%
fma-def99.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/99.0%
fma-udef99.0%
associate-/r/99.0%
associate-+r+99.0%
associate-*l/100.0%
fma-udef100.0%
+-commutative100.0%
fma-udef100.0%
associate-*l/99.0%
associate-+r+99.0%
div-inv99.0%
fma-def99.0%
clear-num99.0%
div-inv99.0%
metadata-eval99.0%
associate-*l/100.0%
Applied egg-rr100.0%
Taylor expanded in t around inf 43.9%
associate-*r*44.9%
*-commutative44.9%
*-commutative44.9%
*-commutative44.9%
Simplified44.9%
if -5.5000000000000004e-87 < (*.f64 x y) < 2.2e-287 or 3e-176 < (*.f64 x y) < 1.4e10Initial program 98.9%
associate-+l-98.9%
associate--l+98.9%
fma-def98.9%
associate-*l/98.9%
fma-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
associate-/l*99.8%
distribute-frac-neg99.8%
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-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.9%
fma-def98.9%
clear-num98.9%
div-inv98.9%
metadata-eval98.9%
associate-*l/98.9%
Applied egg-rr98.9%
Taylor expanded in x around 0 94.0%
+-commutative94.0%
*-commutative94.0%
associate-*r*94.0%
fma-udef94.0%
*-commutative94.0%
Simplified94.0%
Taylor expanded in a around inf 48.6%
associate-*r*48.6%
Simplified48.6%
Final simplification55.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (* z (* t 0.0625))))
(t_2 (+ (* x y) (* t (* z 0.0625))))
(t_3 (+ c (* a (* b -0.25)))))
(if (<= (* x y) -4.1e+88)
t_2
(if (<= (* x y) -1.3e-80)
t_1
(if (<= (* x y) 3.2e-288)
t_3
(if (<= (* x y) 4.6e-175) t_1 (if (<= (* x y) 1.35e-80) t_3 t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = c + (z * (t * 0.0625));
double t_2 = (x * y) + (t * (z * 0.0625));
double t_3 = c + (a * (b * -0.25));
double tmp;
if ((x * y) <= -4.1e+88) {
tmp = t_2;
} else if ((x * y) <= -1.3e-80) {
tmp = t_1;
} else if ((x * y) <= 3.2e-288) {
tmp = t_3;
} else if ((x * y) <= 4.6e-175) {
tmp = t_1;
} else if ((x * y) <= 1.35e-80) {
tmp = t_3;
} 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) :: t_3
real(8) :: tmp
t_1 = c + (z * (t * 0.0625d0))
t_2 = (x * y) + (t * (z * 0.0625d0))
t_3 = c + (a * (b * (-0.25d0)))
if ((x * y) <= (-4.1d+88)) then
tmp = t_2
else if ((x * y) <= (-1.3d-80)) then
tmp = t_1
else if ((x * y) <= 3.2d-288) then
tmp = t_3
else if ((x * y) <= 4.6d-175) then
tmp = t_1
else if ((x * y) <= 1.35d-80) then
tmp = t_3
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 + (z * (t * 0.0625));
double t_2 = (x * y) + (t * (z * 0.0625));
double t_3 = c + (a * (b * -0.25));
double tmp;
if ((x * y) <= -4.1e+88) {
tmp = t_2;
} else if ((x * y) <= -1.3e-80) {
tmp = t_1;
} else if ((x * y) <= 3.2e-288) {
tmp = t_3;
} else if ((x * y) <= 4.6e-175) {
tmp = t_1;
} else if ((x * y) <= 1.35e-80) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = c + (z * (t * 0.0625)) t_2 = (x * y) + (t * (z * 0.0625)) t_3 = c + (a * (b * -0.25)) tmp = 0 if (x * y) <= -4.1e+88: tmp = t_2 elif (x * y) <= -1.3e-80: tmp = t_1 elif (x * y) <= 3.2e-288: tmp = t_3 elif (x * y) <= 4.6e-175: tmp = t_1 elif (x * y) <= 1.35e-80: tmp = t_3 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(c + Float64(z * Float64(t * 0.0625))) t_2 = Float64(Float64(x * y) + Float64(t * Float64(z * 0.0625))) t_3 = Float64(c + Float64(a * Float64(b * -0.25))) tmp = 0.0 if (Float64(x * y) <= -4.1e+88) tmp = t_2; elseif (Float64(x * y) <= -1.3e-80) tmp = t_1; elseif (Float64(x * y) <= 3.2e-288) tmp = t_3; elseif (Float64(x * y) <= 4.6e-175) tmp = t_1; elseif (Float64(x * y) <= 1.35e-80) tmp = t_3; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = c + (z * (t * 0.0625)); t_2 = (x * y) + (t * (z * 0.0625)); t_3 = c + (a * (b * -0.25)); tmp = 0.0; if ((x * y) <= -4.1e+88) tmp = t_2; elseif ((x * y) <= -1.3e-80) tmp = t_1; elseif ((x * y) <= 3.2e-288) tmp = t_3; elseif ((x * y) <= 4.6e-175) tmp = t_1; elseif ((x * y) <= 1.35e-80) tmp = t_3; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] + N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -4.1e+88], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], -1.3e-80], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 3.2e-288], t$95$3, If[LessEqual[N[(x * y), $MachinePrecision], 4.6e-175], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.35e-80], t$95$3, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + z \cdot \left(t \cdot 0.0625\right)\\
t_2 := x \cdot y + t \cdot \left(z \cdot 0.0625\right)\\
t_3 := c + a \cdot \left(b \cdot -0.25\right)\\
\mathbf{if}\;x \cdot y \leq -4.1 \cdot 10^{+88}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \cdot y \leq -1.3 \cdot 10^{-80}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 3.2 \cdot 10^{-288}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;x \cdot y \leq 4.6 \cdot 10^{-175}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 1.35 \cdot 10^{-80}:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if (*.f64 x y) < -4.10000000000000028e88 or 1.3500000000000001e-80 < (*.f64 x y) Initial program 95.9%
associate-+l-95.9%
associate--l+95.9%
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-udef95.9%
fma-udef95.9%
associate-*l/95.9%
fma-udef95.9%
associate-/r/95.9%
associate-+r+95.9%
associate-*l/95.9%
fma-udef95.9%
+-commutative95.9%
fma-udef95.9%
associate-*l/95.9%
associate-+r+95.9%
div-inv95.9%
fma-def95.9%
clear-num95.9%
div-inv95.9%
metadata-eval95.9%
associate-*l/95.9%
Applied egg-rr95.9%
Taylor expanded in x around inf 76.5%
if -4.10000000000000028e88 < (*.f64 x y) < -1.3e-80 or 3.2e-288 < (*.f64 x y) < 4.6e-175Initial program 98.6%
Taylor expanded in z around inf 80.4%
*-commutative80.4%
*-commutative80.4%
associate-*l*81.8%
Simplified81.8%
if -1.3e-80 < (*.f64 x y) < 3.2e-288 or 4.6e-175 < (*.f64 x y) < 1.3500000000000001e-80Initial program 98.7%
Taylor expanded in a around inf 81.1%
*-commutative81.1%
associate-*r*81.1%
Simplified81.1%
Final simplification79.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* z (* t 0.0625))))
(if (<= (* x y) -2.8e+83)
(* x y)
(if (<= (* x y) 1.9e-279)
c
(if (<= (* x y) 5.6e-226)
t_1
(if (<= (* x y) 1.12e-85)
c
(if (<= (* x y) 4.5e+156) t_1 (* x y))))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = z * (t * 0.0625);
double tmp;
if ((x * y) <= -2.8e+83) {
tmp = x * y;
} else if ((x * y) <= 1.9e-279) {
tmp = c;
} else if ((x * y) <= 5.6e-226) {
tmp = t_1;
} else if ((x * y) <= 1.12e-85) {
tmp = c;
} else if ((x * y) <= 4.5e+156) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = z * (t * 0.0625d0)
if ((x * y) <= (-2.8d+83)) then
tmp = x * y
else if ((x * y) <= 1.9d-279) then
tmp = c
else if ((x * y) <= 5.6d-226) then
tmp = t_1
else if ((x * y) <= 1.12d-85) then
tmp = c
else if ((x * y) <= 4.5d+156) then
tmp = t_1
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 t_1 = z * (t * 0.0625);
double tmp;
if ((x * y) <= -2.8e+83) {
tmp = x * y;
} else if ((x * y) <= 1.9e-279) {
tmp = c;
} else if ((x * y) <= 5.6e-226) {
tmp = t_1;
} else if ((x * y) <= 1.12e-85) {
tmp = c;
} else if ((x * y) <= 4.5e+156) {
tmp = t_1;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = z * (t * 0.0625) tmp = 0 if (x * y) <= -2.8e+83: tmp = x * y elif (x * y) <= 1.9e-279: tmp = c elif (x * y) <= 5.6e-226: tmp = t_1 elif (x * y) <= 1.12e-85: tmp = c elif (x * y) <= 4.5e+156: tmp = t_1 else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(z * Float64(t * 0.0625)) tmp = 0.0 if (Float64(x * y) <= -2.8e+83) tmp = Float64(x * y); elseif (Float64(x * y) <= 1.9e-279) tmp = c; elseif (Float64(x * y) <= 5.6e-226) tmp = t_1; elseif (Float64(x * y) <= 1.12e-85) tmp = c; elseif (Float64(x * y) <= 4.5e+156) tmp = t_1; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = z * (t * 0.0625); tmp = 0.0; if ((x * y) <= -2.8e+83) tmp = x * y; elseif ((x * y) <= 1.9e-279) tmp = c; elseif ((x * y) <= 5.6e-226) tmp = t_1; elseif ((x * y) <= 1.12e-85) tmp = c; elseif ((x * y) <= 4.5e+156) tmp = t_1; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.8e+83], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.9e-279], c, If[LessEqual[N[(x * y), $MachinePrecision], 5.6e-226], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.12e-85], c, If[LessEqual[N[(x * y), $MachinePrecision], 4.5e+156], t$95$1, N[(x * y), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(t \cdot 0.0625\right)\\
\mathbf{if}\;x \cdot y \leq -2.8 \cdot 10^{+83}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 1.9 \cdot 10^{-279}:\\
\;\;\;\;c\\
\mathbf{elif}\;x \cdot y \leq 5.6 \cdot 10^{-226}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \cdot y \leq 1.12 \cdot 10^{-85}:\\
\;\;\;\;c\\
\mathbf{elif}\;x \cdot y \leq 4.5 \cdot 10^{+156}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -2.8e83 or 4.50000000000000031e156 < (*.f64 x y) Initial program 93.8%
Taylor expanded in z around 0 82.8%
Taylor expanded in c around 0 78.9%
Taylor expanded in x around inf 74.9%
if -2.8e83 < (*.f64 x y) < 1.90000000000000016e-279 or 5.60000000000000016e-226 < (*.f64 x y) < 1.12000000000000004e-85Initial program 98.6%
Taylor expanded in c around inf 36.7%
if 1.90000000000000016e-279 < (*.f64 x y) < 5.60000000000000016e-226 or 1.12000000000000004e-85 < (*.f64 x y) < 4.50000000000000031e156Initial 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-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 43.7%
associate-*r*43.7%
*-commutative43.7%
*-commutative43.7%
*-commutative43.7%
Simplified43.7%
Final simplification50.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 0.0625 (* z t))))
(if (or (<= (* x y) -2.3e+74) (not (<= (* x y) 5.6e+56)))
(+ c (+ (* x y) t_1))
(- (+ c t_1) (* 0.25 (* a b))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 0.0625 * (z * t);
double tmp;
if (((x * y) <= -2.3e+74) || !((x * y) <= 5.6e+56)) {
tmp = c + ((x * y) + t_1);
} else {
tmp = (c + t_1) - (0.25 * (a * b));
}
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 = 0.0625d0 * (z * t)
if (((x * y) <= (-2.3d+74)) .or. (.not. ((x * y) <= 5.6d+56))) then
tmp = c + ((x * y) + t_1)
else
tmp = (c + t_1) - (0.25d0 * (a * b))
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 = 0.0625 * (z * t);
double tmp;
if (((x * y) <= -2.3e+74) || !((x * y) <= 5.6e+56)) {
tmp = c + ((x * y) + t_1);
} else {
tmp = (c + t_1) - (0.25 * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = 0.0625 * (z * t) tmp = 0 if ((x * y) <= -2.3e+74) or not ((x * y) <= 5.6e+56): tmp = c + ((x * y) + t_1) else: tmp = (c + t_1) - (0.25 * (a * b)) return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(0.0625 * Float64(z * t)) tmp = 0.0 if ((Float64(x * y) <= -2.3e+74) || !(Float64(x * y) <= 5.6e+56)) tmp = Float64(c + Float64(Float64(x * y) + t_1)); else tmp = Float64(Float64(c + t_1) - Float64(0.25 * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = 0.0625 * (z * t); tmp = 0.0; if (((x * y) <= -2.3e+74) || ~(((x * y) <= 5.6e+56))) tmp = c + ((x * y) + t_1); else tmp = (c + t_1) - (0.25 * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[N[(x * y), $MachinePrecision], -2.3e+74], N[Not[LessEqual[N[(x * y), $MachinePrecision], 5.6e+56]], $MachinePrecision]], N[(c + N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(c + t$95$1), $MachinePrecision] - N[(0.25 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{if}\;x \cdot y \leq -2.3 \cdot 10^{+74} \lor \neg \left(x \cdot y \leq 5.6 \cdot 10^{+56}\right):\\
\;\;\;\;c + \left(x \cdot y + t_1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(c + t_1\right) - 0.25 \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -2.2999999999999999e74 or 5.60000000000000017e56 < (*.f64 x y) Initial program 94.9%
Taylor expanded in a around 0 89.6%
if -2.2999999999999999e74 < (*.f64 x y) < 5.60000000000000017e56Initial program 98.8%
Taylor expanded in x around 0 94.4%
Final simplification92.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* a (* b -0.25))))
(if (<= (* a b) -1e+137)
(+ (* t (* z 0.0625)) t_1)
(if (<= (* a b) 5e+162) (+ c (+ (* x y) (* 0.0625 (* z t)))) (+ c 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 ((a * b) <= -1e+137) {
tmp = (t * (z * 0.0625)) + t_1;
} else if ((a * b) <= 5e+162) {
tmp = c + ((x * y) + (0.0625 * (z * t)));
} else {
tmp = c + 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 ((a * b) <= (-1d+137)) then
tmp = (t * (z * 0.0625d0)) + t_1
else if ((a * b) <= 5d+162) then
tmp = c + ((x * y) + (0.0625d0 * (z * t)))
else
tmp = c + 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 ((a * b) <= -1e+137) {
tmp = (t * (z * 0.0625)) + t_1;
} else if ((a * b) <= 5e+162) {
tmp = c + ((x * y) + (0.0625 * (z * t)));
} else {
tmp = c + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = a * (b * -0.25) tmp = 0 if (a * b) <= -1e+137: tmp = (t * (z * 0.0625)) + t_1 elif (a * b) <= 5e+162: tmp = c + ((x * y) + (0.0625 * (z * t))) else: tmp = c + t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(a * Float64(b * -0.25)) tmp = 0.0 if (Float64(a * b) <= -1e+137) tmp = Float64(Float64(t * Float64(z * 0.0625)) + t_1); elseif (Float64(a * b) <= 5e+162) tmp = Float64(c + Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t)))); else tmp = Float64(c + 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 ((a * b) <= -1e+137) tmp = (t * (z * 0.0625)) + t_1; elseif ((a * b) <= 5e+162) tmp = c + ((x * y) + (0.0625 * (z * t))); else tmp = c + t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -1e+137], N[(N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+162], N[(c + N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c + t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot -0.25\right)\\
\mathbf{if}\;a \cdot b \leq -1 \cdot 10^{+137}:\\
\;\;\;\;t \cdot \left(z \cdot 0.0625\right) + t_1\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+162}:\\
\;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\
\mathbf{else}:\\
\;\;\;\;c + t_1\\
\end{array}
\end{array}
if (*.f64 a b) < -1e137Initial program 93.7%
associate-+l-93.7%
associate--l+93.7%
fma-def95.8%
associate-*l/95.8%
fma-neg95.8%
sub-neg95.8%
distribute-neg-in95.8%
remove-double-neg95.8%
associate-/l*95.7%
distribute-frac-neg95.7%
associate-/r/95.8%
fma-def95.8%
neg-mul-195.8%
*-commutative95.8%
associate-/l*95.8%
metadata-eval95.8%
Simplified95.8%
fma-udef93.8%
fma-udef93.8%
associate-*l/93.8%
fma-udef93.7%
associate-/r/93.7%
associate-+r+93.7%
associate-*l/93.7%
fma-udef93.7%
+-commutative93.7%
fma-udef93.7%
associate-*l/93.7%
associate-+r+93.7%
div-inv93.7%
fma-def93.7%
clear-num93.8%
div-inv93.8%
metadata-eval93.8%
associate-*l/93.8%
Applied egg-rr93.8%
Taylor expanded in a around inf 82.8%
*-commutative82.8%
associate-*r*82.8%
*-commutative82.8%
Simplified82.8%
if -1e137 < (*.f64 a b) < 4.9999999999999997e162Initial program 99.6%
Taylor expanded in a around 0 91.1%
if 4.9999999999999997e162 < (*.f64 a b) Initial program 89.3%
Taylor expanded in a around inf 79.2%
*-commutative79.2%
associate-*r*79.2%
Simplified79.2%
Final simplification88.3%
(FPCore (x y z t a b c) :precision binary64 (+ c (+ (* t (* z 0.0625)) (- (* x y) (/ a (/ 4.0 b))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return c + ((t * (z * 0.0625)) + ((x * y) - (a / (4.0 / b))));
}
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 + ((t * (z * 0.0625d0)) + ((x * y) - (a / (4.0d0 / b))))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return c + ((t * (z * 0.0625)) + ((x * y) - (a / (4.0 / b))));
}
def code(x, y, z, t, a, b, c): return c + ((t * (z * 0.0625)) + ((x * y) - (a / (4.0 / b))))
function code(x, y, z, t, a, b, c) return Float64(c + Float64(Float64(t * Float64(z * 0.0625)) + Float64(Float64(x * y) - Float64(a / Float64(4.0 / b))))) end
function tmp = code(x, y, z, t, a, b, c) tmp = c + ((t * (z * 0.0625)) + ((x * y) - (a / (4.0 / b)))); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(c + N[(N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] - N[(a / N[(4.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c + \left(t \cdot \left(z \cdot 0.0625\right) + \left(x \cdot y - \frac{a}{\frac{4}{b}}\right)\right)
\end{array}
Initial program 97.3%
+-commutative97.3%
associate--l+97.3%
associate-*l/97.6%
*-commutative97.6%
div-inv97.6%
metadata-eval97.6%
associate-/l*97.6%
Applied egg-rr97.6%
Final simplification97.6%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* x y) -1.5e+76) (not (<= (* x y) 1.02e+58))) (+ c (* x y)) (+ c (* a (* b -0.25)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (((x * y) <= -1.5e+76) || !((x * y) <= 1.02e+58)) {
tmp = c + (x * y);
} else {
tmp = c + (a * (b * -0.25));
}
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.5d+76)) .or. (.not. ((x * y) <= 1.02d+58))) then
tmp = c + (x * y)
else
tmp = c + (a * (b * (-0.25d0)))
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.5e+76) || !((x * y) <= 1.02e+58)) {
tmp = c + (x * y);
} else {
tmp = c + (a * (b * -0.25));
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if ((x * y) <= -1.5e+76) or not ((x * y) <= 1.02e+58): tmp = c + (x * y) else: tmp = c + (a * (b * -0.25)) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((Float64(x * y) <= -1.5e+76) || !(Float64(x * y) <= 1.02e+58)) tmp = Float64(c + Float64(x * y)); else tmp = Float64(c + Float64(a * Float64(b * -0.25))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if (((x * y) <= -1.5e+76) || ~(((x * y) <= 1.02e+58))) tmp = c + (x * y); else tmp = c + (a * (b * -0.25)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -1.5e+76], N[Not[LessEqual[N[(x * y), $MachinePrecision], 1.02e+58]], $MachinePrecision]], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.5 \cdot 10^{+76} \lor \neg \left(x \cdot y \leq 1.02 \cdot 10^{+58}\right):\\
\;\;\;\;c + x \cdot y\\
\mathbf{else}:\\
\;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -1.4999999999999999e76 or 1.02000000000000005e58 < (*.f64 x y) Initial program 94.9%
Taylor expanded in x around inf 73.8%
if -1.4999999999999999e76 < (*.f64 x y) < 1.02000000000000005e58Initial program 98.8%
Taylor expanded in a around inf 65.6%
*-commutative65.6%
associate-*r*65.6%
Simplified65.6%
Final simplification68.7%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= z -3.8e+57) (not (<= z 2.5e-84))) (+ c (+ (* x y) (* 0.0625 (* z t)))) (- (+ c (* x y)) (* 0.25 (* a b)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((z <= -3.8e+57) || !(z <= 2.5e-84)) {
tmp = c + ((x * y) + (0.0625 * (z * t)));
} else {
tmp = (c + (x * y)) - (0.25 * (a * b));
}
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 ((z <= (-3.8d+57)) .or. (.not. (z <= 2.5d-84))) then
tmp = c + ((x * y) + (0.0625d0 * (z * t)))
else
tmp = (c + (x * y)) - (0.25d0 * (a * b))
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 ((z <= -3.8e+57) || !(z <= 2.5e-84)) {
tmp = c + ((x * y) + (0.0625 * (z * t)));
} else {
tmp = (c + (x * y)) - (0.25 * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (z <= -3.8e+57) or not (z <= 2.5e-84): tmp = c + ((x * y) + (0.0625 * (z * t))) else: tmp = (c + (x * y)) - (0.25 * (a * b)) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((z <= -3.8e+57) || !(z <= 2.5e-84)) tmp = Float64(c + Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t)))); else tmp = Float64(Float64(c + Float64(x * y)) - Float64(0.25 * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((z <= -3.8e+57) || ~((z <= 2.5e-84))) tmp = c + ((x * y) + (0.0625 * (z * t))); else tmp = (c + (x * y)) - (0.25 * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[z, -3.8e+57], N[Not[LessEqual[z, 2.5e-84]], $MachinePrecision]], N[(c + N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision] - N[(0.25 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.8 \cdot 10^{+57} \lor \neg \left(z \leq 2.5 \cdot 10^{-84}\right):\\
\;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(c + x \cdot y\right) - 0.25 \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if z < -3.7999999999999999e57 or 2.5000000000000001e-84 < z Initial program 96.8%
Taylor expanded in a around 0 76.4%
if -3.7999999999999999e57 < z < 2.5000000000000001e-84Initial program 97.8%
Taylor expanded in z around 0 92.2%
Final simplification84.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (* x y))) (t_2 (* z (* t 0.0625))))
(if (<= t -8200000000.0)
t_2
(if (<= t 0.03)
t_1
(if (<= t 3.2e+67) (* b (* a -0.25)) (if (<= t 1.4e+189) 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 = z * (t * 0.0625);
double tmp;
if (t <= -8200000000.0) {
tmp = t_2;
} else if (t <= 0.03) {
tmp = t_1;
} else if (t <= 3.2e+67) {
tmp = b * (a * -0.25);
} else if (t <= 1.4e+189) {
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 = z * (t * 0.0625d0)
if (t <= (-8200000000.0d0)) then
tmp = t_2
else if (t <= 0.03d0) then
tmp = t_1
else if (t <= 3.2d+67) then
tmp = b * (a * (-0.25d0))
else if (t <= 1.4d+189) 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 = z * (t * 0.0625);
double tmp;
if (t <= -8200000000.0) {
tmp = t_2;
} else if (t <= 0.03) {
tmp = t_1;
} else if (t <= 3.2e+67) {
tmp = b * (a * -0.25);
} else if (t <= 1.4e+189) {
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 = z * (t * 0.0625) tmp = 0 if t <= -8200000000.0: tmp = t_2 elif t <= 0.03: tmp = t_1 elif t <= 3.2e+67: tmp = b * (a * -0.25) elif t <= 1.4e+189: 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(z * Float64(t * 0.0625)) tmp = 0.0 if (t <= -8200000000.0) tmp = t_2; elseif (t <= 0.03) tmp = t_1; elseif (t <= 3.2e+67) tmp = Float64(b * Float64(a * -0.25)); elseif (t <= 1.4e+189) 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 = z * (t * 0.0625); tmp = 0.0; if (t <= -8200000000.0) tmp = t_2; elseif (t <= 0.03) tmp = t_1; elseif (t <= 3.2e+67) tmp = b * (a * -0.25); elseif (t <= 1.4e+189) 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[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8200000000.0], t$95$2, If[LessEqual[t, 0.03], t$95$1, If[LessEqual[t, 3.2e+67], N[(b * N[(a * -0.25), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.4e+189], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + x \cdot y\\
t_2 := z \cdot \left(t \cdot 0.0625\right)\\
\mathbf{if}\;t \leq -8200000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 0.03:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+67}:\\
\;\;\;\;b \cdot \left(a \cdot -0.25\right)\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{+189}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -8.2e9 or 1.40000000000000003e189 < t Initial program 95.5%
associate-+l-95.5%
associate--l+95.5%
fma-def95.5%
associate-*l/96.4%
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.6%
neg-mul-197.6%
*-commutative97.6%
associate-/l*97.6%
metadata-eval97.6%
Simplified97.6%
fma-udef97.6%
fma-udef96.4%
associate-*l/95.5%
fma-udef95.5%
associate-/r/95.4%
associate-+r+95.4%
associate-*l/96.4%
fma-udef96.4%
+-commutative96.4%
fma-udef96.4%
associate-*l/95.4%
associate-+r+95.4%
div-inv95.4%
fma-def95.4%
clear-num95.5%
div-inv95.5%
metadata-eval95.5%
associate-*l/96.4%
Applied egg-rr96.4%
Taylor expanded in t around inf 51.4%
associate-*r*52.3%
*-commutative52.3%
*-commutative52.3%
*-commutative52.3%
Simplified52.3%
if -8.2e9 < t < 0.029999999999999999 or 3.19999999999999983e67 < t < 1.40000000000000003e189Initial program 98.1%
Taylor expanded in x around inf 58.9%
if 0.029999999999999999 < t < 3.19999999999999983e67Initial program 99.9%
associate-+l-99.9%
associate--l+99.9%
fma-def99.9%
associate-*l/99.9%
fma-neg99.9%
sub-neg99.9%
distribute-neg-in99.9%
remove-double-neg99.9%
associate-/l*99.8%
distribute-frac-neg99.8%
associate-/r/99.9%
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-udef99.9%
associate-/r/99.8%
associate-+r+99.8%
associate-*l/99.8%
fma-udef99.8%
+-commutative99.8%
fma-udef99.8%
associate-*l/99.8%
associate-+r+99.8%
div-inv99.9%
fma-def99.9%
clear-num100.0%
div-inv100.0%
metadata-eval100.0%
associate-*l/100.0%
Applied egg-rr100.0%
Taylor expanded in x around 0 86.7%
+-commutative86.7%
*-commutative86.7%
associate-*r*86.7%
fma-udef86.8%
*-commutative86.8%
Simplified86.8%
Taylor expanded in a around inf 46.3%
associate-*r*46.3%
Simplified46.3%
Final simplification56.0%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* x y) -1.3e+85) (not (<= (* x y) 2e+149))) (* 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.3e+85) || !((x * y) <= 2e+149)) {
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.3d+85)) .or. (.not. ((x * y) <= 2d+149))) 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.3e+85) || !((x * y) <= 2e+149)) {
tmp = x * y;
} else {
tmp = c;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if ((x * y) <= -1.3e+85) or not ((x * y) <= 2e+149): 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.3e+85) || !(Float64(x * y) <= 2e+149)) 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.3e+85) || ~(((x * y) <= 2e+149))) 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.3e+85], N[Not[LessEqual[N[(x * y), $MachinePrecision], 2e+149]], $MachinePrecision]], N[(x * y), $MachinePrecision], c]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.3 \cdot 10^{+85} \lor \neg \left(x \cdot y \leq 2 \cdot 10^{+149}\right):\\
\;\;\;\;x \cdot y\\
\mathbf{else}:\\
\;\;\;\;c\\
\end{array}
\end{array}
if (*.f64 x y) < -1.30000000000000005e85 or 2.0000000000000001e149 < (*.f64 x y) Initial program 94.0%
Taylor expanded in z around 0 82.3%
Taylor expanded in c around 0 78.5%
Taylor expanded in x around inf 73.4%
if -1.30000000000000005e85 < (*.f64 x y) < 2.0000000000000001e149Initial program 98.9%
Taylor expanded in c around inf 31.5%
Final simplification45.1%
(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 97.3%
Taylor expanded in c around inf 23.3%
Final simplification23.3%
herbie shell --seed 2023334
(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))