
(FPCore (x y z) :precision binary64 (/ (/ 1.0 x) (* y (+ 1.0 (* z z)))))
double code(double x, double y, double z) {
return (1.0 / x) / (y * (1.0 + (z * z)));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (1.0d0 / x) / (y * (1.0d0 + (z * z)))
end function
public static double code(double x, double y, double z) {
return (1.0 / x) / (y * (1.0 + (z * z)));
}
def code(x, y, z): return (1.0 / x) / (y * (1.0 + (z * z)))
function code(x, y, z) return Float64(Float64(1.0 / x) / Float64(y * Float64(1.0 + Float64(z * z)))) end
function tmp = code(x, y, z) tmp = (1.0 / x) / (y * (1.0 + (z * z))); end
code[x_, y_, z_] := N[(N[(1.0 / x), $MachinePrecision] / N[(y * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{1}{x}}{y \cdot \left(1 + z \cdot z\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (/ 1.0 x) (* y (+ 1.0 (* z z)))))
double code(double x, double y, double z) {
return (1.0 / x) / (y * (1.0 + (z * z)));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (1.0d0 / x) / (y * (1.0d0 + (z * z)))
end function
public static double code(double x, double y, double z) {
return (1.0 / x) / (y * (1.0 + (z * z)));
}
def code(x, y, z): return (1.0 / x) / (y * (1.0 + (z * z)))
function code(x, y, z) return Float64(Float64(1.0 / x) / Float64(y * Float64(1.0 + Float64(z * z)))) end
function tmp = code(x, y, z) tmp = (1.0 / x) / (y * (1.0 + (z * z))); end
code[x_, y_, z_] := N[(N[(1.0 / x), $MachinePrecision] / N[(y * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{1}{x}}{y \cdot \left(1 + z \cdot z\right)}
\end{array}
x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
(FPCore (y_s x_s x_m y_m z)
:precision binary64
(*
y_s
(*
x_s
(if (<= (* y_m (+ 1.0 (* z z))) 2e+307)
(/ (/ 1.0 x_m) (fma (* y_m z) z y_m))
(* (/ 1.0 z) (/ (/ (/ 1.0 z) x_m) y_m))))))x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
double tmp;
if ((y_m * (1.0 + (z * z))) <= 2e+307) {
tmp = (1.0 / x_m) / fma((y_m * z), z, y_m);
} else {
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
}
return y_s * (x_s * tmp);
}
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) tmp = 0.0 if (Float64(y_m * Float64(1.0 + Float64(z * z))) <= 2e+307) tmp = Float64(Float64(1.0 / x_m) / fma(Float64(y_m * z), z, y_m)); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / x_m) / y_m)); end return Float64(y_s * Float64(x_s * tmp)) end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * If[LessEqual[N[(y$95$m * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e+307], N[(N[(1.0 / x$95$m), $MachinePrecision] / N[(N[(y$95$m * z), $MachinePrecision] * z + y$95$m), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \begin{array}{l}
\mathbf{if}\;y_m \cdot \left(1 + z \cdot z\right) \leq 2 \cdot 10^{+307}:\\
\;\;\;\;\frac{\frac{1}{x_m}}{\mathsf{fma}\left(y_m \cdot z, z, y_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{x_m}}{y_m}\\
\end{array}\right)
\end{array}
if (*.f64 y (+.f64 1 (*.f64 z z))) < 1.99999999999999997e307Initial program 95.8%
+-commutative95.8%
distribute-lft-in95.8%
associate-*r*98.4%
*-rgt-identity98.4%
fma-def98.4%
Applied egg-rr98.4%
if 1.99999999999999997e307 < (*.f64 y (+.f64 1 (*.f64 z z))) Initial program 60.5%
associate-/l/60.6%
metadata-eval60.6%
associate-*r/60.6%
associate-/l/60.5%
associate-*r/60.5%
associate-/l*60.5%
associate-/r/60.6%
/-rgt-identity60.6%
associate-*l*72.4%
*-commutative72.4%
sqr-neg72.4%
+-commutative72.4%
sqr-neg72.4%
fma-def72.4%
Simplified72.4%
fma-udef72.4%
+-commutative72.4%
*-commutative72.4%
associate-*l*60.6%
associate-/l/60.5%
add-sqr-sqrt60.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
sqrt-prod16.5%
hypot-1-def16.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
Applied egg-rr38.1%
unpow238.1%
*-commutative38.1%
associate-/r*38.2%
Simplified38.2%
Taylor expanded in z around inf 60.6%
associate-*r*72.0%
associate-/r*72.1%
associate-/l/72.1%
unpow272.1%
associate-/r*87.5%
associate-/l/87.6%
unpow-187.6%
metadata-eval87.6%
pow-sqr46.2%
associate-*r/46.2%
associate-*l/46.3%
*-rgt-identity46.3%
associate-*r/46.2%
*-rgt-identity46.2%
associate-*r/46.1%
unswap-sqr38.9%
pow-sqr73.5%
metadata-eval73.5%
unpow-173.5%
unpow-173.5%
unpow-173.5%
pow-sqr73.5%
metadata-eval73.5%
Simplified73.5%
div-inv73.5%
add-sqr-sqrt73.5%
associate-/r*73.5%
associate-*l*73.4%
sqrt-pow169.8%
metadata-eval69.8%
unpow-169.8%
sqrt-pow187.4%
metadata-eval87.4%
unpow-187.4%
associate-/l/87.5%
Applied egg-rr87.5%
un-div-inv87.4%
*-commutative87.4%
associate-/r*94.8%
Applied egg-rr94.8%
Final simplification97.9%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (pow (/ (/ (pow x_m -0.5) (sqrt y_m)) (hypot 1.0 z)) 2.0))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * pow(((pow(x_m, -0.5) / sqrt(y_m)) / hypot(1.0, z)), 2.0));
}
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * Math.pow(((Math.pow(x_m, -0.5) / Math.sqrt(y_m)) / Math.hypot(1.0, z)), 2.0));
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): return y_s * (x_s * math.pow(((math.pow(x_m, -0.5) / math.sqrt(y_m)) / math.hypot(1.0, z)), 2.0))
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) return Float64(y_s * Float64(x_s * (Float64(Float64((x_m ^ -0.5) / sqrt(y_m)) / hypot(1.0, z)) ^ 2.0))) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp = code(y_s, x_s, x_m, y_m, z)
tmp = y_s * (x_s * ((((x_m ^ -0.5) / sqrt(y_m)) / hypot(1.0, z)) ^ 2.0));
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * N[Power[N[(N[(N[Power[x$95$m, -0.5], $MachinePrecision] / N[Sqrt[y$95$m], $MachinePrecision]), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + z ^ 2], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot {\left(\frac{\frac{{x_m}^{-0.5}}{\sqrt{y_m}}}{\mathsf{hypot}\left(1, z\right)}\right)}^{2}\right)
\end{array}
Initial program 90.5%
associate-/l/90.2%
metadata-eval90.2%
associate-*r/90.2%
associate-/l/90.5%
associate-*r/90.5%
associate-/l*90.1%
associate-/r/90.2%
/-rgt-identity90.2%
associate-*l*90.1%
*-commutative90.1%
sqr-neg90.1%
+-commutative90.1%
sqr-neg90.1%
fma-def90.1%
Simplified90.1%
fma-udef90.1%
+-commutative90.1%
*-commutative90.1%
associate-*l*90.2%
associate-/l/90.5%
add-sqr-sqrt60.8%
sqrt-div18.8%
inv-pow18.8%
sqrt-pow118.8%
metadata-eval18.8%
*-commutative18.8%
sqrt-prod18.8%
hypot-1-def18.8%
sqrt-div18.8%
inv-pow18.8%
sqrt-pow118.8%
metadata-eval18.8%
*-commutative18.8%
Applied egg-rr22.1%
unpow222.1%
*-commutative22.1%
associate-/r*22.1%
Simplified22.1%
Final simplification22.1%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (/ 1.0 (* y_m (pow (* (hypot 1.0 z) (sqrt x_m)) 2.0))))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * (1.0 / (y_m * pow((hypot(1.0, z) * sqrt(x_m)), 2.0))));
}
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * (1.0 / (y_m * Math.pow((Math.hypot(1.0, z) * Math.sqrt(x_m)), 2.0))));
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): return y_s * (x_s * (1.0 / (y_m * math.pow((math.hypot(1.0, z) * math.sqrt(x_m)), 2.0))))
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) return Float64(y_s * Float64(x_s * Float64(1.0 / Float64(y_m * (Float64(hypot(1.0, z) * sqrt(x_m)) ^ 2.0))))) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp = code(y_s, x_s, x_m, y_m, z)
tmp = y_s * (x_s * (1.0 / (y_m * ((hypot(1.0, z) * sqrt(x_m)) ^ 2.0))));
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * N[(1.0 / N[(y$95$m * N[Power[N[(N[Sqrt[1.0 ^ 2 + z ^ 2], $MachinePrecision] * N[Sqrt[x$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \frac{1}{y_m \cdot {\left(\mathsf{hypot}\left(1, z\right) \cdot \sqrt{x_m}\right)}^{2}}\right)
\end{array}
Initial program 90.5%
associate-/l/90.2%
metadata-eval90.2%
associate-*r/90.2%
associate-/l/90.5%
associate-*r/90.5%
associate-/l*90.1%
associate-/r/90.2%
/-rgt-identity90.2%
associate-*l*90.1%
*-commutative90.1%
sqr-neg90.1%
+-commutative90.1%
sqr-neg90.1%
fma-def90.1%
Simplified90.1%
add-sqr-sqrt42.0%
pow242.0%
fma-udef42.0%
+-commutative42.0%
*-commutative42.0%
sqrt-prod42.0%
hypot-1-def43.5%
Applied egg-rr43.5%
Final simplification43.5%
x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
(FPCore (y_s x_s x_m y_m z)
:precision binary64
(let* ((t_0 (* y_m (+ 1.0 (* z z)))))
(*
y_s
(*
x_s
(if (<= t_0 2e+307)
(/ 1.0 (* x_m t_0))
(* (/ 1.0 z) (/ (/ (/ 1.0 z) x_m) y_m)))))))x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
double t_0 = y_m * (1.0 + (z * z));
double tmp;
if (t_0 <= 2e+307) {
tmp = 1.0 / (x_m * t_0);
} else {
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
}
return y_s * (x_s * tmp);
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = y_m * (1.0d0 + (z * z))
if (t_0 <= 2d+307) then
tmp = 1.0d0 / (x_m * t_0)
else
tmp = (1.0d0 / z) * (((1.0d0 / z) / x_m) / y_m)
end if
code = y_s * (x_s * tmp)
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
double t_0 = y_m * (1.0 + (z * z));
double tmp;
if (t_0 <= 2e+307) {
tmp = 1.0 / (x_m * t_0);
} else {
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
}
return y_s * (x_s * tmp);
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): t_0 = y_m * (1.0 + (z * z)) tmp = 0 if t_0 <= 2e+307: tmp = 1.0 / (x_m * t_0) else: tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m) return y_s * (x_s * tmp)
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) t_0 = Float64(y_m * Float64(1.0 + Float64(z * z))) tmp = 0.0 if (t_0 <= 2e+307) tmp = Float64(1.0 / Float64(x_m * t_0)); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / x_m) / y_m)); end return Float64(y_s * Float64(x_s * tmp)) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp_2 = code(y_s, x_s, x_m, y_m, z)
t_0 = y_m * (1.0 + (z * z));
tmp = 0.0;
if (t_0 <= 2e+307)
tmp = 1.0 / (x_m * t_0);
else
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
end
tmp_2 = y_s * (x_s * tmp);
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := Block[{t$95$0 = N[(y$95$m * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(y$95$s * N[(x$95$s * If[LessEqual[t$95$0, 2e+307], N[(1.0 / N[(x$95$m * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
\begin{array}{l}
t_0 := y_m \cdot \left(1 + z \cdot z\right)\\
y_s \cdot \left(x_s \cdot \begin{array}{l}
\mathbf{if}\;t_0 \leq 2 \cdot 10^{+307}:\\
\;\;\;\;\frac{1}{x_m \cdot t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{x_m}}{y_m}\\
\end{array}\right)
\end{array}
\end{array}
if (*.f64 y (+.f64 1 (*.f64 z z))) < 1.99999999999999997e307Initial program 95.8%
associate-/l/95.5%
Simplified95.5%
if 1.99999999999999997e307 < (*.f64 y (+.f64 1 (*.f64 z z))) Initial program 60.5%
associate-/l/60.6%
metadata-eval60.6%
associate-*r/60.6%
associate-/l/60.5%
associate-*r/60.5%
associate-/l*60.5%
associate-/r/60.6%
/-rgt-identity60.6%
associate-*l*72.4%
*-commutative72.4%
sqr-neg72.4%
+-commutative72.4%
sqr-neg72.4%
fma-def72.4%
Simplified72.4%
fma-udef72.4%
+-commutative72.4%
*-commutative72.4%
associate-*l*60.6%
associate-/l/60.5%
add-sqr-sqrt60.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
sqrt-prod16.5%
hypot-1-def16.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
Applied egg-rr38.1%
unpow238.1%
*-commutative38.1%
associate-/r*38.2%
Simplified38.2%
Taylor expanded in z around inf 60.6%
associate-*r*72.0%
associate-/r*72.1%
associate-/l/72.1%
unpow272.1%
associate-/r*87.5%
associate-/l/87.6%
unpow-187.6%
metadata-eval87.6%
pow-sqr46.2%
associate-*r/46.2%
associate-*l/46.3%
*-rgt-identity46.3%
associate-*r/46.2%
*-rgt-identity46.2%
associate-*r/46.1%
unswap-sqr38.9%
pow-sqr73.5%
metadata-eval73.5%
unpow-173.5%
unpow-173.5%
unpow-173.5%
pow-sqr73.5%
metadata-eval73.5%
Simplified73.5%
div-inv73.5%
add-sqr-sqrt73.5%
associate-/r*73.5%
associate-*l*73.4%
sqrt-pow169.8%
metadata-eval69.8%
unpow-169.8%
sqrt-pow187.4%
metadata-eval87.4%
unpow-187.4%
associate-/l/87.5%
Applied egg-rr87.5%
un-div-inv87.4%
*-commutative87.4%
associate-/r*94.8%
Applied egg-rr94.8%
Final simplification95.4%
x_m = (fabs.f64 x)
x_s = (copysign.f64 1 x)
y_m = (fabs.f64 y)
y_s = (copysign.f64 1 y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
(FPCore (y_s x_s x_m y_m z)
:precision binary64
(let* ((t_0 (* y_m (+ 1.0 (* z z)))))
(*
y_s
(*
x_s
(if (<= t_0 2e+307)
(/ (/ 1.0 x_m) t_0)
(* (/ 1.0 z) (/ (/ (/ 1.0 z) x_m) y_m)))))))x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
double t_0 = y_m * (1.0 + (z * z));
double tmp;
if (t_0 <= 2e+307) {
tmp = (1.0 / x_m) / t_0;
} else {
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
}
return y_s * (x_s * tmp);
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = y_m * (1.0d0 + (z * z))
if (t_0 <= 2d+307) then
tmp = (1.0d0 / x_m) / t_0
else
tmp = (1.0d0 / z) * (((1.0d0 / z) / x_m) / y_m)
end if
code = y_s * (x_s * tmp)
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
double t_0 = y_m * (1.0 + (z * z));
double tmp;
if (t_0 <= 2e+307) {
tmp = (1.0 / x_m) / t_0;
} else {
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
}
return y_s * (x_s * tmp);
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): t_0 = y_m * (1.0 + (z * z)) tmp = 0 if t_0 <= 2e+307: tmp = (1.0 / x_m) / t_0 else: tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m) return y_s * (x_s * tmp)
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) t_0 = Float64(y_m * Float64(1.0 + Float64(z * z))) tmp = 0.0 if (t_0 <= 2e+307) tmp = Float64(Float64(1.0 / x_m) / t_0); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / x_m) / y_m)); end return Float64(y_s * Float64(x_s * tmp)) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp_2 = code(y_s, x_s, x_m, y_m, z)
t_0 = y_m * (1.0 + (z * z));
tmp = 0.0;
if (t_0 <= 2e+307)
tmp = (1.0 / x_m) / t_0;
else
tmp = (1.0 / z) * (((1.0 / z) / x_m) / y_m);
end
tmp_2 = y_s * (x_s * tmp);
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := Block[{t$95$0 = N[(y$95$m * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(y$95$s * N[(x$95$s * If[LessEqual[t$95$0, 2e+307], N[(N[(1.0 / x$95$m), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
\begin{array}{l}
t_0 := y_m \cdot \left(1 + z \cdot z\right)\\
y_s \cdot \left(x_s \cdot \begin{array}{l}
\mathbf{if}\;t_0 \leq 2 \cdot 10^{+307}:\\
\;\;\;\;\frac{\frac{1}{x_m}}{t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{x_m}}{y_m}\\
\end{array}\right)
\end{array}
\end{array}
if (*.f64 y (+.f64 1 (*.f64 z z))) < 1.99999999999999997e307Initial program 95.8%
if 1.99999999999999997e307 < (*.f64 y (+.f64 1 (*.f64 z z))) Initial program 60.5%
associate-/l/60.6%
metadata-eval60.6%
associate-*r/60.6%
associate-/l/60.5%
associate-*r/60.5%
associate-/l*60.5%
associate-/r/60.6%
/-rgt-identity60.6%
associate-*l*72.4%
*-commutative72.4%
sqr-neg72.4%
+-commutative72.4%
sqr-neg72.4%
fma-def72.4%
Simplified72.4%
fma-udef72.4%
+-commutative72.4%
*-commutative72.4%
associate-*l*60.6%
associate-/l/60.5%
add-sqr-sqrt60.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
sqrt-prod16.5%
hypot-1-def16.5%
sqrt-div16.5%
inv-pow16.5%
sqrt-pow116.5%
metadata-eval16.5%
*-commutative16.5%
Applied egg-rr38.1%
unpow238.1%
*-commutative38.1%
associate-/r*38.2%
Simplified38.2%
Taylor expanded in z around inf 60.6%
associate-*r*72.0%
associate-/r*72.1%
associate-/l/72.1%
unpow272.1%
associate-/r*87.5%
associate-/l/87.6%
unpow-187.6%
metadata-eval87.6%
pow-sqr46.2%
associate-*r/46.2%
associate-*l/46.3%
*-rgt-identity46.3%
associate-*r/46.2%
*-rgt-identity46.2%
associate-*r/46.1%
unswap-sqr38.9%
pow-sqr73.5%
metadata-eval73.5%
unpow-173.5%
unpow-173.5%
unpow-173.5%
pow-sqr73.5%
metadata-eval73.5%
Simplified73.5%
div-inv73.5%
add-sqr-sqrt73.5%
associate-/r*73.5%
associate-*l*73.4%
sqrt-pow169.8%
metadata-eval69.8%
unpow-169.8%
sqrt-pow187.4%
metadata-eval87.4%
unpow-187.4%
associate-/l/87.5%
Applied egg-rr87.5%
un-div-inv87.4%
*-commutative87.4%
associate-/r*94.8%
Applied egg-rr94.8%
Final simplification95.7%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (if (<= z 1.0) (/ (/ 1.0 x_m) y_m) (/ 1.0 (* z (* z (* x_m y_m))))))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / x_m) / y_m;
} else {
tmp = 1.0 / (z * (z * (x_m * y_m)));
}
return y_s * (x_s * tmp);
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 1.0d0) then
tmp = (1.0d0 / x_m) / y_m
else
tmp = 1.0d0 / (z * (z * (x_m * y_m)))
end if
code = y_s * (x_s * tmp)
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / x_m) / y_m;
} else {
tmp = 1.0 / (z * (z * (x_m * y_m)));
}
return y_s * (x_s * tmp);
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): tmp = 0 if z <= 1.0: tmp = (1.0 / x_m) / y_m else: tmp = 1.0 / (z * (z * (x_m * y_m))) return y_s * (x_s * tmp)
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) tmp = 0.0 if (z <= 1.0) tmp = Float64(Float64(1.0 / x_m) / y_m); else tmp = Float64(1.0 / Float64(z * Float64(z * Float64(x_m * y_m)))); end return Float64(y_s * Float64(x_s * tmp)) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp_2 = code(y_s, x_s, x_m, y_m, z)
tmp = 0.0;
if (z <= 1.0)
tmp = (1.0 / x_m) / y_m;
else
tmp = 1.0 / (z * (z * (x_m * y_m)));
end
tmp_2 = y_s * (x_s * tmp);
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * If[LessEqual[z, 1.0], N[(N[(1.0 / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(x$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \begin{array}{l}
\mathbf{if}\;z \leq 1:\\
\;\;\;\;\frac{\frac{1}{x_m}}{y_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z \cdot \left(z \cdot \left(x_m \cdot y_m\right)\right)}\\
\end{array}\right)
\end{array}
if z < 1Initial program 96.2%
Taylor expanded in z around 0 74.1%
if 1 < z Initial program 75.2%
associate-/l/75.2%
metadata-eval75.2%
associate-*r/75.2%
associate-/l/75.2%
associate-*r/75.2%
associate-/l*75.2%
associate-/r/75.2%
/-rgt-identity75.2%
associate-*l*81.9%
*-commutative81.9%
sqr-neg81.9%
+-commutative81.9%
sqr-neg81.9%
fma-def81.9%
Simplified81.9%
Taylor expanded in z around inf 74.9%
associate-/r*74.9%
associate-/r*78.7%
associate-/l/78.7%
associate-/r*78.6%
Simplified78.6%
*-un-lft-identity78.6%
unpow278.6%
times-frac88.4%
Applied egg-rr88.4%
*-commutative88.4%
associate-/r*88.5%
*-un-lft-identity88.5%
associate-*l/88.4%
frac-times88.4%
metadata-eval88.4%
frac-times88.1%
metadata-eval88.1%
*-commutative88.1%
Applied egg-rr88.1%
Final simplification77.9%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (if (<= z 1.0) (/ (/ 1.0 x_m) y_m) (/ (/ 1.0 y_m) (* z (* x_m z)))))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / x_m) / y_m;
} else {
tmp = (1.0 / y_m) / (z * (x_m * z));
}
return y_s * (x_s * tmp);
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 1.0d0) then
tmp = (1.0d0 / x_m) / y_m
else
tmp = (1.0d0 / y_m) / (z * (x_m * z))
end if
code = y_s * (x_s * tmp)
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / x_m) / y_m;
} else {
tmp = (1.0 / y_m) / (z * (x_m * z));
}
return y_s * (x_s * tmp);
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): tmp = 0 if z <= 1.0: tmp = (1.0 / x_m) / y_m else: tmp = (1.0 / y_m) / (z * (x_m * z)) return y_s * (x_s * tmp)
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) tmp = 0.0 if (z <= 1.0) tmp = Float64(Float64(1.0 / x_m) / y_m); else tmp = Float64(Float64(1.0 / y_m) / Float64(z * Float64(x_m * z))); end return Float64(y_s * Float64(x_s * tmp)) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp_2 = code(y_s, x_s, x_m, y_m, z)
tmp = 0.0;
if (z <= 1.0)
tmp = (1.0 / x_m) / y_m;
else
tmp = (1.0 / y_m) / (z * (x_m * z));
end
tmp_2 = y_s * (x_s * tmp);
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * If[LessEqual[z, 1.0], N[(N[(1.0 / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision], N[(N[(1.0 / y$95$m), $MachinePrecision] / N[(z * N[(x$95$m * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \begin{array}{l}
\mathbf{if}\;z \leq 1:\\
\;\;\;\;\frac{\frac{1}{x_m}}{y_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{y_m}}{z \cdot \left(x_m \cdot z\right)}\\
\end{array}\right)
\end{array}
if z < 1Initial program 96.2%
Taylor expanded in z around 0 74.1%
if 1 < z Initial program 75.2%
associate-/l/75.2%
metadata-eval75.2%
associate-*r/75.2%
associate-/l/75.2%
associate-*r/75.2%
associate-/l*75.2%
associate-/r/75.2%
/-rgt-identity75.2%
associate-*l*81.9%
*-commutative81.9%
sqr-neg81.9%
+-commutative81.9%
sqr-neg81.9%
fma-def81.9%
Simplified81.9%
Taylor expanded in z around inf 74.9%
associate-/r*74.9%
associate-/r*78.7%
associate-/l/78.7%
associate-/r*78.6%
Simplified78.6%
*-un-lft-identity78.6%
unpow278.6%
times-frac88.4%
Applied egg-rr88.4%
*-commutative88.4%
associate-/l/92.8%
frac-times91.1%
associate-/r/91.1%
clear-num91.1%
Applied egg-rr91.1%
Final simplification78.7%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (/ 1.0 (* x_m y_m)))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * (1.0 / (x_m * y_m)));
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
code = y_s * (x_s * (1.0d0 / (x_m * y_m)))
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * (1.0 / (x_m * y_m)));
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): return y_s * (x_s * (1.0 / (x_m * y_m)))
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) return Float64(y_s * Float64(x_s * Float64(1.0 / Float64(x_m * y_m)))) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp = code(y_s, x_s, x_m, y_m, z)
tmp = y_s * (x_s * (1.0 / (x_m * y_m)));
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * N[(1.0 / N[(x$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \frac{1}{x_m \cdot y_m}\right)
\end{array}
Initial program 90.5%
associate-/l/90.2%
metadata-eval90.2%
associate-*r/90.2%
associate-/l/90.5%
associate-*r/90.5%
associate-/l*90.1%
associate-/r/90.2%
/-rgt-identity90.2%
associate-*l*90.1%
*-commutative90.1%
sqr-neg90.1%
+-commutative90.1%
sqr-neg90.1%
fma-def90.1%
Simplified90.1%
Taylor expanded in z around 0 58.8%
Final simplification58.8%
x_m = (fabs.f64 x) x_s = (copysign.f64 1 x) y_m = (fabs.f64 y) y_s = (copysign.f64 1 y) NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function. (FPCore (y_s x_s x_m y_m z) :precision binary64 (* y_s (* x_s (/ (/ 1.0 x_m) y_m))))
x_m = fabs(x);
x_s = copysign(1.0, x);
y_m = fabs(y);
y_s = copysign(1.0, y);
assert(x_m < y_m && y_m < z);
double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * ((1.0 / x_m) / y_m));
}
x_m = abs(x)
x_s = copysign(1.0d0, x)
y_m = abs(y)
y_s = copysign(1.0d0, y)
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
real(8) function code(y_s, x_s, x_m, y_m, z)
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z
code = y_s * (x_s * ((1.0d0 / x_m) / y_m))
end function
x_m = Math.abs(x);
x_s = Math.copySign(1.0, x);
y_m = Math.abs(y);
y_s = Math.copySign(1.0, y);
assert x_m < y_m && y_m < z;
public static double code(double y_s, double x_s, double x_m, double y_m, double z) {
return y_s * (x_s * ((1.0 / x_m) / y_m));
}
x_m = math.fabs(x) x_s = math.copysign(1.0, x) y_m = math.fabs(y) y_s = math.copysign(1.0, y) [x_m, y_m, z] = sort([x_m, y_m, z]) def code(y_s, x_s, x_m, y_m, z): return y_s * (x_s * ((1.0 / x_m) / y_m))
x_m = abs(x) x_s = copysign(1.0, x) y_m = abs(y) y_s = copysign(1.0, y) x_m, y_m, z = sort([x_m, y_m, z]) function code(y_s, x_s, x_m, y_m, z) return Float64(y_s * Float64(x_s * Float64(Float64(1.0 / x_m) / y_m))) end
x_m = abs(x);
x_s = sign(x) * abs(1.0);
y_m = abs(y);
y_s = sign(y) * abs(1.0);
x_m, y_m, z = num2cell(sort([x_m, y_m, z])){:}
function tmp = code(y_s, x_s, x_m, y_m, z)
tmp = y_s * (x_s * ((1.0 / x_m) / y_m));
end
x_m = N[Abs[x], $MachinePrecision]
x_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
y_m = N[Abs[y], $MachinePrecision]
y_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, and z should be sorted in increasing order before calling this function.
code[y$95$s_, x$95$s_, x$95$m_, y$95$m_, z_] := N[(y$95$s * N[(x$95$s * N[(N[(1.0 / x$95$m), $MachinePrecision] / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
x_s = \mathsf{copysign}\left(1, x\right)
\\
y_m = \left|y\right|
\\
y_s = \mathsf{copysign}\left(1, y\right)
\\
[x_m, y_m, z] = \mathsf{sort}([x_m, y_m, z])\\
\\
y_s \cdot \left(x_s \cdot \frac{\frac{1}{x_m}}{y_m}\right)
\end{array}
Initial program 90.5%
Taylor expanded in z around 0 59.1%
Final simplification59.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (+ 1.0 (* z z))) (t_1 (* y t_0)) (t_2 (/ (/ 1.0 y) (* t_0 x))))
(if (< t_1 (- INFINITY))
t_2
(if (< t_1 8.680743250567252e+305) (/ (/ 1.0 x) (* t_0 y)) t_2))))
double code(double x, double y, double z) {
double t_0 = 1.0 + (z * z);
double t_1 = y * t_0;
double t_2 = (1.0 / y) / (t_0 * x);
double tmp;
if (t_1 < -((double) INFINITY)) {
tmp = t_2;
} else if (t_1 < 8.680743250567252e+305) {
tmp = (1.0 / x) / (t_0 * y);
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = 1.0 + (z * z);
double t_1 = y * t_0;
double t_2 = (1.0 / y) / (t_0 * x);
double tmp;
if (t_1 < -Double.POSITIVE_INFINITY) {
tmp = t_2;
} else if (t_1 < 8.680743250567252e+305) {
tmp = (1.0 / x) / (t_0 * y);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z): t_0 = 1.0 + (z * z) t_1 = y * t_0 t_2 = (1.0 / y) / (t_0 * x) tmp = 0 if t_1 < -math.inf: tmp = t_2 elif t_1 < 8.680743250567252e+305: tmp = (1.0 / x) / (t_0 * y) else: tmp = t_2 return tmp
function code(x, y, z) t_0 = Float64(1.0 + Float64(z * z)) t_1 = Float64(y * t_0) t_2 = Float64(Float64(1.0 / y) / Float64(t_0 * x)) tmp = 0.0 if (t_1 < Float64(-Inf)) tmp = t_2; elseif (t_1 < 8.680743250567252e+305) tmp = Float64(Float64(1.0 / x) / Float64(t_0 * y)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z) t_0 = 1.0 + (z * z); t_1 = y * t_0; t_2 = (1.0 / y) / (t_0 * x); tmp = 0.0; if (t_1 < -Inf) tmp = t_2; elseif (t_1 < 8.680743250567252e+305) tmp = (1.0 / x) / (t_0 * y); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(y * t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(1.0 / y), $MachinePrecision] / N[(t$95$0 * x), $MachinePrecision]), $MachinePrecision]}, If[Less[t$95$1, (-Infinity)], t$95$2, If[Less[t$95$1, 8.680743250567252e+305], N[(N[(1.0 / x), $MachinePrecision] / N[(t$95$0 * y), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + z \cdot z\\
t_1 := y \cdot t_0\\
t_2 := \frac{\frac{1}{y}}{t_0 \cdot x}\\
\mathbf{if}\;t_1 < -\infty:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t_1 < 8.680743250567252 \cdot 10^{+305}:\\
\;\;\;\;\frac{\frac{1}{x}}{t_0 \cdot y}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2024019
(FPCore (x y z)
:name "Statistics.Distribution.CauchyLorentz:$cdensity from math-functions-0.1.5.2"
:precision binary64
:herbie-target
(if (< (* y (+ 1.0 (* z z))) (- INFINITY)) (/ (/ 1.0 y) (* (+ 1.0 (* z z)) x)) (if (< (* y (+ 1.0 (* z z))) 8.680743250567252e+305) (/ (/ 1.0 x) (* (+ 1.0 (* z z)) y)) (/ (/ 1.0 y) (* (+ 1.0 (* z z)) x))))
(/ (/ 1.0 x) (* y (+ 1.0 (* z z)))))