
(FPCore (x y z t a) :precision binary64 (/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))
double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
real(8) function code(x, y, z, t, a)
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
code = ((x * y) - ((z * 9.0d0) * t)) / (a * 2.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
def code(x, y, z, t, a): return ((x * y) - ((z * 9.0) * t)) / (a * 2.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) - Float64(Float64(z * 9.0) * t)) / Float64(a * 2.0)) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) - ((z * 9.0) * t)) / (a * 2.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] - N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y - \left(z \cdot 9\right) \cdot t}{a \cdot 2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))
double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
real(8) function code(x, y, z, t, a)
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
code = ((x * y) - ((z * 9.0d0) * t)) / (a * 2.0d0)
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) - ((z * 9.0) * t)) / (a * 2.0);
}
def code(x, y, z, t, a): return ((x * y) - ((z * 9.0) * t)) / (a * 2.0)
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) - Float64(Float64(z * 9.0) * t)) / Float64(a * 2.0)) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) - ((z * 9.0) * t)) / (a * 2.0); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] - N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y - \left(z \cdot 9\right) \cdot t}{a \cdot 2}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* x y) (* (* z 9.0) t))))
(if (or (<= t_1 (- INFINITY)) (not (<= t_1 1e+270)))
(* z (fma -4.5 (/ t a) (* x (* (/ y (* z a)) 0.5))))
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (x * y) - ((z * 9.0) * t);
double tmp;
if ((t_1 <= -((double) INFINITY)) || !(t_1 <= 1e+270)) {
tmp = z * fma(-4.5, (t / a), (x * ((y / (z * a)) * 0.5)));
} else {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(x * y) - Float64(Float64(z * 9.0) * t)) tmp = 0.0 if ((t_1 <= Float64(-Inf)) || !(t_1 <= 1e+270)) tmp = Float64(z * fma(-4.5, Float64(t / a), Float64(x * Float64(Float64(y / Float64(z * a)) * 0.5)))); else tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] - N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, (-Infinity)], N[Not[LessEqual[t$95$1, 1e+270]], $MachinePrecision]], N[(z * N[(-4.5 * N[(t / a), $MachinePrecision] + N[(x * N[(N[(y / N[(z * a), $MachinePrecision]), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y - \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty \lor \neg \left(t\_1 \leq 10^{+270}\right):\\
\;\;\;\;z \cdot \mathsf{fma}\left(-4.5, \frac{t}{a}, x \cdot \left(\frac{y}{z \cdot a} \cdot 0.5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\end{array}
\end{array}
if (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < -inf.0 or 1e270 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) Initial program 67.6%
div-sub64.2%
*-commutative64.2%
div-sub67.6%
cancel-sign-sub-inv67.6%
*-commutative67.6%
fma-define69.3%
distribute-rgt-neg-in69.3%
associate-*r*69.3%
distribute-lft-neg-in69.3%
*-commutative69.3%
distribute-rgt-neg-in69.3%
metadata-eval69.3%
Simplified69.3%
Taylor expanded in z around inf 85.2%
fma-define85.2%
*-commutative85.2%
associate-/l*93.1%
associate-*l*93.1%
*-commutative93.1%
Simplified93.1%
if -inf.0 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < 1e270Initial program 98.3%
div-sub97.9%
*-commutative97.9%
div-sub98.3%
cancel-sign-sub-inv98.3%
*-commutative98.3%
fma-define98.3%
distribute-rgt-neg-in98.3%
associate-*r*98.4%
distribute-lft-neg-in98.4%
*-commutative98.4%
distribute-rgt-neg-in98.4%
metadata-eval98.4%
Simplified98.4%
*-commutative98.4%
associate-*r*98.3%
metadata-eval98.3%
distribute-rgt-neg-in98.3%
distribute-lft-neg-in98.3%
fma-neg98.3%
associate-*l*98.4%
Applied egg-rr98.4%
Final simplification97.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (* z 9.0) t)))
(if (<= t_1 (- INFINITY))
(* -4.5 (* z (/ t a)))
(if (<= t_1 2e+185)
(/ (fma x y (* z (* t -9.0))) (* a 2.0))
(* z (+ (* -4.5 (/ t a)) (* 0.5 (/ (* x y) (* z a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * 9.0) * t;
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = -4.5 * (z * (t / a));
} else if (t_1 <= 2e+185) {
tmp = fma(x, y, (z * (t * -9.0))) / (a * 2.0);
} else {
tmp = z * ((-4.5 * (t / a)) + (0.5 * ((x * y) / (z * a))));
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z * 9.0) * t) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); elseif (t_1 <= 2e+185) tmp = Float64(fma(x, y, Float64(z * Float64(t * -9.0))) / Float64(a * 2.0)); else tmp = Float64(z * Float64(Float64(-4.5 * Float64(t / a)) + Float64(0.5 * Float64(Float64(x * y) / Float64(z * a))))); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+185], N[(N[(x * y + N[(z * N[(t * -9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(-4.5 * N[(t / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(x * y), $MachinePrecision] / N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+185}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t \cdot -9\right)\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(-4.5 \cdot \frac{t}{a} + 0.5 \cdot \frac{x \cdot y}{z \cdot a}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 z #s(literal 9 binary64)) t) < -inf.0Initial program 67.7%
div-sub63.6%
*-commutative63.6%
div-sub67.7%
cancel-sign-sub-inv67.7%
*-commutative67.7%
fma-define71.9%
distribute-rgt-neg-in71.9%
associate-*r*71.9%
distribute-lft-neg-in71.9%
*-commutative71.9%
distribute-rgt-neg-in71.9%
metadata-eval71.9%
Simplified71.9%
Taylor expanded in x around 0 71.9%
associate-*r/71.9%
associate-*r*71.9%
associate-*l/91.4%
associate-*r/91.4%
associate-*l*91.6%
Simplified91.6%
if -inf.0 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) < 2e185Initial program 95.5%
div-sub94.5%
*-commutative94.5%
div-sub95.5%
cancel-sign-sub-inv95.5%
*-commutative95.5%
fma-define95.5%
distribute-rgt-neg-in95.5%
associate-*r*95.6%
distribute-lft-neg-in95.6%
*-commutative95.6%
distribute-rgt-neg-in95.6%
metadata-eval95.6%
Simplified95.6%
if 2e185 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) Initial program 84.3%
div-sub84.3%
*-commutative84.3%
div-sub84.3%
cancel-sign-sub-inv84.3%
*-commutative84.3%
fma-define84.3%
distribute-rgt-neg-in84.3%
associate-*r*84.3%
distribute-lft-neg-in84.3%
*-commutative84.3%
distribute-rgt-neg-in84.3%
metadata-eval84.3%
Simplified84.3%
Taylor expanded in z around inf 97.0%
Final simplification95.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (* z 9.0) t)))
(if (<= t_1 (- INFINITY))
(* -4.5 (* z (/ t a)))
(if (<= t_1 2e+185)
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))
(* z (+ (* -4.5 (/ t a)) (* 0.5 (/ (* x y) (* z a)))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * 9.0) * t;
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = -4.5 * (z * (t / a));
} else if (t_1 <= 2e+185) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = z * ((-4.5 * (t / a)) + (0.5 * ((x * y) / (z * a))));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * 9.0) * t;
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = -4.5 * (z * (t / a));
} else if (t_1 <= 2e+185) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = z * ((-4.5 * (t / a)) + (0.5 * ((x * y) / (z * a))));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * 9.0) * t tmp = 0 if t_1 <= -math.inf: tmp = -4.5 * (z * (t / a)) elif t_1 <= 2e+185: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) else: tmp = z * ((-4.5 * (t / a)) + (0.5 * ((x * y) / (z * a)))) return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * 9.0) * t) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); elseif (t_1 <= 2e+185) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); else tmp = Float64(z * Float64(Float64(-4.5 * Float64(t / a)) + Float64(0.5 * Float64(Float64(x * y) / Float64(z * a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * 9.0) * t; tmp = 0.0; if (t_1 <= -Inf) tmp = -4.5 * (z * (t / a)); elseif (t_1 <= 2e+185) tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0); else tmp = z * ((-4.5 * (t / a)) + (0.5 * ((x * y) / (z * a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+185], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(-4.5 * N[(t / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(x * y), $MachinePrecision] / N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+185}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(-4.5 \cdot \frac{t}{a} + 0.5 \cdot \frac{x \cdot y}{z \cdot a}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 z #s(literal 9 binary64)) t) < -inf.0Initial program 67.7%
div-sub63.6%
*-commutative63.6%
div-sub67.7%
cancel-sign-sub-inv67.7%
*-commutative67.7%
fma-define71.9%
distribute-rgt-neg-in71.9%
associate-*r*71.9%
distribute-lft-neg-in71.9%
*-commutative71.9%
distribute-rgt-neg-in71.9%
metadata-eval71.9%
Simplified71.9%
Taylor expanded in x around 0 71.9%
associate-*r/71.9%
associate-*r*71.9%
associate-*l/91.4%
associate-*r/91.4%
associate-*l*91.6%
Simplified91.6%
if -inf.0 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) < 2e185Initial program 95.5%
div-sub94.5%
*-commutative94.5%
div-sub95.5%
cancel-sign-sub-inv95.5%
*-commutative95.5%
fma-define95.5%
distribute-rgt-neg-in95.5%
associate-*r*95.6%
distribute-lft-neg-in95.6%
*-commutative95.6%
distribute-rgt-neg-in95.6%
metadata-eval95.6%
Simplified95.6%
*-commutative95.6%
associate-*r*95.5%
metadata-eval95.5%
distribute-rgt-neg-in95.5%
distribute-lft-neg-in95.5%
fma-neg95.5%
associate-*l*95.6%
Applied egg-rr95.6%
if 2e185 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) Initial program 84.3%
div-sub84.3%
*-commutative84.3%
div-sub84.3%
cancel-sign-sub-inv84.3%
*-commutative84.3%
fma-define84.3%
distribute-rgt-neg-in84.3%
associate-*r*84.3%
distribute-lft-neg-in84.3%
*-commutative84.3%
distribute-rgt-neg-in84.3%
metadata-eval84.3%
Simplified84.3%
Taylor expanded in z around inf 97.0%
Final simplification95.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* (* z 9.0) t)))
(if (<= t_1 (- INFINITY))
(* -4.5 (* z (/ t a)))
(if (<= t_1 1e+234)
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))
(* t (/ -4.5 (/ a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * 9.0) * t;
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = -4.5 * (z * (t / a));
} else if (t_1 <= 1e+234) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = t * (-4.5 / (a / z));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * 9.0) * t;
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = -4.5 * (z * (t / a));
} else if (t_1 <= 1e+234) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = t * (-4.5 / (a / z));
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * 9.0) * t tmp = 0 if t_1 <= -math.inf: tmp = -4.5 * (z * (t / a)) elif t_1 <= 1e+234: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) else: tmp = t * (-4.5 / (a / z)) return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * 9.0) * t) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(-4.5 * Float64(z * Float64(t / a))); elseif (t_1 <= 1e+234) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); else tmp = Float64(t * Float64(-4.5 / Float64(a / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * 9.0) * t; tmp = 0.0; if (t_1 <= -Inf) tmp = -4.5 * (z * (t / a)); elseif (t_1 <= 1e+234) tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0); else tmp = t * (-4.5 / (a / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * 9.0), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+234], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(t * N[(-4.5 / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\mathbf{elif}\;t\_1 \leq 10^{+234}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{-4.5}{\frac{a}{z}}\\
\end{array}
\end{array}
if (*.f64 (*.f64 z #s(literal 9 binary64)) t) < -inf.0Initial program 67.7%
div-sub63.6%
*-commutative63.6%
div-sub67.7%
cancel-sign-sub-inv67.7%
*-commutative67.7%
fma-define71.9%
distribute-rgt-neg-in71.9%
associate-*r*71.9%
distribute-lft-neg-in71.9%
*-commutative71.9%
distribute-rgt-neg-in71.9%
metadata-eval71.9%
Simplified71.9%
Taylor expanded in x around 0 71.9%
associate-*r/71.9%
associate-*r*71.9%
associate-*l/91.4%
associate-*r/91.4%
associate-*l*91.6%
Simplified91.6%
if -inf.0 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) < 1.00000000000000002e234Initial program 95.6%
div-sub94.7%
*-commutative94.7%
div-sub95.6%
cancel-sign-sub-inv95.6%
*-commutative95.6%
fma-define95.6%
distribute-rgt-neg-in95.6%
associate-*r*95.7%
distribute-lft-neg-in95.7%
*-commutative95.7%
distribute-rgt-neg-in95.7%
metadata-eval95.7%
Simplified95.7%
*-commutative95.7%
associate-*r*95.6%
metadata-eval95.6%
distribute-rgt-neg-in95.6%
distribute-lft-neg-in95.6%
fma-neg95.6%
associate-*l*95.7%
Applied egg-rr95.7%
if 1.00000000000000002e234 < (*.f64 (*.f64 z #s(literal 9 binary64)) t) Initial program 80.1%
div-sub80.1%
*-commutative80.1%
div-sub80.1%
cancel-sign-sub-inv80.1%
*-commutative80.1%
fma-define80.1%
distribute-rgt-neg-in80.1%
associate-*r*80.1%
distribute-lft-neg-in80.1%
*-commutative80.1%
distribute-rgt-neg-in80.1%
metadata-eval80.1%
Simplified80.1%
Taylor expanded in x around 0 80.2%
*-commutative80.2%
times-frac80.2%
metadata-eval80.2%
associate-*r/96.2%
*-commutative96.2%
associate-*r*96.4%
Applied egg-rr96.4%
clear-num96.3%
un-div-inv96.3%
Applied egg-rr96.3%
Final simplification95.4%
(FPCore (x y z t a)
:precision binary64
(if (<= (* x y) -3.5e+59)
(* 0.5 (* x (/ y a)))
(if (<= (* x y) 5e+31)
(* (* z t) (* -9.0 (/ 0.5 a)))
(* (* x y) (/ 0.5 a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -3.5e+59) {
tmp = 0.5 * (x * (y / a));
} else if ((x * y) <= 5e+31) {
tmp = (z * t) * (-9.0 * (0.5 / a));
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if ((x * y) <= (-3.5d+59)) then
tmp = 0.5d0 * (x * (y / a))
else if ((x * y) <= 5d+31) then
tmp = (z * t) * ((-9.0d0) * (0.5d0 / a))
else
tmp = (x * y) * (0.5d0 / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -3.5e+59) {
tmp = 0.5 * (x * (y / a));
} else if ((x * y) <= 5e+31) {
tmp = (z * t) * (-9.0 * (0.5 / a));
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x * y) <= -3.5e+59: tmp = 0.5 * (x * (y / a)) elif (x * y) <= 5e+31: tmp = (z * t) * (-9.0 * (0.5 / a)) else: tmp = (x * y) * (0.5 / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -3.5e+59) tmp = Float64(0.5 * Float64(x * Float64(y / a))); elseif (Float64(x * y) <= 5e+31) tmp = Float64(Float64(z * t) * Float64(-9.0 * Float64(0.5 / a))); else tmp = Float64(Float64(x * y) * Float64(0.5 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x * y) <= -3.5e+59) tmp = 0.5 * (x * (y / a)); elseif ((x * y) <= 5e+31) tmp = (z * t) * (-9.0 * (0.5 / a)); else tmp = (x * y) * (0.5 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -3.5e+59], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+31], N[(N[(z * t), $MachinePrecision] * N[(-9.0 * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -3.5 \cdot 10^{+59}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+31}:\\
\;\;\;\;\left(z \cdot t\right) \cdot \left(-9 \cdot \frac{0.5}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\end{array}
\end{array}
if (*.f64 x y) < -3.5e59Initial program 84.7%
div-sub78.8%
*-commutative78.8%
div-sub84.7%
cancel-sign-sub-inv84.7%
*-commutative84.7%
fma-define86.7%
distribute-rgt-neg-in86.7%
associate-*r*86.7%
distribute-lft-neg-in86.7%
*-commutative86.7%
distribute-rgt-neg-in86.7%
metadata-eval86.7%
Simplified86.7%
Taylor expanded in x around inf 64.2%
associate-/l*71.5%
Simplified71.5%
if -3.5e59 < (*.f64 x y) < 5.00000000000000027e31Initial program 93.7%
div-sub93.7%
*-commutative93.7%
div-sub93.7%
cancel-sign-sub-inv93.7%
*-commutative93.7%
fma-define93.7%
distribute-rgt-neg-in93.7%
associate-*r*93.8%
distribute-lft-neg-in93.8%
*-commutative93.8%
distribute-rgt-neg-in93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in x around 0 77.1%
div-inv77.0%
*-commutative77.0%
associate-*l*77.7%
*-commutative77.7%
metadata-eval77.7%
div-inv77.7%
clear-num77.7%
Applied egg-rr77.7%
if 5.00000000000000027e31 < (*.f64 x y) Initial program 90.5%
div-sub90.5%
*-commutative90.5%
div-sub90.5%
cancel-sign-sub-inv90.5%
*-commutative90.5%
fma-define90.5%
distribute-rgt-neg-in90.5%
associate-*r*90.5%
distribute-lft-neg-in90.5%
*-commutative90.5%
distribute-rgt-neg-in90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in a around 0 90.5%
associate-*r/90.5%
+-commutative90.5%
metadata-eval90.5%
cancel-sign-sub-inv90.5%
cancel-sign-sub-inv90.5%
metadata-eval90.5%
*-commutative90.5%
*-commutative90.5%
associate-*r*90.5%
fma-define90.5%
associate-*l/90.6%
*-commutative90.6%
fma-define90.6%
+-commutative90.6%
fma-define92.5%
Simplified92.5%
Taylor expanded in z around 0 82.7%
(FPCore (x y z t a) :precision binary64 (if (<= (* x y) -5e-8) (* y (/ 0.5 (/ a x))) (if (<= (* x y) 5e+31) (/ (* z (* t -4.5)) a) (* (* x y) (/ 0.5 a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -5e-8) {
tmp = y * (0.5 / (a / x));
} else if ((x * y) <= 5e+31) {
tmp = (z * (t * -4.5)) / a;
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if ((x * y) <= (-5d-8)) then
tmp = y * (0.5d0 / (a / x))
else if ((x * y) <= 5d+31) then
tmp = (z * (t * (-4.5d0))) / a
else
tmp = (x * y) * (0.5d0 / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -5e-8) {
tmp = y * (0.5 / (a / x));
} else if ((x * y) <= 5e+31) {
tmp = (z * (t * -4.5)) / a;
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x * y) <= -5e-8: tmp = y * (0.5 / (a / x)) elif (x * y) <= 5e+31: tmp = (z * (t * -4.5)) / a else: tmp = (x * y) * (0.5 / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -5e-8) tmp = Float64(y * Float64(0.5 / Float64(a / x))); elseif (Float64(x * y) <= 5e+31) tmp = Float64(Float64(z * Float64(t * -4.5)) / a); else tmp = Float64(Float64(x * y) * Float64(0.5 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x * y) <= -5e-8) tmp = y * (0.5 / (a / x)); elseif ((x * y) <= 5e+31) tmp = (z * (t * -4.5)) / a; else tmp = (x * y) * (0.5 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -5e-8], N[(y * N[(0.5 / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+31], N[(N[(z * N[(t * -4.5), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -5 \cdot 10^{-8}:\\
\;\;\;\;y \cdot \frac{0.5}{\frac{a}{x}}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+31}:\\
\;\;\;\;\frac{z \cdot \left(t \cdot -4.5\right)}{a}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\end{array}
\end{array}
if (*.f64 x y) < -4.9999999999999998e-8Initial program 86.8%
div-sub82.4%
*-commutative82.4%
div-sub86.8%
cancel-sign-sub-inv86.8%
*-commutative86.8%
fma-define88.3%
distribute-rgt-neg-in88.3%
associate-*r*88.4%
distribute-lft-neg-in88.4%
*-commutative88.4%
distribute-rgt-neg-in88.4%
metadata-eval88.4%
Simplified88.4%
Taylor expanded in x around inf 61.1%
associate-/l*63.9%
Simplified63.9%
associate-*r*63.9%
clear-num63.9%
un-div-inv64.0%
Applied egg-rr64.0%
clear-num63.8%
*-commutative63.8%
associate-/r*63.8%
associate-/r*61.0%
*-commutative61.0%
clear-num61.0%
associate-/r*63.8%
associate-/r/65.2%
Applied egg-rr65.2%
if -4.9999999999999998e-8 < (*.f64 x y) < 5.00000000000000027e31Initial program 93.7%
div-sub93.7%
*-commutative93.7%
div-sub93.7%
cancel-sign-sub-inv93.7%
*-commutative93.7%
fma-define93.7%
distribute-rgt-neg-in93.7%
associate-*r*93.8%
distribute-lft-neg-in93.8%
*-commutative93.8%
distribute-rgt-neg-in93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in x around 0 81.1%
div-inv81.0%
*-commutative81.0%
associate-*l*81.1%
*-commutative81.1%
metadata-eval81.1%
div-inv81.1%
clear-num81.1%
Applied egg-rr81.1%
*-commutative81.1%
associate-*r/81.0%
metadata-eval81.0%
associate-*l/81.1%
associate-*l*81.0%
*-commutative81.0%
associate-*l*81.1%
*-commutative81.1%
Applied egg-rr81.1%
if 5.00000000000000027e31 < (*.f64 x y) Initial program 90.5%
div-sub90.5%
*-commutative90.5%
div-sub90.5%
cancel-sign-sub-inv90.5%
*-commutative90.5%
fma-define90.5%
distribute-rgt-neg-in90.5%
associate-*r*90.5%
distribute-lft-neg-in90.5%
*-commutative90.5%
distribute-rgt-neg-in90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in a around 0 90.5%
associate-*r/90.5%
+-commutative90.5%
metadata-eval90.5%
cancel-sign-sub-inv90.5%
cancel-sign-sub-inv90.5%
metadata-eval90.5%
*-commutative90.5%
*-commutative90.5%
associate-*r*90.5%
fma-define90.5%
associate-*l/90.6%
*-commutative90.6%
fma-define90.6%
+-commutative90.6%
fma-define92.5%
Simplified92.5%
Taylor expanded in z around 0 82.7%
Final simplification77.2%
(FPCore (x y z t a) :precision binary64 (if (<= (* x y) -5e-8) (* y (/ 0.5 (/ a x))) (if (<= (* x y) 5e+31) (* -4.5 (/ (* z t) a)) (* (* x y) (/ 0.5 a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -5e-8) {
tmp = y * (0.5 / (a / x));
} else if ((x * y) <= 5e+31) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if ((x * y) <= (-5d-8)) then
tmp = y * (0.5d0 / (a / x))
else if ((x * y) <= 5d+31) then
tmp = (-4.5d0) * ((z * t) / a)
else
tmp = (x * y) * (0.5d0 / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -5e-8) {
tmp = y * (0.5 / (a / x));
} else if ((x * y) <= 5e+31) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x * y) <= -5e-8: tmp = y * (0.5 / (a / x)) elif (x * y) <= 5e+31: tmp = -4.5 * ((z * t) / a) else: tmp = (x * y) * (0.5 / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -5e-8) tmp = Float64(y * Float64(0.5 / Float64(a / x))); elseif (Float64(x * y) <= 5e+31) tmp = Float64(-4.5 * Float64(Float64(z * t) / a)); else tmp = Float64(Float64(x * y) * Float64(0.5 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x * y) <= -5e-8) tmp = y * (0.5 / (a / x)); elseif ((x * y) <= 5e+31) tmp = -4.5 * ((z * t) / a); else tmp = (x * y) * (0.5 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -5e-8], N[(y * N[(0.5 / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+31], N[(-4.5 * N[(N[(z * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -5 \cdot 10^{-8}:\\
\;\;\;\;y \cdot \frac{0.5}{\frac{a}{x}}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+31}:\\
\;\;\;\;-4.5 \cdot \frac{z \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\end{array}
\end{array}
if (*.f64 x y) < -4.9999999999999998e-8Initial program 86.8%
div-sub82.4%
*-commutative82.4%
div-sub86.8%
cancel-sign-sub-inv86.8%
*-commutative86.8%
fma-define88.3%
distribute-rgt-neg-in88.3%
associate-*r*88.4%
distribute-lft-neg-in88.4%
*-commutative88.4%
distribute-rgt-neg-in88.4%
metadata-eval88.4%
Simplified88.4%
Taylor expanded in x around inf 61.1%
associate-/l*63.9%
Simplified63.9%
associate-*r*63.9%
clear-num63.9%
un-div-inv64.0%
Applied egg-rr64.0%
clear-num63.8%
*-commutative63.8%
associate-/r*63.8%
associate-/r*61.0%
*-commutative61.0%
clear-num61.0%
associate-/r*63.8%
associate-/r/65.2%
Applied egg-rr65.2%
if -4.9999999999999998e-8 < (*.f64 x y) < 5.00000000000000027e31Initial program 93.7%
div-sub93.7%
*-commutative93.7%
div-sub93.7%
cancel-sign-sub-inv93.7%
*-commutative93.7%
fma-define93.7%
distribute-rgt-neg-in93.7%
associate-*r*93.8%
distribute-lft-neg-in93.8%
*-commutative93.8%
distribute-rgt-neg-in93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in x around 0 81.0%
if 5.00000000000000027e31 < (*.f64 x y) Initial program 90.5%
div-sub90.5%
*-commutative90.5%
div-sub90.5%
cancel-sign-sub-inv90.5%
*-commutative90.5%
fma-define90.5%
distribute-rgt-neg-in90.5%
associate-*r*90.5%
distribute-lft-neg-in90.5%
*-commutative90.5%
distribute-rgt-neg-in90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in a around 0 90.5%
associate-*r/90.5%
+-commutative90.5%
metadata-eval90.5%
cancel-sign-sub-inv90.5%
cancel-sign-sub-inv90.5%
metadata-eval90.5%
*-commutative90.5%
*-commutative90.5%
associate-*r*90.5%
fma-define90.5%
associate-*l/90.6%
*-commutative90.6%
fma-define90.6%
+-commutative90.6%
fma-define92.5%
Simplified92.5%
Taylor expanded in z around 0 82.7%
Final simplification77.2%
(FPCore (x y z t a) :precision binary64 (if (<= (* x y) -3.5e+59) (* 0.5 (* x (/ y a))) (if (<= (* x y) 5e+31) (* -4.5 (/ (* z t) a)) (* (* x y) (/ 0.5 a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -3.5e+59) {
tmp = 0.5 * (x * (y / a));
} else if ((x * y) <= 5e+31) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if ((x * y) <= (-3.5d+59)) then
tmp = 0.5d0 * (x * (y / a))
else if ((x * y) <= 5d+31) then
tmp = (-4.5d0) * ((z * t) / a)
else
tmp = (x * y) * (0.5d0 / a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -3.5e+59) {
tmp = 0.5 * (x * (y / a));
} else if ((x * y) <= 5e+31) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = (x * y) * (0.5 / a);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x * y) <= -3.5e+59: tmp = 0.5 * (x * (y / a)) elif (x * y) <= 5e+31: tmp = -4.5 * ((z * t) / a) else: tmp = (x * y) * (0.5 / a) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -3.5e+59) tmp = Float64(0.5 * Float64(x * Float64(y / a))); elseif (Float64(x * y) <= 5e+31) tmp = Float64(-4.5 * Float64(Float64(z * t) / a)); else tmp = Float64(Float64(x * y) * Float64(0.5 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x * y) <= -3.5e+59) tmp = 0.5 * (x * (y / a)); elseif ((x * y) <= 5e+31) tmp = -4.5 * ((z * t) / a); else tmp = (x * y) * (0.5 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -3.5e+59], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+31], N[(-4.5 * N[(N[(z * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -3.5 \cdot 10^{+59}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+31}:\\
\;\;\;\;-4.5 \cdot \frac{z \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\end{array}
\end{array}
if (*.f64 x y) < -3.5e59Initial program 84.7%
div-sub78.8%
*-commutative78.8%
div-sub84.7%
cancel-sign-sub-inv84.7%
*-commutative84.7%
fma-define86.7%
distribute-rgt-neg-in86.7%
associate-*r*86.7%
distribute-lft-neg-in86.7%
*-commutative86.7%
distribute-rgt-neg-in86.7%
metadata-eval86.7%
Simplified86.7%
Taylor expanded in x around inf 64.2%
associate-/l*71.5%
Simplified71.5%
if -3.5e59 < (*.f64 x y) < 5.00000000000000027e31Initial program 93.7%
div-sub93.7%
*-commutative93.7%
div-sub93.7%
cancel-sign-sub-inv93.7%
*-commutative93.7%
fma-define93.7%
distribute-rgt-neg-in93.7%
associate-*r*93.8%
distribute-lft-neg-in93.8%
*-commutative93.8%
distribute-rgt-neg-in93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in x around 0 77.1%
if 5.00000000000000027e31 < (*.f64 x y) Initial program 90.5%
div-sub90.5%
*-commutative90.5%
div-sub90.5%
cancel-sign-sub-inv90.5%
*-commutative90.5%
fma-define90.5%
distribute-rgt-neg-in90.5%
associate-*r*90.5%
distribute-lft-neg-in90.5%
*-commutative90.5%
distribute-rgt-neg-in90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in a around 0 90.5%
associate-*r/90.5%
+-commutative90.5%
metadata-eval90.5%
cancel-sign-sub-inv90.5%
cancel-sign-sub-inv90.5%
metadata-eval90.5%
*-commutative90.5%
*-commutative90.5%
associate-*r*90.5%
fma-define90.5%
associate-*l/90.6%
*-commutative90.6%
fma-define90.6%
+-commutative90.6%
fma-define92.5%
Simplified92.5%
Taylor expanded in z around 0 82.7%
Final simplification77.1%
(FPCore (x y z t a) :precision binary64 (if (<= (* x y) (- INFINITY)) (* x (* y (/ 0.5 a))) (* (/ 0.5 a) (+ (* x y) (* t (* z -9.0))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -((double) INFINITY)) {
tmp = x * (y * (0.5 / a));
} else {
tmp = (0.5 / a) * ((x * y) + (t * (z * -9.0)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -Double.POSITIVE_INFINITY) {
tmp = x * (y * (0.5 / a));
} else {
tmp = (0.5 / a) * ((x * y) + (t * (z * -9.0)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x * y) <= -math.inf: tmp = x * (y * (0.5 / a)) else: tmp = (0.5 / a) * ((x * y) + (t * (z * -9.0))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= Float64(-Inf)) tmp = Float64(x * Float64(y * Float64(0.5 / a))); else tmp = Float64(Float64(0.5 / a) * Float64(Float64(x * y) + Float64(t * Float64(z * -9.0)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x * y) <= -Inf) tmp = x * (y * (0.5 / a)); else tmp = (0.5 / a) * ((x * y) + (t * (z * -9.0))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], (-Infinity)], N[(x * N[(y * N[(0.5 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.5 / a), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] + N[(t * N[(z * -9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -\infty:\\
\;\;\;\;x \cdot \left(y \cdot \frac{0.5}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{a} \cdot \left(x \cdot y + t \cdot \left(z \cdot -9\right)\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -inf.0Initial program 32.2%
div-sub22.2%
*-commutative22.2%
div-sub32.2%
cancel-sign-sub-inv32.2%
*-commutative32.2%
fma-define42.2%
distribute-rgt-neg-in42.2%
associate-*r*42.2%
distribute-lft-neg-in42.2%
*-commutative42.2%
distribute-rgt-neg-in42.2%
metadata-eval42.2%
Simplified42.2%
Taylor expanded in a around 0 32.2%
associate-*r/32.2%
+-commutative32.2%
metadata-eval32.2%
cancel-sign-sub-inv32.2%
cancel-sign-sub-inv32.2%
metadata-eval32.2%
*-commutative32.2%
*-commutative32.2%
associate-*r*32.2%
fma-define42.2%
associate-*l/42.2%
*-commutative42.2%
fma-define32.2%
+-commutative32.2%
fma-define42.7%
Simplified42.7%
Taylor expanded in z around 0 42.7%
associate-*r/42.7%
associate-*l/42.7%
*-commutative42.7%
associate-*l*90.0%
Simplified90.0%
if -inf.0 < (*.f64 x y) Initial program 93.7%
div-sub92.9%
*-commutative92.9%
div-sub93.7%
cancel-sign-sub-inv93.7%
*-commutative93.7%
fma-define93.7%
distribute-rgt-neg-in93.7%
associate-*r*93.7%
distribute-lft-neg-in93.7%
*-commutative93.7%
distribute-rgt-neg-in93.7%
metadata-eval93.7%
Simplified93.7%
Taylor expanded in a around 0 93.7%
associate-*r/93.7%
+-commutative93.7%
metadata-eval93.7%
cancel-sign-sub-inv93.7%
cancel-sign-sub-inv93.7%
metadata-eval93.7%
*-commutative93.7%
*-commutative93.7%
associate-*r*93.7%
fma-define93.7%
associate-*l/93.7%
*-commutative93.7%
fma-define93.7%
+-commutative93.7%
fma-define94.1%
Simplified94.1%
fma-undefine93.7%
associate-*r*93.6%
*-commutative93.6%
associate-*l*93.6%
Applied egg-rr93.6%
Final simplification93.5%
(FPCore (x y z t a) :precision binary64 (if (or (<= y -6.5e-133) (not (<= y 1.5e+126))) (* 0.5 (* x (/ y a))) (* -4.5 (* z (/ t a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((y <= -6.5e-133) || !(y <= 1.5e+126)) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if ((y <= (-6.5d-133)) .or. (.not. (y <= 1.5d+126))) then
tmp = 0.5d0 * (x * (y / a))
else
tmp = (-4.5d0) * (z * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((y <= -6.5e-133) || !(y <= 1.5e+126)) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (y <= -6.5e-133) or not (y <= 1.5e+126): tmp = 0.5 * (x * (y / a)) else: tmp = -4.5 * (z * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((y <= -6.5e-133) || !(y <= 1.5e+126)) tmp = Float64(0.5 * Float64(x * Float64(y / a))); else tmp = Float64(-4.5 * Float64(z * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((y <= -6.5e-133) || ~((y <= 1.5e+126))) tmp = 0.5 * (x * (y / a)); else tmp = -4.5 * (z * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[y, -6.5e-133], N[Not[LessEqual[y, 1.5e+126]], $MachinePrecision]], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.5 \cdot 10^{-133} \lor \neg \left(y \leq 1.5 \cdot 10^{+126}\right):\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\end{array}
\end{array}
if y < -6.5000000000000002e-133 or 1.5000000000000001e126 < y Initial program 89.4%
div-sub86.9%
*-commutative86.9%
div-sub89.4%
cancel-sign-sub-inv89.4%
*-commutative89.4%
fma-define90.2%
distribute-rgt-neg-in90.2%
associate-*r*90.2%
distribute-lft-neg-in90.2%
*-commutative90.2%
distribute-rgt-neg-in90.2%
metadata-eval90.2%
Simplified90.2%
Taylor expanded in x around inf 55.7%
associate-/l*58.8%
Simplified58.8%
if -6.5000000000000002e-133 < y < 1.5000000000000001e126Initial program 93.0%
div-sub93.0%
*-commutative93.0%
div-sub93.0%
cancel-sign-sub-inv93.0%
*-commutative93.0%
fma-define93.0%
distribute-rgt-neg-in93.0%
associate-*r*93.0%
distribute-lft-neg-in93.0%
*-commutative93.0%
distribute-rgt-neg-in93.0%
metadata-eval93.0%
Simplified93.0%
Taylor expanded in x around 0 67.5%
associate-*r/67.5%
associate-*r*67.5%
associate-*l/71.4%
associate-*r/72.0%
associate-*l*72.0%
Simplified72.0%
Final simplification65.8%
(FPCore (x y z t a) :precision binary64 (if (<= t 1.28e+135) (* -4.5 (/ (* z t) a)) (* -4.5 (* z (/ t a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 1.28e+135) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (t <= 1.28d+135) then
tmp = (-4.5d0) * ((z * t) / a)
else
tmp = (-4.5d0) * (z * (t / a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 1.28e+135) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = -4.5 * (z * (t / a));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= 1.28e+135: tmp = -4.5 * ((z * t) / a) else: tmp = -4.5 * (z * (t / a)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= 1.28e+135) tmp = Float64(-4.5 * Float64(Float64(z * t) / a)); else tmp = Float64(-4.5 * Float64(z * Float64(t / a))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= 1.28e+135) tmp = -4.5 * ((z * t) / a); else tmp = -4.5 * (z * (t / a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, 1.28e+135], N[(-4.5 * N[(N[(z * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.28 \cdot 10^{+135}:\\
\;\;\;\;-4.5 \cdot \frac{z \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(z \cdot \frac{t}{a}\right)\\
\end{array}
\end{array}
if t < 1.28e135Initial program 92.0%
div-sub90.7%
*-commutative90.7%
div-sub92.0%
cancel-sign-sub-inv92.0%
*-commutative92.0%
fma-define92.5%
distribute-rgt-neg-in92.5%
associate-*r*92.5%
distribute-lft-neg-in92.5%
*-commutative92.5%
distribute-rgt-neg-in92.5%
metadata-eval92.5%
Simplified92.5%
Taylor expanded in x around 0 54.0%
if 1.28e135 < t Initial program 86.8%
div-sub86.8%
*-commutative86.8%
div-sub86.8%
cancel-sign-sub-inv86.8%
*-commutative86.8%
fma-define86.8%
distribute-rgt-neg-in86.8%
associate-*r*87.1%
distribute-lft-neg-in87.1%
*-commutative87.1%
distribute-rgt-neg-in87.1%
metadata-eval87.1%
Simplified87.1%
Taylor expanded in x around 0 74.2%
associate-*r/74.0%
associate-*r*74.2%
associate-*l/81.3%
associate-*r/83.8%
associate-*l*83.9%
Simplified83.9%
Final simplification58.4%
(FPCore (x y z t a) :precision binary64 (* -4.5 (* z (/ t a))))
double code(double x, double y, double z, double t, double a) {
return -4.5 * (z * (t / a));
}
real(8) function code(x, y, z, t, a)
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
code = (-4.5d0) * (z * (t / a))
end function
public static double code(double x, double y, double z, double t, double a) {
return -4.5 * (z * (t / a));
}
def code(x, y, z, t, a): return -4.5 * (z * (t / a))
function code(x, y, z, t, a) return Float64(-4.5 * Float64(z * Float64(t / a))) end
function tmp = code(x, y, z, t, a) tmp = -4.5 * (z * (t / a)); end
code[x_, y_, z_, t_, a_] := N[(-4.5 * N[(z * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4.5 \cdot \left(z \cdot \frac{t}{a}\right)
\end{array}
Initial program 91.3%
div-sub90.1%
*-commutative90.1%
div-sub91.3%
cancel-sign-sub-inv91.3%
*-commutative91.3%
fma-define91.7%
distribute-rgt-neg-in91.7%
associate-*r*91.7%
distribute-lft-neg-in91.7%
*-commutative91.7%
distribute-rgt-neg-in91.7%
metadata-eval91.7%
Simplified91.7%
Taylor expanded in x around 0 56.9%
associate-*r/57.0%
associate-*r*57.0%
associate-*l/60.1%
associate-*r/60.5%
associate-*l*60.4%
Simplified60.4%
Final simplification60.4%
(FPCore (x y z t a) :precision binary64 (* -4.5 (* t (/ z a))))
double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
real(8) function code(x, y, z, t, a)
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
code = (-4.5d0) * (t * (z / a))
end function
public static double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
def code(x, y, z, t, a): return -4.5 * (t * (z / a))
function code(x, y, z, t, a) return Float64(-4.5 * Float64(t * Float64(z / a))) end
function tmp = code(x, y, z, t, a) tmp = -4.5 * (t * (z / a)); end
code[x_, y_, z_, t_, a_] := N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4.5 \cdot \left(t \cdot \frac{z}{a}\right)
\end{array}
Initial program 91.3%
div-sub90.1%
*-commutative90.1%
div-sub91.3%
cancel-sign-sub-inv91.3%
*-commutative91.3%
fma-define91.7%
distribute-rgt-neg-in91.7%
associate-*r*91.7%
distribute-lft-neg-in91.7%
*-commutative91.7%
distribute-rgt-neg-in91.7%
metadata-eval91.7%
Simplified91.7%
Taylor expanded in x around 0 56.9%
associate-/l*54.4%
Simplified54.4%
(FPCore (x y z t a)
:precision binary64
(if (< a -2.090464557976709e+86)
(- (* 0.5 (/ (* y x) a)) (* 4.5 (/ t (/ a z))))
(if (< a 2.144030707833976e+99)
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))
(- (* (/ y a) (* x 0.5)) (* (/ t a) (* z 4.5))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a < -2.090464557976709e+86) {
tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z)));
} else if (a < 2.144030707833976e+99) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
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) :: tmp
if (a < (-2.090464557976709d+86)) then
tmp = (0.5d0 * ((y * x) / a)) - (4.5d0 * (t / (a / z)))
else if (a < 2.144030707833976d+99) then
tmp = ((x * y) - (z * (9.0d0 * t))) / (a * 2.0d0)
else
tmp = ((y / a) * (x * 0.5d0)) - ((t / a) * (z * 4.5d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a < -2.090464557976709e+86) {
tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z)));
} else if (a < 2.144030707833976e+99) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a < -2.090464557976709e+86: tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z))) elif a < 2.144030707833976e+99: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) else: tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a < -2.090464557976709e+86) tmp = Float64(Float64(0.5 * Float64(Float64(y * x) / a)) - Float64(4.5 * Float64(t / Float64(a / z)))); elseif (a < 2.144030707833976e+99) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); else tmp = Float64(Float64(Float64(y / a) * Float64(x * 0.5)) - Float64(Float64(t / a) * Float64(z * 4.5))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a < -2.090464557976709e+86) tmp = (0.5 * ((y * x) / a)) - (4.5 * (t / (a / z))); elseif (a < 2.144030707833976e+99) tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0); else tmp = ((y / a) * (x * 0.5)) - ((t / a) * (z * 4.5)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Less[a, -2.090464557976709e+86], N[(N[(0.5 * N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] - N[(4.5 * N[(t / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Less[a, 2.144030707833976e+99], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y / a), $MachinePrecision] * N[(x * 0.5), $MachinePrecision]), $MachinePrecision] - N[(N[(t / a), $MachinePrecision] * N[(z * 4.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a < -2.090464557976709 \cdot 10^{+86}:\\
\;\;\;\;0.5 \cdot \frac{y \cdot x}{a} - 4.5 \cdot \frac{t}{\frac{a}{z}}\\
\mathbf{elif}\;a < 2.144030707833976 \cdot 10^{+99}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a} \cdot \left(x \cdot 0.5\right) - \frac{t}{a} \cdot \left(z \cdot 4.5\right)\\
\end{array}
\end{array}
herbie shell --seed 2024123
(FPCore (x y z t a)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, I"
:precision binary64
:alt
(! :herbie-platform default (if (< a -209046455797670900000000000000000000000000000000000000000000000000000000000000000000000) (- (* 1/2 (/ (* y x) a)) (* 9/2 (/ t (/ a z)))) (if (< a 2144030707833976000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (/ (- (* x y) (* z (* 9 t))) (* a 2)) (- (* (/ y a) (* x 1/2)) (* (/ t a) (* z 9/2))))))
(/ (- (* x y) (* (* z 9.0) t)) (* a 2.0)))