
(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}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* x y) (* (* z 9.0) t))))
(if (<= t_1 -1e+251)
(- (* x (/ y (* a 2.0))) (* z (/ 4.5 (/ a t))))
(if (<= t_1 1e+275)
(/ (fma x y (* z (* t -9.0))) (* a 2.0))
(* -0.5 (* t (/ (- (* z 9.0) (* x (/ y t))) a)))))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
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 <= -1e+251) {
tmp = (x * (y / (a * 2.0))) - (z * (4.5 / (a / t)));
} else if (t_1 <= 1e+275) {
tmp = fma(x, y, (z * (t * -9.0))) / (a * 2.0);
} else {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
}
return tmp;
}
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) 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 <= -1e+251) tmp = Float64(Float64(x * Float64(y / Float64(a * 2.0))) - Float64(z * Float64(4.5 / Float64(a / t)))); elseif (t_1 <= 1e+275) tmp = Float64(fma(x, y, Float64(z * Float64(t * -9.0))) / Float64(a * 2.0)); else tmp = Float64(-0.5 * Float64(t * Float64(Float64(Float64(z * 9.0) - Float64(x * Float64(y / t))) / a))); end return tmp end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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[LessEqual[t$95$1, -1e+251], N[(N[(x * N[(y / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(z * N[(4.5 / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+275], N[(N[(x * y + N[(z * N[(t * -9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(t * N[(N[(N[(z * 9.0), $MachinePrecision] - N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := x \cdot y - \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+251}:\\
\;\;\;\;x \cdot \frac{y}{a \cdot 2} - z \cdot \frac{4.5}{\frac{a}{t}}\\
\mathbf{elif}\;t\_1 \leq 10^{+275}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t \cdot -9\right)\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \left(t \cdot \frac{z \cdot 9 - x \cdot \frac{y}{t}}{a}\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < -1e251Initial program 74.4%
div-sub71.9%
*-commutative71.9%
div-sub74.4%
cancel-sign-sub-inv74.4%
*-commutative74.4%
fma-define74.4%
distribute-rgt-neg-in74.4%
associate-*r*74.4%
distribute-lft-neg-in74.4%
*-commutative74.4%
distribute-rgt-neg-in74.4%
metadata-eval74.4%
Simplified74.4%
*-un-lft-identity74.4%
*-un-lft-identity74.4%
*-commutative74.4%
associate-*r*74.4%
metadata-eval74.4%
distribute-rgt-neg-in74.4%
distribute-lft-neg-in74.4%
fmm-def74.4%
div-sub71.9%
associate-/l*88.4%
associate-*l*88.4%
associate-/l*94.9%
Applied egg-rr94.9%
clear-num94.9%
inv-pow94.9%
*-commutative94.9%
times-frac94.8%
metadata-eval94.8%
Applied egg-rr94.8%
unpow-194.8%
*-commutative94.8%
associate-/r*94.9%
metadata-eval94.9%
Simplified94.9%
if -1e251 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < 9.9999999999999996e274Initial program 98.7%
div-sub97.0%
*-commutative97.0%
div-sub98.7%
cancel-sign-sub-inv98.7%
*-commutative98.7%
fma-define98.7%
distribute-rgt-neg-in98.7%
associate-*r*98.7%
distribute-lft-neg-in98.7%
*-commutative98.7%
distribute-rgt-neg-in98.7%
metadata-eval98.7%
Simplified98.7%
if 9.9999999999999996e274 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) Initial program 65.6%
div-sub62.8%
*-commutative62.8%
div-sub65.6%
cancel-sign-sub-inv65.6%
*-commutative65.6%
fma-define65.6%
distribute-rgt-neg-in65.6%
associate-*r*65.6%
distribute-lft-neg-in65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in a around 0 65.6%
associate-*r/65.6%
+-commutative65.6%
metadata-eval65.6%
cancel-sign-sub-inv65.6%
cancel-sign-sub-inv65.6%
metadata-eval65.6%
*-commutative65.6%
*-commutative65.6%
associate-*r*65.6%
fma-define65.6%
associate-*l/65.6%
*-commutative65.6%
fma-define65.6%
+-commutative65.6%
fma-define73.9%
Simplified73.9%
Taylor expanded in t around -inf 71.4%
mul-1-neg71.4%
*-commutative71.4%
distribute-rgt-neg-in71.4%
+-commutative71.4%
mul-1-neg71.4%
unsub-neg71.4%
*-commutative71.4%
associate-/l*71.4%
Simplified71.4%
Taylor expanded in a around 0 71.3%
associate-/l*84.3%
*-commutative84.3%
associate-/l*89.5%
Simplified89.5%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(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+275)))
(* -0.5 (* t (/ (- (* z 9.0) (* x (/ y t))) a)))
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0)))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
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+275)) {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
} else {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
}
return tmp;
}
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static 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.POSITIVE_INFINITY) || !(t_1 <= 1e+275)) {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
} else {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = (x * y) - ((z * 9.0) * t) tmp = 0 if (t_1 <= -math.inf) or not (t_1 <= 1e+275): tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a)) else: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) 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+275)) tmp = Float64(-0.5 * Float64(t * Float64(Float64(Float64(z * 9.0) - Float64(x * Float64(y / t))) / a))); else tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = (x * y) - ((z * 9.0) * t);
tmp = 0.0;
if ((t_1 <= -Inf) || ~((t_1 <= 1e+275)))
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
else
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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+275]], $MachinePrecision]], N[(-0.5 * N[(t * N[(N[(N[(z * 9.0), $MachinePrecision] - N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $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}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\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^{+275}\right):\\
\;\;\;\;-0.5 \cdot \left(t \cdot \frac{z \cdot 9 - x \cdot \frac{y}{t}}{a}\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 9.9999999999999996e274 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) Initial program 65.2%
div-sub62.2%
*-commutative62.2%
div-sub65.2%
cancel-sign-sub-inv65.2%
*-commutative65.2%
fma-define65.2%
distribute-rgt-neg-in65.2%
associate-*r*65.3%
distribute-lft-neg-in65.3%
*-commutative65.3%
distribute-rgt-neg-in65.3%
metadata-eval65.3%
Simplified65.3%
Taylor expanded in a around 0 65.2%
associate-*r/65.2%
+-commutative65.2%
metadata-eval65.2%
cancel-sign-sub-inv65.2%
cancel-sign-sub-inv65.2%
metadata-eval65.2%
*-commutative65.2%
*-commutative65.2%
associate-*r*65.3%
fma-define65.3%
associate-*l/65.3%
*-commutative65.3%
fma-define65.3%
+-commutative65.3%
fma-define69.9%
Simplified69.9%
Taylor expanded in t around -inf 68.5%
mul-1-neg68.5%
*-commutative68.5%
distribute-rgt-neg-in68.5%
+-commutative68.5%
mul-1-neg68.5%
unsub-neg68.5%
*-commutative68.5%
associate-/l*68.5%
Simplified68.5%
Taylor expanded in a around 0 68.5%
associate-/l*81.1%
*-commutative81.1%
associate-/l*89.7%
Simplified89.7%
if -inf.0 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < 9.9999999999999996e274Initial program 98.7%
div-sub97.2%
*-commutative97.2%
div-sub98.7%
cancel-sign-sub-inv98.7%
*-commutative98.7%
fma-define98.8%
distribute-rgt-neg-in98.8%
associate-*r*98.7%
distribute-lft-neg-in98.7%
*-commutative98.7%
distribute-rgt-neg-in98.7%
metadata-eval98.7%
Simplified98.7%
*-commutative98.7%
associate-*r*98.8%
metadata-eval98.8%
distribute-rgt-neg-in98.8%
distribute-lft-neg-in98.8%
fmm-def98.7%
associate-*l*98.7%
Applied egg-rr98.7%
Final simplification96.4%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* x y) (* (* z 9.0) t))))
(if (<= t_1 -1e+251)
(- (* x (/ y (* a 2.0))) (* z (/ 4.5 (/ a t))))
(if (<= t_1 1e+275)
(/ (- (* (* x y) 0.5) (* 4.5 (* z t))) a)
(* -0.5 (* t (/ (- (* z 9.0) (* x (/ y t))) a)))))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
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 <= -1e+251) {
tmp = (x * (y / (a * 2.0))) - (z * (4.5 / (a / t)));
} else if (t_1 <= 1e+275) {
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
} else {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = (x * y) - ((z * 9.0d0) * t)
if (t_1 <= (-1d+251)) then
tmp = (x * (y / (a * 2.0d0))) - (z * (4.5d0 / (a / t)))
else if (t_1 <= 1d+275) then
tmp = (((x * y) * 0.5d0) - (4.5d0 * (z * t))) / a
else
tmp = (-0.5d0) * (t * (((z * 9.0d0) - (x * (y / t))) / a))
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static 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 <= -1e+251) {
tmp = (x * (y / (a * 2.0))) - (z * (4.5 / (a / t)));
} else if (t_1 <= 1e+275) {
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
} else {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = (x * y) - ((z * 9.0) * t) tmp = 0 if t_1 <= -1e+251: tmp = (x * (y / (a * 2.0))) - (z * (4.5 / (a / t))) elif t_1 <= 1e+275: tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a else: tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a)) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) 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 <= -1e+251) tmp = Float64(Float64(x * Float64(y / Float64(a * 2.0))) - Float64(z * Float64(4.5 / Float64(a / t)))); elseif (t_1 <= 1e+275) tmp = Float64(Float64(Float64(Float64(x * y) * 0.5) - Float64(4.5 * Float64(z * t))) / a); else tmp = Float64(-0.5 * Float64(t * Float64(Float64(Float64(z * 9.0) - Float64(x * Float64(y / t))) / a))); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = (x * y) - ((z * 9.0) * t);
tmp = 0.0;
if (t_1 <= -1e+251)
tmp = (x * (y / (a * 2.0))) - (z * (4.5 / (a / t)));
elseif (t_1 <= 1e+275)
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
else
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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[LessEqual[t$95$1, -1e+251], N[(N[(x * N[(y / N[(a * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(z * N[(4.5 / N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+275], N[(N[(N[(N[(x * y), $MachinePrecision] * 0.5), $MachinePrecision] - N[(4.5 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(-0.5 * N[(t * N[(N[(N[(z * 9.0), $MachinePrecision] - N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := x \cdot y - \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+251}:\\
\;\;\;\;x \cdot \frac{y}{a \cdot 2} - z \cdot \frac{4.5}{\frac{a}{t}}\\
\mathbf{elif}\;t\_1 \leq 10^{+275}:\\
\;\;\;\;\frac{\left(x \cdot y\right) \cdot 0.5 - 4.5 \cdot \left(z \cdot t\right)}{a}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \left(t \cdot \frac{z \cdot 9 - x \cdot \frac{y}{t}}{a}\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < -1e251Initial program 74.4%
div-sub71.9%
*-commutative71.9%
div-sub74.4%
cancel-sign-sub-inv74.4%
*-commutative74.4%
fma-define74.4%
distribute-rgt-neg-in74.4%
associate-*r*74.4%
distribute-lft-neg-in74.4%
*-commutative74.4%
distribute-rgt-neg-in74.4%
metadata-eval74.4%
Simplified74.4%
*-un-lft-identity74.4%
*-un-lft-identity74.4%
*-commutative74.4%
associate-*r*74.4%
metadata-eval74.4%
distribute-rgt-neg-in74.4%
distribute-lft-neg-in74.4%
fmm-def74.4%
div-sub71.9%
associate-/l*88.4%
associate-*l*88.4%
associate-/l*94.9%
Applied egg-rr94.9%
clear-num94.9%
inv-pow94.9%
*-commutative94.9%
times-frac94.8%
metadata-eval94.8%
Applied egg-rr94.8%
unpow-194.8%
*-commutative94.8%
associate-/r*94.9%
metadata-eval94.9%
Simplified94.9%
if -1e251 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < 9.9999999999999996e274Initial program 98.7%
div-sub97.0%
*-commutative97.0%
div-sub98.7%
cancel-sign-sub-inv98.7%
*-commutative98.7%
fma-define98.7%
distribute-rgt-neg-in98.7%
associate-*r*98.7%
distribute-lft-neg-in98.7%
*-commutative98.7%
distribute-rgt-neg-in98.7%
metadata-eval98.7%
Simplified98.7%
*-un-lft-identity98.7%
*-un-lft-identity98.7%
*-commutative98.7%
associate-*r*98.7%
metadata-eval98.7%
distribute-rgt-neg-in98.7%
distribute-lft-neg-in98.7%
fmm-def98.7%
div-sub97.0%
associate-/l*91.9%
associate-*l*91.9%
associate-/l*85.1%
Applied egg-rr85.1%
Taylor expanded in a around 0 98.7%
if 9.9999999999999996e274 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) Initial program 65.6%
div-sub62.8%
*-commutative62.8%
div-sub65.6%
cancel-sign-sub-inv65.6%
*-commutative65.6%
fma-define65.6%
distribute-rgt-neg-in65.6%
associate-*r*65.6%
distribute-lft-neg-in65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in a around 0 65.6%
associate-*r/65.6%
+-commutative65.6%
metadata-eval65.6%
cancel-sign-sub-inv65.6%
cancel-sign-sub-inv65.6%
metadata-eval65.6%
*-commutative65.6%
*-commutative65.6%
associate-*r*65.6%
fma-define65.6%
associate-*l/65.6%
*-commutative65.6%
fma-define65.6%
+-commutative65.6%
fma-define73.9%
Simplified73.9%
Taylor expanded in t around -inf 71.4%
mul-1-neg71.4%
*-commutative71.4%
distribute-rgt-neg-in71.4%
+-commutative71.4%
mul-1-neg71.4%
unsub-neg71.4%
*-commutative71.4%
associate-/l*71.4%
Simplified71.4%
Taylor expanded in a around 0 71.3%
associate-/l*84.3%
*-commutative84.3%
associate-/l*89.5%
Simplified89.5%
Final simplification96.8%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* x y) (* (* z 9.0) t))))
(if (<= t_1 -1e+295)
(* (* z -0.5) (/ (- (* 9.0 t) (* x (/ y z))) a))
(if (<= t_1 1e+275)
(/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))
(* -0.5 (* t (/ (- (* z 9.0) (* x (/ y t))) a)))))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
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 <= -1e+295) {
tmp = (z * -0.5) * (((9.0 * t) - (x * (y / z))) / a);
} else if (t_1 <= 1e+275) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = (x * y) - ((z * 9.0d0) * t)
if (t_1 <= (-1d+295)) then
tmp = (z * (-0.5d0)) * (((9.0d0 * t) - (x * (y / z))) / a)
else if (t_1 <= 1d+275) then
tmp = ((x * y) - (z * (9.0d0 * t))) / (a * 2.0d0)
else
tmp = (-0.5d0) * (t * (((z * 9.0d0) - (x * (y / t))) / a))
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static 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 <= -1e+295) {
tmp = (z * -0.5) * (((9.0 * t) - (x * (y / z))) / a);
} else if (t_1 <= 1e+275) {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
} else {
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = (x * y) - ((z * 9.0) * t) tmp = 0 if t_1 <= -1e+295: tmp = (z * -0.5) * (((9.0 * t) - (x * (y / z))) / a) elif t_1 <= 1e+275: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) else: tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a)) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) 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 <= -1e+295) tmp = Float64(Float64(z * -0.5) * Float64(Float64(Float64(9.0 * t) - Float64(x * Float64(y / z))) / a)); elseif (t_1 <= 1e+275) tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); else tmp = Float64(-0.5 * Float64(t * Float64(Float64(Float64(z * 9.0) - Float64(x * Float64(y / t))) / a))); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = (x * y) - ((z * 9.0) * t);
tmp = 0.0;
if (t_1 <= -1e+295)
tmp = (z * -0.5) * (((9.0 * t) - (x * (y / z))) / a);
elseif (t_1 <= 1e+275)
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
else
tmp = -0.5 * (t * (((z * 9.0) - (x * (y / t))) / a));
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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[LessEqual[t$95$1, -1e+295], N[(N[(z * -0.5), $MachinePrecision] * N[(N[(N[(9.0 * t), $MachinePrecision] - N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+275], N[(N[(N[(x * y), $MachinePrecision] - N[(z * N[(9.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(t * N[(N[(N[(z * 9.0), $MachinePrecision] - N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := x \cdot y - \left(z \cdot 9\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+295}:\\
\;\;\;\;\left(z \cdot -0.5\right) \cdot \frac{9 \cdot t - x \cdot \frac{y}{z}}{a}\\
\mathbf{elif}\;t\_1 \leq 10^{+275}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \left(t \cdot \frac{z \cdot 9 - x \cdot \frac{y}{t}}{a}\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < -9.9999999999999998e294Initial program 68.1%
div-sub65.0%
*-commutative65.0%
div-sub68.1%
cancel-sign-sub-inv68.1%
*-commutative68.1%
fma-define68.1%
distribute-rgt-neg-in68.1%
associate-*r*68.1%
distribute-lft-neg-in68.1%
*-commutative68.1%
distribute-rgt-neg-in68.1%
metadata-eval68.1%
Simplified68.1%
Taylor expanded in a around 0 68.1%
associate-*r/68.1%
+-commutative68.1%
metadata-eval68.1%
cancel-sign-sub-inv68.1%
cancel-sign-sub-inv68.1%
metadata-eval68.1%
*-commutative68.1%
*-commutative68.1%
associate-*r*68.1%
fma-define68.1%
associate-*l/68.1%
*-commutative68.1%
fma-define68.1%
+-commutative68.1%
fma-define68.1%
Simplified68.1%
Taylor expanded in z around -inf 68.1%
mul-1-neg68.1%
*-commutative68.1%
distribute-rgt-neg-in68.1%
+-commutative68.1%
*-commutative68.1%
mul-1-neg68.1%
unsub-neg68.1%
associate-/l*68.2%
Simplified68.2%
Taylor expanded in a around 0 68.1%
associate-/l*79.4%
associate-*r*79.4%
*-commutative79.4%
associate-*r/85.4%
Simplified85.4%
if -9.9999999999999998e294 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) < 9.9999999999999996e274Initial program 98.7%
div-sub97.1%
*-commutative97.1%
div-sub98.7%
cancel-sign-sub-inv98.7%
*-commutative98.7%
fma-define98.7%
distribute-rgt-neg-in98.7%
associate-*r*98.7%
distribute-lft-neg-in98.7%
*-commutative98.7%
distribute-rgt-neg-in98.7%
metadata-eval98.7%
Simplified98.7%
*-commutative98.7%
associate-*r*98.7%
metadata-eval98.7%
distribute-rgt-neg-in98.7%
distribute-lft-neg-in98.7%
fmm-def98.7%
associate-*l*98.7%
Applied egg-rr98.7%
if 9.9999999999999996e274 < (-.f64 (*.f64 x y) (*.f64 (*.f64 z #s(literal 9 binary64)) t)) Initial program 65.6%
div-sub62.8%
*-commutative62.8%
div-sub65.6%
cancel-sign-sub-inv65.6%
*-commutative65.6%
fma-define65.6%
distribute-rgt-neg-in65.6%
associate-*r*65.6%
distribute-lft-neg-in65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in a around 0 65.6%
associate-*r/65.6%
+-commutative65.6%
metadata-eval65.6%
cancel-sign-sub-inv65.6%
cancel-sign-sub-inv65.6%
metadata-eval65.6%
*-commutative65.6%
*-commutative65.6%
associate-*r*65.6%
fma-define65.6%
associate-*l/65.6%
*-commutative65.6%
fma-define65.6%
+-commutative65.6%
fma-define73.9%
Simplified73.9%
Taylor expanded in t around -inf 71.4%
mul-1-neg71.4%
*-commutative71.4%
distribute-rgt-neg-in71.4%
+-commutative71.4%
mul-1-neg71.4%
unsub-neg71.4%
*-commutative71.4%
associate-/l*71.4%
Simplified71.4%
Taylor expanded in a around 0 71.3%
associate-/l*84.3%
*-commutative84.3%
associate-/l*89.5%
Simplified89.5%
Final simplification95.8%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* 0.5 (* x (/ y a)))))
(if (<= (* x y) -1e+220)
t_1
(if (<= (* x y) -2e-109)
(/ (* x y) (* a 2.0))
(if (<= (* x y) 5e+64) (/ (* -9.0 (* z t)) (* a 2.0)) t_1)))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -1e+220) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) / (a * 2.0);
} else if ((x * y) <= 5e+64) {
tmp = (-9.0 * (z * t)) / (a * 2.0);
} else {
tmp = t_1;
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = 0.5d0 * (x * (y / a))
if ((x * y) <= (-1d+220)) then
tmp = t_1
else if ((x * y) <= (-2d-109)) then
tmp = (x * y) / (a * 2.0d0)
else if ((x * y) <= 5d+64) then
tmp = ((-9.0d0) * (z * t)) / (a * 2.0d0)
else
tmp = t_1
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -1e+220) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) / (a * 2.0);
} else if ((x * y) <= 5e+64) {
tmp = (-9.0 * (z * t)) / (a * 2.0);
} else {
tmp = t_1;
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = 0.5 * (x * (y / a)) tmp = 0 if (x * y) <= -1e+220: tmp = t_1 elif (x * y) <= -2e-109: tmp = (x * y) / (a * 2.0) elif (x * y) <= 5e+64: tmp = (-9.0 * (z * t)) / (a * 2.0) else: tmp = t_1 return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) t_1 = Float64(0.5 * Float64(x * Float64(y / a))) tmp = 0.0 if (Float64(x * y) <= -1e+220) tmp = t_1; elseif (Float64(x * y) <= -2e-109) tmp = Float64(Float64(x * y) / Float64(a * 2.0)); elseif (Float64(x * y) <= 5e+64) tmp = Float64(Float64(-9.0 * Float64(z * t)) / Float64(a * 2.0)); else tmp = t_1; end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = 0.5 * (x * (y / a));
tmp = 0.0;
if ((x * y) <= -1e+220)
tmp = t_1;
elseif ((x * y) <= -2e-109)
tmp = (x * y) / (a * 2.0);
elseif ((x * y) <= 5e+64)
tmp = (-9.0 * (z * t)) / (a * 2.0);
else
tmp = t_1;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1e+220], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -2e-109], N[(N[(x * y), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+64], N[(N[(-9.0 * N[(z * t), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := 0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{if}\;x \cdot y \leq -1 \cdot 10^{+220}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -2 \cdot 10^{-109}:\\
\;\;\;\;\frac{x \cdot y}{a \cdot 2}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+64}:\\
\;\;\;\;\frac{-9 \cdot \left(z \cdot t\right)}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -1e220 or 5e64 < (*.f64 x y) Initial program 77.7%
div-sub74.9%
*-commutative74.9%
div-sub77.7%
cancel-sign-sub-inv77.7%
*-commutative77.7%
fma-define77.7%
distribute-rgt-neg-in77.7%
associate-*r*77.7%
distribute-lft-neg-in77.7%
*-commutative77.7%
distribute-rgt-neg-in77.7%
metadata-eval77.7%
Simplified77.7%
Taylor expanded in x around inf 73.8%
associate-/l*86.8%
Simplified86.8%
if -1e220 < (*.f64 x y) < -2e-109Initial program 96.5%
div-sub93.1%
*-commutative93.1%
div-sub96.5%
cancel-sign-sub-inv96.5%
*-commutative96.5%
fma-define96.5%
distribute-rgt-neg-in96.5%
associate-*r*96.5%
distribute-lft-neg-in96.5%
*-commutative96.5%
distribute-rgt-neg-in96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in x around inf 65.5%
if -2e-109 < (*.f64 x y) < 5e64Initial program 94.7%
div-sub93.9%
*-commutative93.9%
div-sub94.7%
cancel-sign-sub-inv94.7%
*-commutative94.7%
fma-define94.7%
distribute-rgt-neg-in94.7%
associate-*r*94.7%
distribute-lft-neg-in94.7%
*-commutative94.7%
distribute-rgt-neg-in94.7%
metadata-eval94.7%
Simplified94.7%
Taylor expanded in x around 0 76.4%
Final simplification77.0%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* 0.5 (* x (/ y a)))))
(if (<= (* x y) -1e+220)
t_1
(if (<= (* x y) -2e-109)
(/ (* x y) (* a 2.0))
(if (<= (* x y) 5e+64) (/ (* (* z t) -4.5) a) t_1)))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -1e+220) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) / (a * 2.0);
} else if ((x * y) <= 5e+64) {
tmp = ((z * t) * -4.5) / a;
} else {
tmp = t_1;
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = 0.5d0 * (x * (y / a))
if ((x * y) <= (-1d+220)) then
tmp = t_1
else if ((x * y) <= (-2d-109)) then
tmp = (x * y) / (a * 2.0d0)
else if ((x * y) <= 5d+64) then
tmp = ((z * t) * (-4.5d0)) / a
else
tmp = t_1
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -1e+220) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) / (a * 2.0);
} else if ((x * y) <= 5e+64) {
tmp = ((z * t) * -4.5) / a;
} else {
tmp = t_1;
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = 0.5 * (x * (y / a)) tmp = 0 if (x * y) <= -1e+220: tmp = t_1 elif (x * y) <= -2e-109: tmp = (x * y) / (a * 2.0) elif (x * y) <= 5e+64: tmp = ((z * t) * -4.5) / a else: tmp = t_1 return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) t_1 = Float64(0.5 * Float64(x * Float64(y / a))) tmp = 0.0 if (Float64(x * y) <= -1e+220) tmp = t_1; elseif (Float64(x * y) <= -2e-109) tmp = Float64(Float64(x * y) / Float64(a * 2.0)); elseif (Float64(x * y) <= 5e+64) tmp = Float64(Float64(Float64(z * t) * -4.5) / a); else tmp = t_1; end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = 0.5 * (x * (y / a));
tmp = 0.0;
if ((x * y) <= -1e+220)
tmp = t_1;
elseif ((x * y) <= -2e-109)
tmp = (x * y) / (a * 2.0);
elseif ((x * y) <= 5e+64)
tmp = ((z * t) * -4.5) / a;
else
tmp = t_1;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1e+220], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -2e-109], N[(N[(x * y), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+64], N[(N[(N[(z * t), $MachinePrecision] * -4.5), $MachinePrecision] / a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := 0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{if}\;x \cdot y \leq -1 \cdot 10^{+220}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -2 \cdot 10^{-109}:\\
\;\;\;\;\frac{x \cdot y}{a \cdot 2}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+64}:\\
\;\;\;\;\frac{\left(z \cdot t\right) \cdot -4.5}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -1e220 or 5e64 < (*.f64 x y) Initial program 77.7%
div-sub74.9%
*-commutative74.9%
div-sub77.7%
cancel-sign-sub-inv77.7%
*-commutative77.7%
fma-define77.7%
distribute-rgt-neg-in77.7%
associate-*r*77.7%
distribute-lft-neg-in77.7%
*-commutative77.7%
distribute-rgt-neg-in77.7%
metadata-eval77.7%
Simplified77.7%
Taylor expanded in x around inf 73.8%
associate-/l*86.8%
Simplified86.8%
if -1e220 < (*.f64 x y) < -2e-109Initial program 96.5%
div-sub93.1%
*-commutative93.1%
div-sub96.5%
cancel-sign-sub-inv96.5%
*-commutative96.5%
fma-define96.5%
distribute-rgt-neg-in96.5%
associate-*r*96.5%
distribute-lft-neg-in96.5%
*-commutative96.5%
distribute-rgt-neg-in96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in x around inf 65.5%
if -2e-109 < (*.f64 x y) < 5e64Initial program 94.7%
div-sub93.9%
*-commutative93.9%
div-sub94.7%
cancel-sign-sub-inv94.7%
*-commutative94.7%
fma-define94.7%
distribute-rgt-neg-in94.7%
associate-*r*94.7%
distribute-lft-neg-in94.7%
*-commutative94.7%
distribute-rgt-neg-in94.7%
metadata-eval94.7%
Simplified94.7%
*-un-lft-identity94.7%
*-un-lft-identity94.7%
*-commutative94.7%
associate-*r*94.7%
metadata-eval94.7%
distribute-rgt-neg-in94.7%
distribute-lft-neg-in94.7%
fmm-def94.7%
div-sub93.9%
associate-/l*91.2%
associate-*l*91.2%
associate-/l*88.0%
Applied egg-rr88.0%
Taylor expanded in a around 0 94.7%
Taylor expanded in x around 0 76.4%
Final simplification77.0%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* 0.5 (* x (/ y a)))))
(if (<= (* x y) -2e+221)
t_1
(if (<= (* x y) -2e-109)
(* (* x y) (/ 0.5 a))
(if (<= (* x y) 5e+64) (/ (* (* z t) -4.5) a) t_1)))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -2e+221) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) * (0.5 / a);
} else if ((x * y) <= 5e+64) {
tmp = ((z * t) * -4.5) / a;
} else {
tmp = t_1;
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = 0.5d0 * (x * (y / a))
if ((x * y) <= (-2d+221)) then
tmp = t_1
else if ((x * y) <= (-2d-109)) then
tmp = (x * y) * (0.5d0 / a)
else if ((x * y) <= 5d+64) then
tmp = ((z * t) * (-4.5d0)) / a
else
tmp = t_1
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -2e+221) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) * (0.5 / a);
} else if ((x * y) <= 5e+64) {
tmp = ((z * t) * -4.5) / a;
} else {
tmp = t_1;
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = 0.5 * (x * (y / a)) tmp = 0 if (x * y) <= -2e+221: tmp = t_1 elif (x * y) <= -2e-109: tmp = (x * y) * (0.5 / a) elif (x * y) <= 5e+64: tmp = ((z * t) * -4.5) / a else: tmp = t_1 return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) t_1 = Float64(0.5 * Float64(x * Float64(y / a))) tmp = 0.0 if (Float64(x * y) <= -2e+221) tmp = t_1; elseif (Float64(x * y) <= -2e-109) tmp = Float64(Float64(x * y) * Float64(0.5 / a)); elseif (Float64(x * y) <= 5e+64) tmp = Float64(Float64(Float64(z * t) * -4.5) / a); else tmp = t_1; end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = 0.5 * (x * (y / a));
tmp = 0.0;
if ((x * y) <= -2e+221)
tmp = t_1;
elseif ((x * y) <= -2e-109)
tmp = (x * y) * (0.5 / a);
elseif ((x * y) <= 5e+64)
tmp = ((z * t) * -4.5) / a;
else
tmp = t_1;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2e+221], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -2e-109], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+64], N[(N[(N[(z * t), $MachinePrecision] * -4.5), $MachinePrecision] / a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := 0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+221}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -2 \cdot 10^{-109}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+64}:\\
\;\;\;\;\frac{\left(z \cdot t\right) \cdot -4.5}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -2.0000000000000001e221 or 5e64 < (*.f64 x y) Initial program 77.4%
div-sub74.6%
*-commutative74.6%
div-sub77.4%
cancel-sign-sub-inv77.4%
*-commutative77.4%
fma-define77.4%
distribute-rgt-neg-in77.4%
associate-*r*77.4%
distribute-lft-neg-in77.4%
*-commutative77.4%
distribute-rgt-neg-in77.4%
metadata-eval77.4%
Simplified77.4%
Taylor expanded in x around inf 73.5%
associate-/l*86.6%
Simplified86.6%
if -2.0000000000000001e221 < (*.f64 x y) < -2e-109Initial program 96.5%
div-sub93.2%
*-commutative93.2%
div-sub96.5%
cancel-sign-sub-inv96.5%
*-commutative96.5%
fma-define96.6%
distribute-rgt-neg-in96.6%
associate-*r*96.5%
distribute-lft-neg-in96.5%
*-commutative96.5%
distribute-rgt-neg-in96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in a around 0 96.5%
associate-*r/96.5%
+-commutative96.5%
metadata-eval96.5%
cancel-sign-sub-inv96.5%
cancel-sign-sub-inv96.5%
metadata-eval96.5%
*-commutative96.5%
*-commutative96.5%
associate-*r*96.5%
fma-define96.5%
associate-*l/96.5%
*-commutative96.5%
fma-define96.5%
+-commutative96.5%
fma-define96.5%
Simplified96.5%
Taylor expanded in z around 0 66.0%
if -2e-109 < (*.f64 x y) < 5e64Initial program 94.7%
div-sub93.9%
*-commutative93.9%
div-sub94.7%
cancel-sign-sub-inv94.7%
*-commutative94.7%
fma-define94.7%
distribute-rgt-neg-in94.7%
associate-*r*94.7%
distribute-lft-neg-in94.7%
*-commutative94.7%
distribute-rgt-neg-in94.7%
metadata-eval94.7%
Simplified94.7%
*-un-lft-identity94.7%
*-un-lft-identity94.7%
*-commutative94.7%
associate-*r*94.7%
metadata-eval94.7%
distribute-rgt-neg-in94.7%
distribute-lft-neg-in94.7%
fmm-def94.7%
div-sub93.9%
associate-/l*91.2%
associate-*l*91.2%
associate-/l*88.0%
Applied egg-rr88.0%
Taylor expanded in a around 0 94.7%
Taylor expanded in x around 0 76.4%
Final simplification76.9%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* 0.5 (* x (/ y a)))))
(if (<= (* x y) -2e+221)
t_1
(if (<= (* x y) -2e-109)
(* (* x y) (/ 0.5 a))
(if (<= (* x y) 5e+64) (* -4.5 (/ (* z t) a)) t_1)))))assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -2e+221) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) * (0.5 / a);
} else if ((x * y) <= 5e+64) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = t_1;
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) :: t_1
real(8) :: tmp
t_1 = 0.5d0 * (x * (y / a))
if ((x * y) <= (-2d+221)) then
tmp = t_1
else if ((x * y) <= (-2d-109)) then
tmp = (x * y) * (0.5d0 / a)
else if ((x * y) <= 5d+64) then
tmp = (-4.5d0) * ((z * t) / a)
else
tmp = t_1
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = 0.5 * (x * (y / a));
double tmp;
if ((x * y) <= -2e+221) {
tmp = t_1;
} else if ((x * y) <= -2e-109) {
tmp = (x * y) * (0.5 / a);
} else if ((x * y) <= 5e+64) {
tmp = -4.5 * ((z * t) / a);
} else {
tmp = t_1;
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): t_1 = 0.5 * (x * (y / a)) tmp = 0 if (x * y) <= -2e+221: tmp = t_1 elif (x * y) <= -2e-109: tmp = (x * y) * (0.5 / a) elif (x * y) <= 5e+64: tmp = -4.5 * ((z * t) / a) else: tmp = t_1 return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) t_1 = Float64(0.5 * Float64(x * Float64(y / a))) tmp = 0.0 if (Float64(x * y) <= -2e+221) tmp = t_1; elseif (Float64(x * y) <= -2e-109) tmp = Float64(Float64(x * y) * Float64(0.5 / a)); elseif (Float64(x * y) <= 5e+64) tmp = Float64(-4.5 * Float64(Float64(z * t) / a)); else tmp = t_1; end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = 0.5 * (x * (y / a));
tmp = 0.0;
if ((x * y) <= -2e+221)
tmp = t_1;
elseif ((x * y) <= -2e-109)
tmp = (x * y) * (0.5 / a);
elseif ((x * y) <= 5e+64)
tmp = -4.5 * ((z * t) / a);
else
tmp = t_1;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2e+221], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -2e-109], N[(N[(x * y), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+64], N[(-4.5 * N[(N[(z * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
t_1 := 0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+221}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -2 \cdot 10^{-109}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \frac{0.5}{a}\\
\mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+64}:\\
\;\;\;\;-4.5 \cdot \frac{z \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -2.0000000000000001e221 or 5e64 < (*.f64 x y) Initial program 77.4%
div-sub74.6%
*-commutative74.6%
div-sub77.4%
cancel-sign-sub-inv77.4%
*-commutative77.4%
fma-define77.4%
distribute-rgt-neg-in77.4%
associate-*r*77.4%
distribute-lft-neg-in77.4%
*-commutative77.4%
distribute-rgt-neg-in77.4%
metadata-eval77.4%
Simplified77.4%
Taylor expanded in x around inf 73.5%
associate-/l*86.6%
Simplified86.6%
if -2.0000000000000001e221 < (*.f64 x y) < -2e-109Initial program 96.5%
div-sub93.2%
*-commutative93.2%
div-sub96.5%
cancel-sign-sub-inv96.5%
*-commutative96.5%
fma-define96.6%
distribute-rgt-neg-in96.6%
associate-*r*96.5%
distribute-lft-neg-in96.5%
*-commutative96.5%
distribute-rgt-neg-in96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in a around 0 96.5%
associate-*r/96.5%
+-commutative96.5%
metadata-eval96.5%
cancel-sign-sub-inv96.5%
cancel-sign-sub-inv96.5%
metadata-eval96.5%
*-commutative96.5%
*-commutative96.5%
associate-*r*96.5%
fma-define96.5%
associate-*l/96.5%
*-commutative96.5%
fma-define96.5%
+-commutative96.5%
fma-define96.5%
Simplified96.5%
Taylor expanded in z around 0 66.0%
if -2e-109 < (*.f64 x y) < 5e64Initial program 94.7%
div-sub93.9%
*-commutative93.9%
div-sub94.7%
cancel-sign-sub-inv94.7%
*-commutative94.7%
fma-define94.7%
distribute-rgt-neg-in94.7%
associate-*r*94.7%
distribute-lft-neg-in94.7%
*-commutative94.7%
distribute-rgt-neg-in94.7%
metadata-eval94.7%
Simplified94.7%
Taylor expanded in x around 0 76.4%
Final simplification76.9%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) -2e+256) (* 0.5 (* x (/ y a))) (/ (- (* x y) (* z (* 9.0 t))) (* a 2.0))))
assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+256) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) <= (-2d+256)) then
tmp = 0.5d0 * (x * (y / a))
else
tmp = ((x * y) - (z * (9.0d0 * t))) / (a * 2.0d0)
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+256) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): tmp = 0 if (x * y) <= -2e+256: tmp = 0.5 * (x * (y / a)) else: tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -2e+256) tmp = Float64(0.5 * Float64(x * Float64(y / a))); else tmp = Float64(Float64(Float64(x * y) - Float64(z * Float64(9.0 * t))) / Float64(a * 2.0)); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((x * y) <= -2e+256)
tmp = 0.5 * (x * (y / a));
else
tmp = ((x * y) - (z * (9.0 * t))) / (a * 2.0);
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -2e+256], N[(0.5 * N[(x * N[(y / a), $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}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+256}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y - z \cdot \left(9 \cdot t\right)}{a \cdot 2}\\
\end{array}
\end{array}
if (*.f64 x y) < -2.0000000000000001e256Initial program 65.6%
div-sub65.6%
*-commutative65.6%
div-sub65.6%
cancel-sign-sub-inv65.6%
*-commutative65.6%
fma-define65.6%
distribute-rgt-neg-in65.6%
associate-*r*65.6%
distribute-lft-neg-in65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in x around inf 73.6%
associate-/l*99.9%
Simplified99.9%
if -2.0000000000000001e256 < (*.f64 x y) Initial program 92.9%
div-sub90.7%
*-commutative90.7%
div-sub92.9%
cancel-sign-sub-inv92.9%
*-commutative92.9%
fma-define92.9%
distribute-rgt-neg-in92.9%
associate-*r*92.9%
distribute-lft-neg-in92.9%
*-commutative92.9%
distribute-rgt-neg-in92.9%
metadata-eval92.9%
Simplified92.9%
*-commutative92.9%
associate-*r*92.9%
metadata-eval92.9%
distribute-rgt-neg-in92.9%
distribute-lft-neg-in92.9%
fmm-def92.9%
associate-*l*92.9%
Applied egg-rr92.9%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= (* x y) -2e+256) (* 0.5 (* x (/ y a))) (/ (- (* (* x y) 0.5) (* 4.5 (* z t))) a)))
assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+256) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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) <= (-2d+256)) then
tmp = 0.5d0 * (x * (y / a))
else
tmp = (((x * y) * 0.5d0) - (4.5d0 * (z * t))) / a
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x * y) <= -2e+256) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): tmp = 0 if (x * y) <= -2e+256: tmp = 0.5 * (x * (y / a)) else: tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) tmp = 0.0 if (Float64(x * y) <= -2e+256) tmp = Float64(0.5 * Float64(x * Float64(y / a))); else tmp = Float64(Float64(Float64(Float64(x * y) * 0.5) - Float64(4.5 * Float64(z * t))) / a); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((x * y) <= -2e+256)
tmp = 0.5 * (x * (y / a));
else
tmp = (((x * y) * 0.5) - (4.5 * (z * t))) / a;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x * y), $MachinePrecision], -2e+256], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(x * y), $MachinePrecision] * 0.5), $MachinePrecision] - N[(4.5 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -2 \cdot 10^{+256}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(x \cdot y\right) \cdot 0.5 - 4.5 \cdot \left(z \cdot t\right)}{a}\\
\end{array}
\end{array}
if (*.f64 x y) < -2.0000000000000001e256Initial program 65.6%
div-sub65.6%
*-commutative65.6%
div-sub65.6%
cancel-sign-sub-inv65.6%
*-commutative65.6%
fma-define65.6%
distribute-rgt-neg-in65.6%
associate-*r*65.6%
distribute-lft-neg-in65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in x around inf 73.6%
associate-/l*99.9%
Simplified99.9%
if -2.0000000000000001e256 < (*.f64 x y) Initial program 92.9%
div-sub90.7%
*-commutative90.7%
div-sub92.9%
cancel-sign-sub-inv92.9%
*-commutative92.9%
fma-define92.9%
distribute-rgt-neg-in92.9%
associate-*r*92.9%
distribute-lft-neg-in92.9%
*-commutative92.9%
distribute-rgt-neg-in92.9%
metadata-eval92.9%
Simplified92.9%
*-un-lft-identity92.9%
*-un-lft-identity92.9%
*-commutative92.9%
associate-*r*92.9%
metadata-eval92.9%
distribute-rgt-neg-in92.9%
distribute-lft-neg-in92.9%
fmm-def92.9%
div-sub90.7%
associate-/l*88.0%
associate-*l*88.0%
associate-/l*87.5%
Applied egg-rr87.5%
Taylor expanded in a around 0 92.9%
Final simplification93.6%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (or (<= z -7.2e+22) (not (<= z 2.4e-27))) (* -4.5 (* t (/ z a))) (* 0.5 (* x (/ y a)))))
assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -7.2e+22) || !(z <= 2.4e-27)) {
tmp = -4.5 * (t * (z / a));
} else {
tmp = 0.5 * (x * (y / a));
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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 ((z <= (-7.2d+22)) .or. (.not. (z <= 2.4d-27))) then
tmp = (-4.5d0) * (t * (z / a))
else
tmp = 0.5d0 * (x * (y / a))
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -7.2e+22) || !(z <= 2.4e-27)) {
tmp = -4.5 * (t * (z / a));
} else {
tmp = 0.5 * (x * (y / a));
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): tmp = 0 if (z <= -7.2e+22) or not (z <= 2.4e-27): tmp = -4.5 * (t * (z / a)) else: tmp = 0.5 * (x * (y / a)) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) tmp = 0.0 if ((z <= -7.2e+22) || !(z <= 2.4e-27)) tmp = Float64(-4.5 * Float64(t * Float64(z / a))); else tmp = Float64(0.5 * Float64(x * Float64(y / a))); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if ((z <= -7.2e+22) || ~((z <= 2.4e-27)))
tmp = -4.5 * (t * (z / a));
else
tmp = 0.5 * (x * (y / a));
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -7.2e+22], N[Not[LessEqual[z, 2.4e-27]], $MachinePrecision]], N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.2 \cdot 10^{+22} \lor \neg \left(z \leq 2.4 \cdot 10^{-27}\right):\\
\;\;\;\;-4.5 \cdot \left(t \cdot \frac{z}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\end{array}
\end{array}
if z < -7.2e22 or 2.40000000000000002e-27 < z Initial program 89.2%
div-sub85.7%
*-commutative85.7%
div-sub89.2%
cancel-sign-sub-inv89.2%
*-commutative89.2%
fma-define89.2%
distribute-rgt-neg-in89.2%
associate-*r*89.2%
distribute-lft-neg-in89.2%
*-commutative89.2%
distribute-rgt-neg-in89.2%
metadata-eval89.2%
Simplified89.2%
Taylor expanded in x around 0 62.9%
associate-/l*66.8%
Simplified66.8%
if -7.2e22 < z < 2.40000000000000002e-27Initial program 91.6%
div-sub91.6%
*-commutative91.6%
div-sub91.6%
cancel-sign-sub-inv91.6%
*-commutative91.6%
fma-define91.6%
distribute-rgt-neg-in91.6%
associate-*r*91.6%
distribute-lft-neg-in91.6%
*-commutative91.6%
distribute-rgt-neg-in91.6%
metadata-eval91.6%
Simplified91.6%
Taylor expanded in x around inf 66.5%
associate-/l*71.1%
Simplified71.1%
Final simplification68.6%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z -1.6e+23) (* t (* -4.5 (/ z a))) (if (<= z 2.3e-27) (* 0.5 (* x (/ y a))) (* -4.5 (* t (/ z a))))))
assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.6e+23) {
tmp = t * (-4.5 * (z / a));
} else if (z <= 2.3e-27) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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 (z <= (-1.6d+23)) then
tmp = t * ((-4.5d0) * (z / a))
else if (z <= 2.3d-27) then
tmp = 0.5d0 * (x * (y / a))
else
tmp = (-4.5d0) * (t * (z / a))
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.6e+23) {
tmp = t * (-4.5 * (z / a));
} else if (z <= 2.3e-27) {
tmp = 0.5 * (x * (y / a));
} else {
tmp = -4.5 * (t * (z / a));
}
return tmp;
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): tmp = 0 if z <= -1.6e+23: tmp = t * (-4.5 * (z / a)) elif z <= 2.3e-27: tmp = 0.5 * (x * (y / a)) else: tmp = -4.5 * (t * (z / a)) return tmp
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.6e+23) tmp = Float64(t * Float64(-4.5 * Float64(z / a))); elseif (z <= 2.3e-27) tmp = Float64(0.5 * Float64(x * Float64(y / a))); else tmp = Float64(-4.5 * Float64(t * Float64(z / a))); end return tmp end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -1.6e+23)
tmp = t * (-4.5 * (z / a));
elseif (z <= 2.3e-27)
tmp = 0.5 * (x * (y / a));
else
tmp = -4.5 * (t * (z / a));
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.6e+23], N[(t * N[(-4.5 * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e-27], N[(0.5 * N[(x * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.6 \cdot 10^{+23}:\\
\;\;\;\;t \cdot \left(-4.5 \cdot \frac{z}{a}\right)\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{-27}:\\
\;\;\;\;0.5 \cdot \left(x \cdot \frac{y}{a}\right)\\
\mathbf{else}:\\
\;\;\;\;-4.5 \cdot \left(t \cdot \frac{z}{a}\right)\\
\end{array}
\end{array}
if z < -1.6e23Initial program 84.3%
div-sub81.5%
*-commutative81.5%
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 x around 0 60.7%
*-commutative60.7%
associate-/l*69.4%
associate-*r*69.5%
*-commutative69.5%
Simplified69.5%
if -1.6e23 < z < 2.2999999999999999e-27Initial program 91.6%
div-sub91.6%
*-commutative91.6%
div-sub91.6%
cancel-sign-sub-inv91.6%
*-commutative91.6%
fma-define91.6%
distribute-rgt-neg-in91.6%
associate-*r*91.6%
distribute-lft-neg-in91.6%
*-commutative91.6%
distribute-rgt-neg-in91.6%
metadata-eval91.6%
Simplified91.6%
Taylor expanded in x around inf 66.5%
associate-/l*71.1%
Simplified71.1%
if 2.2999999999999999e-27 < z Initial program 94.3%
div-sub90.1%
*-commutative90.1%
div-sub94.3%
cancel-sign-sub-inv94.3%
*-commutative94.3%
fma-define94.3%
distribute-rgt-neg-in94.3%
associate-*r*94.3%
distribute-lft-neg-in94.3%
*-commutative94.3%
distribute-rgt-neg-in94.3%
metadata-eval94.3%
Simplified94.3%
Taylor expanded in x around 0 65.1%
associate-/l*64.1%
Simplified64.1%
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (* -4.5 (* t (/ z a))))
assert(x < y && y < z && z < t && t < a);
assert(x < y && y < z && z < t && t < a);
double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function.
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
assert x < y && y < z && z < t && t < a;
assert x < y && y < z && z < t && t < a;
public static double code(double x, double y, double z, double t, double a) {
return -4.5 * (t * (z / a));
}
[x, y, z, t, a] = sort([x, y, z, t, a]) [x, y, z, t, a] = sort([x, y, z, t, a]) def code(x, y, z, t, a): return -4.5 * (t * (z / a))
x, y, z, t, a = sort([x, y, z, t, a]) x, y, z, t, a = sort([x, y, z, t, a]) function code(x, y, z, t, a) return Float64(-4.5 * Float64(t * Float64(z / a))) end
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
x, y, z, t, a = num2cell(sort([x, y, z, t, a])){:}
function tmp = code(x, y, z, t, a)
tmp = -4.5 * (t * (z / a));
end
NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. NOTE: x, y, z, t, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := N[(-4.5 * N[(t * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\\\
[x, y, z, t, a] = \mathsf{sort}([x, y, z, t, a])\\
\\
-4.5 \cdot \left(t \cdot \frac{z}{a}\right)
\end{array}
Initial program 90.2%
div-sub88.3%
*-commutative88.3%
div-sub90.2%
cancel-sign-sub-inv90.2%
*-commutative90.2%
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 0 51.5%
associate-/l*51.9%
Simplified51.9%
(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 2024191
(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)))