
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * 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 = ((x * y) * z) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * 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 = ((x * y) * z) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ a (/ (* z z) t))))
(if (<= z -1.15e+103)
(/ (* x y) (fma 0.5 t_1 -1.0))
(if (<= z 2.4e-14)
(/ x (/ (sqrt (- (* z z) (* a t))) (* z y)))
(/ (* x y) (sqrt (- 1.0 t_1)))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double t_1 = a / ((z * z) / t);
double tmp;
if (z <= -1.15e+103) {
tmp = (x * y) / fma(0.5, t_1, -1.0);
} else if (z <= 2.4e-14) {
tmp = x / (sqrt(((z * z) - (a * t))) / (z * y));
} else {
tmp = (x * y) / sqrt((1.0 - t_1));
}
return tmp;
}
x, y = sort([x, y]) function code(x, y, z, t, a) t_1 = Float64(a / Float64(Float64(z * z) / t)) tmp = 0.0 if (z <= -1.15e+103) tmp = Float64(Float64(x * y) / fma(0.5, t_1, -1.0)); elseif (z <= 2.4e-14) tmp = Float64(x / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / Float64(z * y))); else tmp = Float64(Float64(x * y) / sqrt(Float64(1.0 - t_1))); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(a / N[(N[(z * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.15e+103], N[(N[(x * y), $MachinePrecision] / N[(0.5 * t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.4e-14], N[(x / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[Sqrt[N[(1.0 - t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := \frac{a}{\frac{z \cdot z}{t}}\\
\mathbf{if}\;z \leq -1.15 \cdot 10^{+103}:\\
\;\;\;\;\frac{x \cdot y}{\mathsf{fma}\left(0.5, t_1, -1\right)}\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x}{\frac{\sqrt{z \cdot z - a \cdot t}}{z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{\sqrt{1 - t_1}}\\
\end{array}
\end{array}
if z < -1.15000000000000004e103Initial program 40.9%
associate-/l*41.3%
Simplified41.3%
Taylor expanded in z around -inf 87.8%
fma-neg87.8%
unpow287.8%
associate-/l*96.2%
metadata-eval96.2%
Simplified96.2%
if -1.15000000000000004e103 < z < 2.4e-14Initial program 75.7%
*-commutative75.7%
associate-*l*78.8%
associate-*r/82.0%
Simplified82.0%
*-commutative82.0%
associate-/l*82.8%
associate-/r/83.4%
associate-/l/82.4%
*-commutative82.4%
Applied egg-rr82.4%
if 2.4e-14 < z Initial program 45.2%
associate-/l*48.5%
Simplified48.5%
add-sqr-sqrt48.5%
sqrt-unprod48.5%
frac-times38.7%
add-sqr-sqrt38.7%
Applied egg-rr38.7%
div-sub38.7%
*-inverses94.4%
*-commutative94.4%
associate-/l*98.9%
Simplified98.9%
Final simplification90.7%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -5e+153)
(* x (- y))
(if (<= z 1e+96)
(* y (/ x (/ (sqrt (- (* z z) (* a t))) z)))
(/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5e+153) {
tmp = x * -y;
} else if (z <= 1e+96) {
tmp = y * (x / (sqrt(((z * z) - (a * t))) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= (-5d+153)) then
tmp = x * -y
else if (z <= 1d+96) then
tmp = y * (x / (sqrt(((z * z) - (a * t))) / z))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5e+153) {
tmp = x * -y;
} else if (z <= 1e+96) {
tmp = y * (x / (Math.sqrt(((z * z) - (a * t))) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -5e+153: tmp = x * -y elif z <= 1e+96: tmp = y * (x / (math.sqrt(((z * z) - (a * t))) / z)) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -5e+153) tmp = Float64(x * Float64(-y)); elseif (z <= 1e+96) tmp = Float64(y * Float64(x / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / z))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -5e+153)
tmp = x * -y;
elseif (z <= 1e+96)
tmp = y * (x / (sqrt(((z * z) - (a * t))) / z));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5e+153], N[(x * (-y)), $MachinePrecision], If[LessEqual[z, 1e+96], N[(y * N[(x / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5 \cdot 10^{+153}:\\
\;\;\;\;x \cdot \left(-y\right)\\
\mathbf{elif}\;z \leq 10^{+96}:\\
\;\;\;\;y \cdot \frac{x}{\frac{\sqrt{z \cdot z - a \cdot t}}{z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < -5.00000000000000018e153Initial program 14.3%
*-commutative14.3%
associate-*l*14.1%
associate-*r/14.2%
Simplified14.2%
Taylor expanded in z around -inf 97.2%
neg-mul-197.2%
Simplified97.2%
if -5.00000000000000018e153 < z < 1.00000000000000005e96Initial program 80.3%
*-commutative80.3%
associate-*l*80.2%
associate-*r/82.7%
Simplified82.7%
associate-/l*86.3%
add-cube-cbrt85.3%
*-un-lft-identity85.3%
times-frac85.3%
pow285.3%
Applied egg-rr85.3%
/-rgt-identity85.3%
associate-*r/85.3%
unpow285.3%
rem-3cbrt-lft86.3%
*-commutative86.3%
Simplified86.3%
if 1.00000000000000005e96 < z Initial program 28.7%
associate-/l*31.8%
Simplified31.8%
Taylor expanded in z around inf 93.9%
unpow293.9%
associate-/l*95.7%
Simplified95.7%
Taylor expanded in z around 0 95.7%
unpow295.7%
associate-*r/95.7%
Simplified95.7%
Final simplification90.1%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.5e+104)
(* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z)))
(if (<= z 2.7e-14)
(/ x (/ (sqrt (- (* z z) (* a t))) (* z y)))
(/ (* x y) (sqrt (- 1.0 (/ a (/ (* z z) t))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.5e+104) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 2.7e-14) {
tmp = x / (sqrt(((z * z) - (a * t))) / (z * y));
} else {
tmp = (x * y) / sqrt((1.0 - (a / ((z * z) / t))));
}
return tmp;
}
NOTE: x and y 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.5d+104)) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else if (z <= 2.7d-14) then
tmp = x / (sqrt(((z * z) - (a * t))) / (z * y))
else
tmp = (x * y) / sqrt((1.0d0 - (a / ((z * z) / t))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.5e+104) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 2.7e-14) {
tmp = x / (Math.sqrt(((z * z) - (a * t))) / (z * y));
} else {
tmp = (x * y) / Math.sqrt((1.0 - (a / ((z * z) / t))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -1.5e+104: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) elif z <= 2.7e-14: tmp = x / (math.sqrt(((z * z) - (a * t))) / (z * y)) else: tmp = (x * y) / math.sqrt((1.0 - (a / ((z * z) / t)))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.5e+104) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); elseif (z <= 2.7e-14) tmp = Float64(x / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / Float64(z * y))); else tmp = Float64(Float64(x * y) / sqrt(Float64(1.0 - Float64(a / Float64(Float64(z * z) / t))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -1.5e+104)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
elseif (z <= 2.7e-14)
tmp = x / (sqrt(((z * z) - (a * t))) / (z * y));
else
tmp = (x * y) / sqrt((1.0 - (a / ((z * z) / t))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.5e+104], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.7e-14], N[(x / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[Sqrt[N[(1.0 - N[(a / N[(N[(z * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.5 \cdot 10^{+104}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{elif}\;z \leq 2.7 \cdot 10^{-14}:\\
\;\;\;\;\frac{x}{\frac{\sqrt{z \cdot z - a \cdot t}}{z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{\sqrt{1 - \frac{a}{\frac{z \cdot z}{t}}}}\\
\end{array}
\end{array}
if z < -1.49999999999999984e104Initial program 40.9%
*-commutative40.9%
associate-*l*32.8%
associate-*r/33.0%
Simplified33.0%
associate-/l*41.4%
add-cube-cbrt41.1%
*-un-lft-identity41.1%
times-frac41.1%
pow241.1%
Applied egg-rr41.1%
/-rgt-identity41.1%
associate-*r/41.1%
unpow241.1%
rem-3cbrt-lft41.4%
*-commutative41.4%
Simplified41.4%
Taylor expanded in z around -inf 90.1%
associate-/l*96.2%
mul-1-neg96.2%
unsub-neg96.2%
associate-/r/96.2%
*-commutative96.2%
Simplified96.2%
if -1.49999999999999984e104 < z < 2.6999999999999999e-14Initial program 75.7%
*-commutative75.7%
associate-*l*78.8%
associate-*r/82.0%
Simplified82.0%
*-commutative82.0%
associate-/l*82.8%
associate-/r/83.4%
associate-/l/82.4%
*-commutative82.4%
Applied egg-rr82.4%
if 2.6999999999999999e-14 < z Initial program 45.2%
associate-/l*48.5%
Simplified48.5%
add-sqr-sqrt48.5%
sqrt-unprod48.5%
frac-times38.7%
add-sqr-sqrt38.7%
Applied egg-rr38.7%
div-sub38.7%
*-inverses94.4%
*-commutative94.4%
associate-/l*98.9%
Simplified98.9%
Final simplification90.7%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -3.6e-97)
(* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z)))
(if (<= z 5.5e-134)
(* x (* (* z y) (/ 1.0 (sqrt (* a (- t))))))
(/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.6e-97) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 5.5e-134) {
tmp = x * ((z * y) * (1.0 / sqrt((a * -t))));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= (-3.6d-97)) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else if (z <= 5.5d-134) then
tmp = x * ((z * y) * (1.0d0 / sqrt((a * -t))))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.6e-97) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 5.5e-134) {
tmp = x * ((z * y) * (1.0 / Math.sqrt((a * -t))));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -3.6e-97: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) elif z <= 5.5e-134: tmp = x * ((z * y) * (1.0 / math.sqrt((a * -t)))) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.6e-97) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); elseif (z <= 5.5e-134) tmp = Float64(x * Float64(Float64(z * y) * Float64(1.0 / sqrt(Float64(a * Float64(-t)))))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -3.6e-97)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
elseif (z <= 5.5e-134)
tmp = x * ((z * y) * (1.0 / sqrt((a * -t))));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.6e-97], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e-134], N[(x * N[(N[(z * y), $MachinePrecision] * N[(1.0 / N[Sqrt[N[(a * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.6 \cdot 10^{-97}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{-134}:\\
\;\;\;\;x \cdot \left(\left(z \cdot y\right) \cdot \frac{1}{\sqrt{a \cdot \left(-t\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < -3.59999999999999997e-97Initial program 64.8%
*-commutative64.8%
associate-*l*60.5%
associate-*r/62.6%
Simplified62.6%
associate-/l*67.0%
add-cube-cbrt66.1%
*-un-lft-identity66.1%
times-frac66.1%
pow266.1%
Applied egg-rr66.1%
/-rgt-identity66.1%
associate-*r/66.1%
unpow266.1%
rem-3cbrt-lft67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in z around -inf 84.6%
associate-/l*87.7%
mul-1-neg87.7%
unsub-neg87.7%
associate-/r/87.7%
*-commutative87.7%
Simplified87.7%
if -3.59999999999999997e-97 < z < 5.5000000000000002e-134Initial program 61.9%
*-commutative61.9%
associate-*l*66.9%
associate-*r/72.0%
Simplified72.0%
*-commutative72.0%
associate-/l*73.5%
associate-/r/75.0%
associate-/l/75.9%
*-commutative75.9%
Applied egg-rr75.9%
Taylor expanded in z around 0 74.0%
associate-*r*74.0%
neg-mul-174.0%
Simplified74.0%
div-inv73.9%
*-commutative73.9%
Applied egg-rr73.9%
associate-/r/74.0%
Simplified74.0%
if 5.5000000000000002e-134 < z Initial program 51.6%
associate-/l*54.5%
Simplified54.5%
Taylor expanded in z around inf 87.1%
unpow287.1%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in z around 0 88.2%
unpow288.2%
associate-*r/88.2%
Simplified88.2%
Final simplification84.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -1e-96)
(* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z)))
(if (<= z 9.2e-100)
(* y (/ x (/ (sqrt (* a (- t))) z)))
(/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e-96) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 9.2e-100) {
tmp = y * (x / (sqrt((a * -t)) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= (-1d-96)) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else if (z <= 9.2d-100) then
tmp = y * (x / (sqrt((a * -t)) / z))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1e-96) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 9.2e-100) {
tmp = y * (x / (Math.sqrt((a * -t)) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -1e-96: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) elif z <= 9.2e-100: tmp = y * (x / (math.sqrt((a * -t)) / z)) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -1e-96) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); elseif (z <= 9.2e-100) tmp = Float64(y * Float64(x / Float64(sqrt(Float64(a * Float64(-t))) / z))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -1e-96)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
elseif (z <= 9.2e-100)
tmp = y * (x / (sqrt((a * -t)) / z));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1e-96], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.2e-100], N[(y * N[(x / N[(N[Sqrt[N[(a * (-t)), $MachinePrecision]], $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \cdot 10^{-96}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{elif}\;z \leq 9.2 \cdot 10^{-100}:\\
\;\;\;\;y \cdot \frac{x}{\frac{\sqrt{a \cdot \left(-t\right)}}{z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < -9.9999999999999991e-97Initial program 64.8%
*-commutative64.8%
associate-*l*60.5%
associate-*r/62.6%
Simplified62.6%
associate-/l*67.0%
add-cube-cbrt66.1%
*-un-lft-identity66.1%
times-frac66.1%
pow266.1%
Applied egg-rr66.1%
/-rgt-identity66.1%
associate-*r/66.1%
unpow266.1%
rem-3cbrt-lft67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in z around -inf 84.6%
associate-/l*87.7%
mul-1-neg87.7%
unsub-neg87.7%
associate-/r/87.7%
*-commutative87.7%
Simplified87.7%
if -9.9999999999999991e-97 < z < 9.19999999999999978e-100Initial program 61.9%
*-commutative61.9%
associate-*l*68.1%
associate-*r/72.8%
Simplified72.8%
associate-/l*74.1%
add-cube-cbrt73.6%
*-un-lft-identity73.6%
times-frac73.5%
pow273.5%
Applied egg-rr73.5%
/-rgt-identity73.5%
associate-*r/73.6%
unpow273.6%
rem-3cbrt-lft74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 70.7%
neg-mul-170.7%
distribute-lft-neg-in70.7%
*-commutative70.7%
Simplified70.7%
if 9.19999999999999978e-100 < z Initial program 51.1%
associate-/l*54.1%
Simplified54.1%
Taylor expanded in z around inf 89.2%
unpow289.2%
associate-/l*90.4%
Simplified90.4%
Taylor expanded in z around 0 90.4%
unpow290.4%
associate-*r/90.4%
Simplified90.4%
Final simplification84.7%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -4.8e-97)
(* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z)))
(if (<= z 1.15e-133)
(* (* z y) (/ x (sqrt (* a (- t)))))
(/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.8e-97) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 1.15e-133) {
tmp = (z * y) * (x / sqrt((a * -t)));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= (-4.8d-97)) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else if (z <= 1.15d-133) then
tmp = (z * y) * (x / sqrt((a * -t)))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.8e-97) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 1.15e-133) {
tmp = (z * y) * (x / Math.sqrt((a * -t)));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -4.8e-97: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) elif z <= 1.15e-133: tmp = (z * y) * (x / math.sqrt((a * -t))) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.8e-97) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); elseif (z <= 1.15e-133) tmp = Float64(Float64(z * y) * Float64(x / sqrt(Float64(a * Float64(-t))))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -4.8e-97)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
elseif (z <= 1.15e-133)
tmp = (z * y) * (x / sqrt((a * -t)));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.8e-97], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.15e-133], N[(N[(z * y), $MachinePrecision] * N[(x / N[Sqrt[N[(a * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.8 \cdot 10^{-97}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{-133}:\\
\;\;\;\;\left(z \cdot y\right) \cdot \frac{x}{\sqrt{a \cdot \left(-t\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < -4.8e-97Initial program 64.8%
*-commutative64.8%
associate-*l*60.5%
associate-*r/62.6%
Simplified62.6%
associate-/l*67.0%
add-cube-cbrt66.1%
*-un-lft-identity66.1%
times-frac66.1%
pow266.1%
Applied egg-rr66.1%
/-rgt-identity66.1%
associate-*r/66.1%
unpow266.1%
rem-3cbrt-lft67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in z around -inf 84.6%
associate-/l*87.7%
mul-1-neg87.7%
unsub-neg87.7%
associate-/r/87.7%
*-commutative87.7%
Simplified87.7%
if -4.8e-97 < z < 1.15e-133Initial program 61.9%
*-commutative61.9%
associate-*l*66.9%
associate-*r/72.0%
Simplified72.0%
*-commutative72.0%
associate-/l*73.5%
associate-/r/75.0%
associate-/l/75.9%
*-commutative75.9%
Applied egg-rr75.9%
Taylor expanded in z around 0 74.0%
associate-*r*74.0%
neg-mul-174.0%
Simplified74.0%
expm1-log1p-u60.6%
expm1-udef39.9%
associate-/r/36.8%
*-commutative36.8%
Applied egg-rr36.8%
expm1-def52.7%
expm1-log1p64.1%
Simplified64.1%
if 1.15e-133 < z Initial program 51.6%
associate-/l*54.5%
Simplified54.5%
Taylor expanded in z around inf 87.1%
unpow287.1%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in z around 0 88.2%
unpow288.2%
associate-*r/88.2%
Simplified88.2%
Final simplification82.8%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(if (<= z -8.8e-100)
(* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z)))
(if (<= z 1.1e-133)
(/ x (/ (sqrt (* a (- t))) (* z y)))
(/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t)))))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.8e-100) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 1.1e-133) {
tmp = x / (sqrt((a * -t)) / (z * y));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= (-8.8d-100)) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else if (z <= 1.1d-133) then
tmp = x / (sqrt((a * -t)) / (z * y))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8.8e-100) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else if (z <= 1.1e-133) {
tmp = x / (Math.sqrt((a * -t)) / (z * y));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -8.8e-100: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) elif z <= 1.1e-133: tmp = x / (math.sqrt((a * -t)) / (z * y)) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -8.8e-100) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); elseif (z <= 1.1e-133) tmp = Float64(x / Float64(sqrt(Float64(a * Float64(-t))) / Float64(z * y))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -8.8e-100)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
elseif (z <= 1.1e-133)
tmp = x / (sqrt((a * -t)) / (z * y));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8.8e-100], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e-133], N[(x / N[(N[Sqrt[N[(a * (-t)), $MachinePrecision]], $MachinePrecision] / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.8 \cdot 10^{-100}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-133}:\\
\;\;\;\;\frac{x}{\frac{\sqrt{a \cdot \left(-t\right)}}{z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < -8.79999999999999957e-100Initial program 65.1%
*-commutative65.1%
associate-*l*60.9%
associate-*r/62.6%
Simplified62.6%
associate-/l*66.9%
add-cube-cbrt66.0%
*-un-lft-identity66.0%
times-frac66.1%
pow266.1%
Applied egg-rr66.1%
/-rgt-identity66.1%
associate-*r/66.0%
unpow266.0%
rem-3cbrt-lft66.9%
*-commutative66.9%
Simplified66.9%
Taylor expanded in z around -inf 83.8%
associate-/l*86.9%
mul-1-neg86.9%
unsub-neg86.9%
associate-/r/86.9%
*-commutative86.9%
Simplified86.9%
if -8.79999999999999957e-100 < z < 1.1e-133Initial program 61.2%
*-commutative61.2%
associate-*l*66.3%
associate-*r/72.3%
Simplified72.3%
*-commutative72.3%
associate-/l*73.8%
associate-/r/74.6%
associate-/l/75.5%
*-commutative75.5%
Applied egg-rr75.5%
Taylor expanded in z around 0 73.5%
associate-*r*73.5%
neg-mul-173.5%
Simplified73.5%
if 1.1e-133 < z Initial program 51.6%
associate-/l*54.5%
Simplified54.5%
Taylor expanded in z around inf 87.1%
unpow287.1%
associate-/l*88.2%
Simplified88.2%
Taylor expanded in z around 0 88.2%
unpow288.2%
associate-*r/88.2%
Simplified88.2%
Final simplification84.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z -3.3e-236) (* x (- y)) (if (<= z 6.9e-217) (* -2.0 (* (/ y a) (/ (* z (* z x)) t))) (* x y))))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.3e-236) {
tmp = x * -y;
} else if (z <= 6.9e-217) {
tmp = -2.0 * ((y / a) * ((z * (z * x)) / t));
} else {
tmp = x * y;
}
return tmp;
}
NOTE: x and y 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 <= (-3.3d-236)) then
tmp = x * -y
else if (z <= 6.9d-217) then
tmp = (-2.0d0) * ((y / a) * ((z * (z * x)) / t))
else
tmp = x * y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.3e-236) {
tmp = x * -y;
} else if (z <= 6.9e-217) {
tmp = -2.0 * ((y / a) * ((z * (z * x)) / t));
} else {
tmp = x * y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -3.3e-236: tmp = x * -y elif z <= 6.9e-217: tmp = -2.0 * ((y / a) * ((z * (z * x)) / t)) else: tmp = x * y return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.3e-236) tmp = Float64(x * Float64(-y)); elseif (z <= 6.9e-217) tmp = Float64(-2.0 * Float64(Float64(y / a) * Float64(Float64(z * Float64(z * x)) / t))); else tmp = Float64(x * y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -3.3e-236)
tmp = x * -y;
elseif (z <= 6.9e-217)
tmp = -2.0 * ((y / a) * ((z * (z * x)) / t));
else
tmp = x * y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.3e-236], N[(x * (-y)), $MachinePrecision], If[LessEqual[z, 6.9e-217], N[(-2.0 * N[(N[(y / a), $MachinePrecision] * N[(N[(z * N[(z * x), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.3 \cdot 10^{-236}:\\
\;\;\;\;x \cdot \left(-y\right)\\
\mathbf{elif}\;z \leq 6.9 \cdot 10^{-217}:\\
\;\;\;\;-2 \cdot \left(\frac{y}{a} \cdot \frac{z \cdot \left(z \cdot x\right)}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if z < -3.3000000000000001e-236Initial program 65.0%
*-commutative65.0%
associate-*l*61.4%
associate-*r/64.4%
Simplified64.4%
Taylor expanded in z around -inf 78.3%
neg-mul-178.3%
Simplified78.3%
if -3.3000000000000001e-236 < z < 6.89999999999999974e-217Initial program 48.4%
associate-/l*49.9%
Simplified49.9%
Taylor expanded in z around inf 34.1%
unpow234.1%
associate-/l*39.4%
Simplified39.4%
Taylor expanded in a around inf 34.7%
times-frac39.4%
unpow239.4%
associate-*l*39.7%
Simplified39.7%
if 6.89999999999999974e-217 < z Initial program 54.8%
*-commutative54.8%
associate-*l*55.3%
associate-*r/57.0%
Simplified57.0%
Taylor expanded in z around inf 79.4%
Final simplification75.7%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z -1.4e-239) (* x (- y)) (* y (/ x (/ (+ z (* (* t (/ a z)) -0.5)) z)))))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.4e-239) {
tmp = x * -y;
} else {
tmp = y * (x / ((z + ((t * (a / z)) * -0.5)) / z));
}
return tmp;
}
NOTE: x and y 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.4d-239)) then
tmp = x * -y
else
tmp = y * (x / ((z + ((t * (a / z)) * (-0.5d0))) / z))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.4e-239) {
tmp = x * -y;
} else {
tmp = y * (x / ((z + ((t * (a / z)) * -0.5)) / z));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -1.4e-239: tmp = x * -y else: tmp = y * (x / ((z + ((t * (a / z)) * -0.5)) / z)) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.4e-239) tmp = Float64(x * Float64(-y)); else tmp = Float64(y * Float64(x / Float64(Float64(z + Float64(Float64(t * Float64(a / z)) * -0.5)) / z))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -1.4e-239)
tmp = x * -y;
else
tmp = y * (x / ((z + ((t * (a / z)) * -0.5)) / z));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.4e-239], N[(x * (-y)), $MachinePrecision], N[(y * N[(x / N[(N[(z + N[(N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.4 \cdot 10^{-239}:\\
\;\;\;\;x \cdot \left(-y\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{x}{\frac{z + \left(t \cdot \frac{a}{z}\right) \cdot -0.5}{z}}\\
\end{array}
\end{array}
if z < -1.40000000000000006e-239Initial program 65.0%
*-commutative65.0%
associate-*l*61.4%
associate-*r/64.4%
Simplified64.4%
Taylor expanded in z around -inf 78.3%
neg-mul-178.3%
Simplified78.3%
if -1.40000000000000006e-239 < z Initial program 53.9%
*-commutative53.9%
associate-*l*56.2%
associate-*r/58.1%
Simplified58.1%
associate-/l*59.6%
add-cube-cbrt59.0%
*-un-lft-identity59.0%
times-frac59.0%
pow259.0%
Applied egg-rr59.0%
/-rgt-identity59.0%
associate-*r/59.0%
unpow259.0%
rem-3cbrt-lft59.6%
*-commutative59.6%
Simplified59.6%
Taylor expanded in z around inf 74.2%
associate-*l/74.9%
*-commutative74.9%
Simplified74.9%
Final simplification76.4%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* t (/ a z))))
(if (<= z 2e-297)
(* y (/ x (/ (- (* 0.5 t_1) z) z)))
(* y (/ x (/ (+ z (* t_1 -0.5)) z))))))assert(x < y);
double code(double x, double y, double z, double t, double a) {
double t_1 = t * (a / z);
double tmp;
if (z <= 2e-297) {
tmp = y * (x / (((0.5 * t_1) - z) / z));
} else {
tmp = y * (x / ((z + (t_1 * -0.5)) / z));
}
return tmp;
}
NOTE: x and y 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 = t * (a / z)
if (z <= 2d-297) then
tmp = y * (x / (((0.5d0 * t_1) - z) / z))
else
tmp = y * (x / ((z + (t_1 * (-0.5d0))) / z))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t * (a / z);
double tmp;
if (z <= 2e-297) {
tmp = y * (x / (((0.5 * t_1) - z) / z));
} else {
tmp = y * (x / ((z + (t_1 * -0.5)) / z));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): t_1 = t * (a / z) tmp = 0 if z <= 2e-297: tmp = y * (x / (((0.5 * t_1) - z) / z)) else: tmp = y * (x / ((z + (t_1 * -0.5)) / z)) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) t_1 = Float64(t * Float64(a / z)) tmp = 0.0 if (z <= 2e-297) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * t_1) - z) / z))); else tmp = Float64(y * Float64(x / Float64(Float64(z + Float64(t_1 * -0.5)) / z))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
t_1 = t * (a / z);
tmp = 0.0;
if (z <= 2e-297)
tmp = y * (x / (((0.5 * t_1) - z) / z));
else
tmp = y * (x / ((z + (t_1 * -0.5)) / z));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, 2e-297], N[(y * N[(x / N[(N[(N[(0.5 * t$95$1), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x / N[(N[(z + N[(t$95$1 * -0.5), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_1 := t \cdot \frac{a}{z}\\
\mathbf{if}\;z \leq 2 \cdot 10^{-297}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot t_1 - z}{z}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{x}{\frac{z + t_1 \cdot -0.5}{z}}\\
\end{array}
\end{array}
if z < 2.00000000000000008e-297Initial program 64.2%
*-commutative64.2%
associate-*l*62.4%
associate-*r/64.9%
Simplified64.9%
associate-/l*68.4%
add-cube-cbrt67.6%
*-un-lft-identity67.6%
times-frac67.6%
pow267.6%
Applied egg-rr67.6%
/-rgt-identity67.6%
associate-*r/67.6%
unpow267.6%
rem-3cbrt-lft68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in z around -inf 74.0%
associate-/l*76.7%
mul-1-neg76.7%
unsub-neg76.7%
associate-/r/76.7%
*-commutative76.7%
Simplified76.7%
if 2.00000000000000008e-297 < z Initial program 53.7%
*-commutative53.7%
associate-*l*54.9%
associate-*r/57.1%
Simplified57.1%
associate-/l*58.7%
add-cube-cbrt58.1%
*-un-lft-identity58.1%
times-frac58.1%
pow258.1%
Applied egg-rr58.1%
/-rgt-identity58.1%
associate-*r/58.1%
unpow258.1%
rem-3cbrt-lft58.7%
*-commutative58.7%
Simplified58.7%
Taylor expanded in z around inf 76.9%
associate-*l/77.7%
*-commutative77.7%
Simplified77.7%
Final simplification77.2%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z 7e-284) (* y (/ x (/ (- (* 0.5 (* t (/ a z))) z) z))) (/ (* x y) (+ 1.0 (* -0.5 (/ a (* z (/ z t))))))))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= 7e-284) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
NOTE: x and y 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 <= 7d-284) then
tmp = y * (x / (((0.5d0 * (t * (a / z))) - z) / z))
else
tmp = (x * y) / (1.0d0 + ((-0.5d0) * (a / (z * (z / t)))))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= 7e-284) {
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
} else {
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= 7e-284: tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z)) else: tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t))))) return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= 7e-284) tmp = Float64(y * Float64(x / Float64(Float64(Float64(0.5 * Float64(t * Float64(a / z))) - z) / z))); else tmp = Float64(Float64(x * y) / Float64(1.0 + Float64(-0.5 * Float64(a / Float64(z * Float64(z / t)))))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= 7e-284)
tmp = y * (x / (((0.5 * (t * (a / z))) - z) / z));
else
tmp = (x * y) / (1.0 + (-0.5 * (a / (z * (z / t)))));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, 7e-284], N[(y * N[(x / N[(N[(N[(0.5 * N[(t * N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] / N[(1.0 + N[(-0.5 * N[(a / N[(z * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 7 \cdot 10^{-284}:\\
\;\;\;\;y \cdot \frac{x}{\frac{0.5 \cdot \left(t \cdot \frac{a}{z}\right) - z}{z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot y}{1 + -0.5 \cdot \frac{a}{z \cdot \frac{z}{t}}}\\
\end{array}
\end{array}
if z < 6.99999999999999951e-284Initial program 63.7%
*-commutative63.7%
associate-*l*62.7%
associate-*r/65.2%
Simplified65.2%
associate-/l*68.6%
add-cube-cbrt67.8%
*-un-lft-identity67.8%
times-frac67.9%
pow267.9%
Applied egg-rr67.9%
/-rgt-identity67.9%
associate-*r/67.8%
unpow267.8%
rem-3cbrt-lft68.6%
*-commutative68.6%
Simplified68.6%
Taylor expanded in z around -inf 73.4%
associate-/l*76.1%
mul-1-neg76.1%
unsub-neg76.1%
associate-/r/76.1%
*-commutative76.1%
Simplified76.1%
if 6.99999999999999951e-284 < z Initial program 54.1%
associate-/l*57.6%
Simplified57.6%
Taylor expanded in z around inf 74.8%
unpow274.8%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in z around 0 76.5%
unpow276.5%
associate-*r/78.8%
Simplified78.8%
Final simplification77.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z -1.45e-241) (* x (- y)) (if (<= z 6.6e-193) (* y (/ (* z x) z)) (* x y))))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.45e-241) {
tmp = x * -y;
} else if (z <= 6.6e-193) {
tmp = y * ((z * x) / z);
} else {
tmp = x * y;
}
return tmp;
}
NOTE: x and y 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.45d-241)) then
tmp = x * -y
else if (z <= 6.6d-193) then
tmp = y * ((z * x) / z)
else
tmp = x * y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.45e-241) {
tmp = x * -y;
} else if (z <= 6.6e-193) {
tmp = y * ((z * x) / z);
} else {
tmp = x * y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -1.45e-241: tmp = x * -y elif z <= 6.6e-193: tmp = y * ((z * x) / z) else: tmp = x * y return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.45e-241) tmp = Float64(x * Float64(-y)); elseif (z <= 6.6e-193) tmp = Float64(y * Float64(Float64(z * x) / z)); else tmp = Float64(x * y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -1.45e-241)
tmp = x * -y;
elseif (z <= 6.6e-193)
tmp = y * ((z * x) / z);
else
tmp = x * y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.45e-241], N[(x * (-y)), $MachinePrecision], If[LessEqual[z, 6.6e-193], N[(y * N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(x * y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.45 \cdot 10^{-241}:\\
\;\;\;\;x \cdot \left(-y\right)\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{-193}:\\
\;\;\;\;y \cdot \frac{z \cdot x}{z}\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if z < -1.45e-241Initial program 65.0%
*-commutative65.0%
associate-*l*61.4%
associate-*r/64.4%
Simplified64.4%
Taylor expanded in z around -inf 78.3%
neg-mul-178.3%
Simplified78.3%
if -1.45e-241 < z < 6.5999999999999998e-193Initial program 49.5%
*-commutative49.5%
associate-*l*59.8%
associate-*r/65.4%
Simplified65.4%
Taylor expanded in z around inf 33.9%
if 6.5999999999999998e-193 < z Initial program 54.9%
*-commutative54.9%
associate-*l*55.4%
associate-*r/56.4%
Simplified56.4%
Taylor expanded in z around inf 82.3%
Final simplification75.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (if (<= z -5e-310) (* x (- y)) (* x y)))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5e-310) {
tmp = x * -y;
} else {
tmp = x * y;
}
return tmp;
}
NOTE: x and y 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 <= (-5d-310)) then
tmp = x * -y
else
tmp = x * y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -5e-310) {
tmp = x * -y;
} else {
tmp = x * y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): tmp = 0 if z <= -5e-310: tmp = x * -y else: tmp = x * y return tmp
x, y = sort([x, y]) function code(x, y, z, t, a) tmp = 0.0 if (z <= -5e-310) tmp = Float64(x * Float64(-y)); else tmp = Float64(x * y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z, t, a)
tmp = 0.0;
if (z <= -5e-310)
tmp = x * -y;
else
tmp = x * y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5e-310], N[(x * (-y)), $MachinePrecision], N[(x * y), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5 \cdot 10^{-310}:\\
\;\;\;\;x \cdot \left(-y\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if z < -4.999999999999985e-310Initial program 63.7%
*-commutative63.7%
associate-*l*61.9%
associate-*r/64.0%
Simplified64.0%
Taylor expanded in z around -inf 75.2%
neg-mul-175.2%
Simplified75.2%
if -4.999999999999985e-310 < z Initial program 54.3%
*-commutative54.3%
associate-*l*55.5%
associate-*r/58.1%
Simplified58.1%
Taylor expanded in z around inf 73.2%
Final simplification74.1%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z t a) :precision binary64 (* x y))
assert(x < y);
double code(double x, double y, double z, double t, double a) {
return x * y;
}
NOTE: x and y 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 = x * y
end function
assert x < y;
public static double code(double x, double y, double z, double t, double a) {
return x * y;
}
[x, y] = sort([x, y]) def code(x, y, z, t, a): return x * y
x, y = sort([x, y]) function code(x, y, z, t, a) return Float64(x * y) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z, t, a)
tmp = x * y;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_] := N[(x * y), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
x \cdot y
\end{array}
Initial program 58.7%
*-commutative58.7%
associate-*l*58.5%
associate-*r/60.8%
Simplified60.8%
Taylor expanded in z around inf 45.5%
Final simplification45.5%
(FPCore (x y z t a)
:precision binary64
(if (< z -3.1921305903852764e+46)
(- (* y x))
(if (< z 5.976268120920894e+90)
(/ (* x z) (/ (sqrt (- (* z z) (* a t))) y))
(* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
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 (z < (-3.1921305903852764d+46)) then
tmp = -(y * x)
else if (z < 5.976268120920894d+90) then
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y)
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (Math.sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z < -3.1921305903852764e+46: tmp = -(y * x) elif z < 5.976268120920894e+90: tmp = (x * z) / (math.sqrt(((z * z) - (a * t))) / y) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z < -3.1921305903852764e+46) tmp = Float64(-Float64(y * x)); elseif (z < 5.976268120920894e+90) tmp = Float64(Float64(x * z) / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / y)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z < -3.1921305903852764e+46) tmp = -(y * x); elseif (z < 5.976268120920894e+90) tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Less[z, -3.1921305903852764e+46], (-N[(y * x), $MachinePrecision]), If[Less[z, 5.976268120920894e+90], N[(N[(x * z), $MachinePrecision] / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z < -3.1921305903852764 \cdot 10^{+46}:\\
\;\;\;\;-y \cdot x\\
\mathbf{elif}\;z < 5.976268120920894 \cdot 10^{+90}:\\
\;\;\;\;\frac{x \cdot z}{\frac{\sqrt{z \cdot z - a \cdot t}}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
herbie shell --seed 2023192
(FPCore (x y z t a)
:name "Statistics.Math.RootFinding:ridders from math-functions-0.1.5.2"
:precision binary64
:herbie-target
(if (< z -3.1921305903852764e+46) (- (* y x)) (if (< z 5.976268120920894e+90) (/ (* x z) (/ (sqrt (- (* z z) (* a t))) y)) (* y x)))
(/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))