
(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 15 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}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* y (+ 1.0 (* z z)))))
(if (<= t_0 1e+305)
(/ (/ 1.0 x) t_0)
(* (/ 1.0 (hypot 1.0 z)) (/ 1.0 (* y (* z x)))))))z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double t_0 = y * (1.0 + (z * z));
double tmp;
if (t_0 <= 1e+305) {
tmp = (1.0 / x) / t_0;
} else {
tmp = (1.0 / hypot(1.0, z)) * (1.0 / (y * (z * x)));
}
return tmp;
}
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double t_0 = y * (1.0 + (z * z));
double tmp;
if (t_0 <= 1e+305) {
tmp = (1.0 / x) / t_0;
} else {
tmp = (1.0 / Math.hypot(1.0, z)) * (1.0 / (y * (z * x)));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): t_0 = y * (1.0 + (z * z)) tmp = 0 if t_0 <= 1e+305: tmp = (1.0 / x) / t_0 else: tmp = (1.0 / math.hypot(1.0, z)) * (1.0 / (y * (z * x))) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) t_0 = Float64(y * Float64(1.0 + Float64(z * z))) tmp = 0.0 if (t_0 <= 1e+305) tmp = Float64(Float64(1.0 / x) / t_0); else tmp = Float64(Float64(1.0 / hypot(1.0, z)) * Float64(1.0 / Float64(y * Float64(z * x)))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
t_0 = y * (1.0 + (z * z));
tmp = 0.0;
if (t_0 <= 1e+305)
tmp = (1.0 / x) / t_0;
else
tmp = (1.0 / hypot(1.0, z)) * (1.0 / (y * (z * x)));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := Block[{t$95$0 = N[(y * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 1e+305], N[(N[(1.0 / x), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sqrt[1.0 ^ 2 + z ^ 2], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(y * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := y \cdot \left(1 + z \cdot z\right)\\
\mathbf{if}\;t_0 \leq 10^{+305}:\\
\;\;\;\;\frac{\frac{1}{x}}{t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{hypot}\left(1, z\right)} \cdot \frac{1}{y \cdot \left(z \cdot x\right)}\\
\end{array}
\end{array}
if (*.f64 y (+.f64 1 (*.f64 z z))) < 9.9999999999999994e304Initial program 94.1%
if 9.9999999999999994e304 < (*.f64 y (+.f64 1 (*.f64 z z))) Initial program 76.8%
associate-/r*76.8%
*-commutative76.8%
sqr-neg76.8%
+-commutative76.8%
distribute-lft1-in76.8%
*-commutative76.8%
fma-def76.8%
sqr-neg76.8%
Simplified76.8%
associate-/r*76.8%
fma-udef76.8%
*-rgt-identity76.8%
distribute-lft-in76.8%
+-commutative76.8%
associate-/r*81.6%
associate-/r*81.6%
*-un-lft-identity81.6%
+-commutative81.6%
fma-udef81.6%
add-sqr-sqrt81.6%
times-frac81.6%
fma-udef81.6%
+-commutative81.6%
hypot-1-def81.6%
fma-udef81.6%
+-commutative81.6%
hypot-1-def92.1%
Applied egg-rr92.1%
Taylor expanded in z around inf 92.1%
Final simplification93.8%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z z) 1e+168) (* (/ 1.0 y) (/ (/ 1.0 x) (fma z z 1.0))) (/ (/ (/ (/ 1.0 z) y) x) (hypot 1.0 z))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 1e+168) {
tmp = (1.0 / y) * ((1.0 / x) / fma(z, z, 1.0));
} else {
tmp = (((1.0 / z) / y) / x) / hypot(1.0, z);
}
return tmp;
}
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 1e+168) tmp = Float64(Float64(1.0 / y) * Float64(Float64(1.0 / x) / fma(z, z, 1.0))); else tmp = Float64(Float64(Float64(Float64(1.0 / z) / y) / x) / hypot(1.0, z)); end return tmp end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 1e+168], N[(N[(1.0 / y), $MachinePrecision] * N[(N[(1.0 / x), $MachinePrecision] / N[(z * z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 / z), $MachinePrecision] / y), $MachinePrecision] / x), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + z ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 10^{+168}:\\
\;\;\;\;\frac{1}{y} \cdot \frac{\frac{1}{x}}{\mathsf{fma}\left(z, z, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{\frac{1}{z}}{y}}{x}}{\mathsf{hypot}\left(1, z\right)}\\
\end{array}
\end{array}
if (*.f64 z z) < 9.9999999999999993e167Initial program 98.9%
associate-/r*98.6%
*-commutative98.6%
sqr-neg98.6%
+-commutative98.6%
distribute-lft1-in98.6%
*-commutative98.6%
fma-def98.6%
sqr-neg98.6%
Simplified98.6%
associate-/r*98.9%
fma-udef98.9%
*-rgt-identity98.9%
distribute-lft-in98.9%
+-commutative98.9%
*-un-lft-identity98.9%
+-commutative98.9%
fma-udef98.9%
times-frac98.3%
Applied egg-rr98.3%
if 9.9999999999999993e167 < (*.f64 z z) Initial program 78.6%
associate-/r*78.0%
*-commutative78.0%
sqr-neg78.0%
+-commutative78.0%
distribute-lft1-in78.0%
*-commutative78.0%
fma-def78.0%
sqr-neg78.0%
Simplified78.0%
associate-/r*78.6%
fma-udef78.6%
*-rgt-identity78.6%
distribute-lft-in78.6%
+-commutative78.6%
associate-/r*83.2%
associate-/r*83.2%
*-un-lft-identity83.2%
+-commutative83.2%
fma-udef83.2%
add-sqr-sqrt83.2%
times-frac83.1%
fma-udef83.1%
+-commutative83.1%
hypot-1-def83.1%
fma-udef83.1%
+-commutative83.1%
hypot-1-def89.4%
Applied egg-rr89.4%
Taylor expanded in z around inf 85.7%
associate-*r*84.6%
*-commutative84.6%
Simplified84.6%
associate-*l/84.6%
*-un-lft-identity84.6%
associate-/r*84.6%
associate-/r*84.6%
Applied egg-rr84.6%
Final simplification93.3%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z z) 3e+289) (/ (/ 1.0 (* y x)) (+ 1.0 (* z z))) (/ (/ (/ (/ 1.0 z) y) x) (hypot 1.0 z))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 3e+289) {
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
} else {
tmp = (((1.0 / z) / y) / x) / hypot(1.0, z);
}
return tmp;
}
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 3e+289) {
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
} else {
tmp = (((1.0 / z) / y) / x) / Math.hypot(1.0, z);
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if (z * z) <= 3e+289: tmp = (1.0 / (y * x)) / (1.0 + (z * z)) else: tmp = (((1.0 / z) / y) / x) / math.hypot(1.0, z) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 3e+289) tmp = Float64(Float64(1.0 / Float64(y * x)) / Float64(1.0 + Float64(z * z))); else tmp = Float64(Float64(Float64(Float64(1.0 / z) / y) / x) / hypot(1.0, z)); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * z) <= 3e+289)
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
else
tmp = (((1.0 / z) / y) / x) / hypot(1.0, z);
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 3e+289], N[(N[(1.0 / N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 / z), $MachinePrecision] / y), $MachinePrecision] / x), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + z ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 3 \cdot 10^{+289}:\\
\;\;\;\;\frac{\frac{1}{y \cdot x}}{1 + z \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{\frac{1}{z}}{y}}{x}}{\mathsf{hypot}\left(1, z\right)}\\
\end{array}
\end{array}
if (*.f64 z z) < 3.0000000000000002e289Initial program 96.6%
associate-/r*96.1%
*-commutative96.1%
sqr-neg96.1%
+-commutative96.1%
distribute-lft1-in96.0%
*-commutative96.0%
fma-def96.0%
sqr-neg96.0%
Simplified96.0%
associate-/r*96.6%
fma-udef96.6%
*-rgt-identity96.6%
distribute-lft-in96.6%
+-commutative96.6%
associate-/r*98.6%
associate-/r*98.4%
*-un-lft-identity98.4%
+-commutative98.4%
fma-udef98.4%
add-sqr-sqrt98.3%
times-frac98.3%
fma-udef98.3%
+-commutative98.3%
hypot-1-def98.3%
fma-udef98.3%
+-commutative98.3%
hypot-1-def98.3%
Applied egg-rr98.3%
frac-times98.3%
*-un-lft-identity98.3%
hypot-udef98.4%
hypot-udef98.3%
add-sqr-sqrt98.4%
metadata-eval98.4%
Applied egg-rr98.4%
if 3.0000000000000002e289 < (*.f64 z z) Initial program 75.7%
associate-/r*75.7%
*-commutative75.7%
sqr-neg75.7%
+-commutative75.7%
distribute-lft1-in75.7%
*-commutative75.7%
fma-def75.7%
sqr-neg75.7%
Simplified75.7%
associate-/r*75.7%
fma-udef75.7%
*-rgt-identity75.7%
distribute-lft-in75.7%
+-commutative75.7%
associate-/r*76.4%
associate-/r*76.4%
*-un-lft-identity76.4%
+-commutative76.4%
fma-udef76.4%
add-sqr-sqrt76.4%
times-frac76.4%
fma-udef76.4%
+-commutative76.4%
hypot-1-def76.4%
fma-udef76.4%
+-commutative76.4%
hypot-1-def85.9%
Applied egg-rr85.9%
Taylor expanded in z around inf 90.5%
associate-*r*87.8%
*-commutative87.8%
Simplified87.8%
associate-*l/87.8%
*-un-lft-identity87.8%
associate-/r*87.8%
associate-/r*87.7%
Applied egg-rr87.7%
Final simplification95.8%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (let* ((t_0 (* y (+ 1.0 (* z z))))) (if (<= t_0 1e+305) (/ (/ 1.0 x) t_0) (* (/ (/ 1.0 z) x) (/ (/ 1.0 y) z)))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double t_0 = y * (1.0 + (z * z));
double tmp;
if (t_0 <= 1e+305) {
tmp = (1.0 / x) / t_0;
} else {
tmp = ((1.0 / z) / x) * ((1.0 / y) / z);
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = y * (1.0d0 + (z * z))
if (t_0 <= 1d+305) then
tmp = (1.0d0 / x) / t_0
else
tmp = ((1.0d0 / z) / x) * ((1.0d0 / y) / z)
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double t_0 = y * (1.0 + (z * z));
double tmp;
if (t_0 <= 1e+305) {
tmp = (1.0 / x) / t_0;
} else {
tmp = ((1.0 / z) / x) * ((1.0 / y) / z);
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): t_0 = y * (1.0 + (z * z)) tmp = 0 if t_0 <= 1e+305: tmp = (1.0 / x) / t_0 else: tmp = ((1.0 / z) / x) * ((1.0 / y) / z) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) t_0 = Float64(y * Float64(1.0 + Float64(z * z))) tmp = 0.0 if (t_0 <= 1e+305) tmp = Float64(Float64(1.0 / x) / t_0); else tmp = Float64(Float64(Float64(1.0 / z) / x) * Float64(Float64(1.0 / y) / z)); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
t_0 = y * (1.0 + (z * z));
tmp = 0.0;
if (t_0 <= 1e+305)
tmp = (1.0 / x) / t_0;
else
tmp = ((1.0 / z) / x) * ((1.0 / y) / z);
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := Block[{t$95$0 = N[(y * N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 1e+305], N[(N[(1.0 / x), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(1.0 / z), $MachinePrecision] / x), $MachinePrecision] * N[(N[(1.0 / y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := y \cdot \left(1 + z \cdot z\right)\\
\mathbf{if}\;t_0 \leq 10^{+305}:\\
\;\;\;\;\frac{\frac{1}{x}}{t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{z}}{x} \cdot \frac{\frac{1}{y}}{z}\\
\end{array}
\end{array}
if (*.f64 y (+.f64 1 (*.f64 z z))) < 9.9999999999999994e304Initial program 94.1%
if 9.9999999999999994e304 < (*.f64 y (+.f64 1 (*.f64 z z))) Initial program 76.8%
associate-/r*76.8%
*-commutative76.8%
sqr-neg76.8%
+-commutative76.8%
distribute-lft1-in76.8%
*-commutative76.8%
fma-def76.8%
sqr-neg76.8%
Simplified76.8%
Taylor expanded in z around inf 81.9%
unpow281.9%
associate-*l*89.8%
Simplified89.8%
frac-2neg89.8%
metadata-eval89.8%
associate-*r*81.9%
associate-*r*76.8%
remove-double-neg76.8%
distribute-rgt-neg-out76.8%
distribute-lft-neg-out76.8%
distribute-rgt-neg-out76.8%
remove-double-neg76.8%
distribute-rgt-neg-out76.8%
associate-/l/76.8%
frac-2neg76.8%
div-inv76.8%
distribute-neg-frac76.8%
metadata-eval76.8%
metadata-eval76.8%
distribute-rgt-neg-out76.8%
remove-double-neg76.8%
associate-*r*87.1%
Applied egg-rr97.2%
Final simplification94.5%
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(if (<= (* z z) 2e-6)
(/ (/ 1.0 y) x)
(if (<= (* z z) 5e+289)
(/ 1.0 (* (* z z) (* y x)))
(/ 1.0 (* y (* z (* z x)))))))z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e-6) {
tmp = (1.0 / y) / x;
} else if ((z * z) <= 5e+289) {
tmp = 1.0 / ((z * z) * (y * x));
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * z) <= 2d-6) then
tmp = (1.0d0 / y) / x
else if ((z * z) <= 5d+289) then
tmp = 1.0d0 / ((z * z) * (y * x))
else
tmp = 1.0d0 / (y * (z * (z * x)))
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e-6) {
tmp = (1.0 / y) / x;
} else if ((z * z) <= 5e+289) {
tmp = 1.0 / ((z * z) * (y * x));
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if (z * z) <= 2e-6: tmp = (1.0 / y) / x elif (z * z) <= 5e+289: tmp = 1.0 / ((z * z) * (y * x)) else: tmp = 1.0 / (y * (z * (z * x))) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e-6) tmp = Float64(Float64(1.0 / y) / x); elseif (Float64(z * z) <= 5e+289) tmp = Float64(1.0 / Float64(Float64(z * z) * Float64(y * x))); else tmp = Float64(1.0 / Float64(y * Float64(z * Float64(z * x)))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * z) <= 2e-6)
tmp = (1.0 / y) / x;
elseif ((z * z) <= 5e+289)
tmp = 1.0 / ((z * z) * (y * x));
else
tmp = 1.0 / (y * (z * (z * x)));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e-6], N[(N[(1.0 / y), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[N[(z * z), $MachinePrecision], 5e+289], N[(1.0 / N[(N[(z * z), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(y * N[(z * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\frac{\frac{1}{y}}{x}\\
\mathbf{elif}\;z \cdot z \leq 5 \cdot 10^{+289}:\\
\;\;\;\;\frac{1}{\left(z \cdot z\right) \cdot \left(y \cdot x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{y \cdot \left(z \cdot \left(z \cdot x\right)\right)}\\
\end{array}
\end{array}
if (*.f64 z z) < 1.99999999999999991e-6Initial program 99.6%
associate-/r*99.2%
*-commutative99.2%
sqr-neg99.2%
+-commutative99.2%
distribute-lft1-in99.2%
*-commutative99.2%
fma-def99.2%
sqr-neg99.2%
Simplified99.2%
associate-/r*99.6%
fma-udef99.6%
*-rgt-identity99.6%
distribute-lft-in99.6%
+-commutative99.6%
associate-/r*99.6%
associate-/r*99.2%
*-un-lft-identity99.2%
+-commutative99.2%
fma-udef99.2%
add-sqr-sqrt99.1%
times-frac99.2%
fma-udef99.2%
+-commutative99.2%
hypot-1-def99.2%
fma-udef99.2%
+-commutative99.2%
hypot-1-def99.1%
Applied egg-rr99.1%
frac-times99.1%
*-un-lft-identity99.1%
hypot-udef99.2%
hypot-udef99.1%
add-sqr-sqrt99.2%
metadata-eval99.2%
Applied egg-rr99.2%
Taylor expanded in z around 0 97.8%
associate-/r*98.3%
Simplified98.3%
if 1.99999999999999991e-6 < (*.f64 z z) < 5.00000000000000031e289Initial program 90.3%
associate-/r*89.5%
*-commutative89.5%
sqr-neg89.5%
+-commutative89.5%
distribute-lft1-in89.5%
*-commutative89.5%
fma-def89.5%
sqr-neg89.5%
Simplified89.5%
associate-/r*90.3%
fma-udef90.3%
*-rgt-identity90.3%
distribute-lft-in90.3%
+-commutative90.3%
associate-/r*97.0%
associate-/r*97.1%
*-un-lft-identity97.1%
+-commutative97.1%
fma-udef97.1%
add-sqr-sqrt97.0%
times-frac96.8%
fma-udef96.8%
+-commutative96.8%
hypot-1-def96.8%
fma-udef96.8%
+-commutative96.8%
hypot-1-def96.8%
Applied egg-rr96.8%
Taylor expanded in z around inf 86.1%
associate-*r*87.3%
unpow287.3%
*-commutative87.3%
unpow287.3%
associate-*r*93.8%
*-commutative93.8%
unpow293.8%
Simplified93.8%
if 5.00000000000000031e289 < (*.f64 z z) Initial program 76.8%
associate-/r*76.8%
*-commutative76.8%
sqr-neg76.8%
+-commutative76.8%
distribute-lft1-in76.8%
*-commutative76.8%
fma-def76.8%
sqr-neg76.8%
Simplified76.8%
Taylor expanded in z around inf 76.8%
unpow276.8%
associate-*l*87.8%
Simplified87.8%
Final simplification94.5%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z z) 2e-6) (/ (- 1.0 (* z z)) (* y x)) (* (/ 1.0 z) (/ (/ (/ 1.0 z) y) x))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e-6) {
tmp = (1.0 - (z * z)) / (y * x);
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * z) <= 2d-6) then
tmp = (1.0d0 - (z * z)) / (y * x)
else
tmp = (1.0d0 / z) * (((1.0d0 / z) / y) / x)
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e-6) {
tmp = (1.0 - (z * z)) / (y * x);
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if (z * z) <= 2e-6: tmp = (1.0 - (z * z)) / (y * x) else: tmp = (1.0 / z) * (((1.0 / z) / y) / x) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e-6) tmp = Float64(Float64(1.0 - Float64(z * z)) / Float64(y * x)); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / y) / x)); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * z) <= 2e-6)
tmp = (1.0 - (z * z)) / (y * x);
else
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e-6], N[(N[(1.0 - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * x), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\frac{1 - z \cdot z}{y \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{y}}{x}\\
\end{array}
\end{array}
if (*.f64 z z) < 1.99999999999999991e-6Initial program 99.6%
associate-/r*99.2%
*-commutative99.2%
sqr-neg99.2%
+-commutative99.2%
distribute-lft1-in99.2%
*-commutative99.2%
fma-def99.2%
sqr-neg99.2%
Simplified99.2%
Taylor expanded in z around 0 86.7%
*-commutative86.7%
mul-1-neg86.7%
unsub-neg86.7%
unpow286.7%
*-commutative86.7%
div-sub98.9%
*-commutative98.9%
Simplified98.9%
if 1.99999999999999991e-6 < (*.f64 z z) Initial program 84.1%
associate-/r*83.7%
*-commutative83.7%
sqr-neg83.7%
+-commutative83.7%
distribute-lft1-in83.7%
*-commutative83.7%
fma-def83.7%
sqr-neg83.7%
Simplified83.7%
Taylor expanded in z around inf 81.9%
unpow281.9%
associate-*r*82.5%
*-commutative82.5%
associate-/r*82.9%
associate-*r*88.7%
*-commutative88.7%
associate-*r*88.7%
Simplified88.7%
*-un-lft-identity88.7%
*-commutative88.7%
times-frac93.7%
associate-/r*93.7%
associate-/l/93.6%
associate-/r*93.7%
Applied egg-rr93.7%
Final simplification96.2%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z z) 5e+73) (/ 1.0 (* x (+ y (* y (* z z))))) (* (/ 1.0 z) (/ (/ (/ 1.0 z) y) x))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 5e+73) {
tmp = 1.0 / (x * (y + (y * (z * z))));
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * z) <= 5d+73) then
tmp = 1.0d0 / (x * (y + (y * (z * z))))
else
tmp = (1.0d0 / z) * (((1.0d0 / z) / y) / x)
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 5e+73) {
tmp = 1.0 / (x * (y + (y * (z * z))));
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if (z * z) <= 5e+73: tmp = 1.0 / (x * (y + (y * (z * z)))) else: tmp = (1.0 / z) * (((1.0 / z) / y) / x) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 5e+73) tmp = Float64(1.0 / Float64(x * Float64(y + Float64(y * Float64(z * z))))); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / y) / x)); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * z) <= 5e+73)
tmp = 1.0 / (x * (y + (y * (z * z))));
else
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 5e+73], N[(1.0 / N[(x * N[(y + N[(y * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 5 \cdot 10^{+73}:\\
\;\;\;\;\frac{1}{x \cdot \left(y + y \cdot \left(z \cdot z\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{y}}{x}\\
\end{array}
\end{array}
if (*.f64 z z) < 4.99999999999999976e73Initial program 99.6%
associate-/r*99.2%
*-commutative99.2%
sqr-neg99.2%
+-commutative99.2%
distribute-lft1-in99.2%
*-commutative99.2%
fma-def99.2%
sqr-neg99.2%
Simplified99.2%
fma-udef99.2%
Applied egg-rr99.2%
if 4.99999999999999976e73 < (*.f64 z z) Initial program 82.0%
associate-/r*81.5%
*-commutative81.5%
sqr-neg81.5%
+-commutative81.5%
distribute-lft1-in81.5%
*-commutative81.5%
fma-def81.5%
sqr-neg81.5%
Simplified81.5%
Taylor expanded in z around inf 80.8%
unpow280.8%
associate-*r*81.5%
*-commutative81.5%
associate-/r*82.0%
associate-*r*88.6%
*-commutative88.6%
associate-*r*88.6%
Simplified88.6%
*-un-lft-identity88.6%
*-commutative88.6%
times-frac95.1%
associate-/r*95.0%
associate-/l/95.0%
associate-/r*95.1%
Applied egg-rr95.1%
Final simplification97.3%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z z) 2e+307) (/ (/ 1.0 (* y x)) (+ 1.0 (* z z))) (* (/ 1.0 z) (/ (/ (/ 1.0 z) y) x))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+307) {
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * z) <= 2d+307) then
tmp = (1.0d0 / (y * x)) / (1.0d0 + (z * z))
else
tmp = (1.0d0 / z) * (((1.0d0 / z) / y) / x)
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+307) {
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
} else {
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if (z * z) <= 2e+307: tmp = (1.0 / (y * x)) / (1.0 + (z * z)) else: tmp = (1.0 / z) * (((1.0 / z) / y) / x) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e+307) tmp = Float64(Float64(1.0 / Float64(y * x)) / Float64(1.0 + Float64(z * z))); else tmp = Float64(Float64(1.0 / z) * Float64(Float64(Float64(1.0 / z) / y) / x)); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * z) <= 2e+307)
tmp = (1.0 / (y * x)) / (1.0 + (z * z));
else
tmp = (1.0 / z) * (((1.0 / z) / y) / x);
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e+307], N[(N[(1.0 / N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / z), $MachinePrecision] * N[(N[(N[(1.0 / z), $MachinePrecision] / y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{+307}:\\
\;\;\;\;\frac{\frac{1}{y \cdot x}}{1 + z \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{z} \cdot \frac{\frac{\frac{1}{z}}{y}}{x}\\
\end{array}
\end{array}
if (*.f64 z z) < 1.99999999999999997e307Initial program 95.9%
associate-/r*95.3%
*-commutative95.3%
sqr-neg95.3%
+-commutative95.3%
distribute-lft1-in95.3%
*-commutative95.3%
fma-def95.3%
sqr-neg95.3%
Simplified95.3%
associate-/r*95.9%
fma-udef95.9%
*-rgt-identity95.9%
distribute-lft-in95.9%
+-commutative95.9%
associate-/r*98.2%
associate-/r*98.0%
*-un-lft-identity98.0%
+-commutative98.0%
fma-udef98.0%
add-sqr-sqrt97.9%
times-frac97.9%
fma-udef97.9%
+-commutative97.9%
hypot-1-def97.9%
fma-udef97.9%
+-commutative97.9%
hypot-1-def97.8%
Applied egg-rr97.8%
frac-times97.9%
*-un-lft-identity97.9%
hypot-udef97.9%
hypot-udef97.9%
add-sqr-sqrt98.0%
metadata-eval98.0%
Applied egg-rr98.0%
if 1.99999999999999997e307 < (*.f64 z z) Initial program 76.1%
associate-/r*76.1%
*-commutative76.1%
sqr-neg76.1%
+-commutative76.1%
distribute-lft1-in76.1%
*-commutative76.1%
fma-def76.1%
sqr-neg76.1%
Simplified76.1%
Taylor expanded in z around inf 76.1%
unpow276.1%
associate-*r*76.1%
*-commutative76.1%
associate-/r*76.1%
associate-*r*89.7%
*-commutative89.7%
associate-*r*89.7%
Simplified89.7%
*-un-lft-identity89.7%
*-commutative89.7%
times-frac98.2%
associate-/r*98.1%
associate-/l/98.1%
associate-/r*98.5%
Applied egg-rr98.5%
Final simplification98.1%
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(if (<= z 0.86)
(/ (- 1.0 (* z z)) (* y x))
(if (<= z 2.5e+145)
(/ 1.0 (* (* z z) (* y x)))
(/ 1.0 (* y (* z (* z x)))))))z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if (z <= 0.86) {
tmp = (1.0 - (z * z)) / (y * x);
} else if (z <= 2.5e+145) {
tmp = 1.0 / ((z * z) * (y * x));
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 0.86d0) then
tmp = (1.0d0 - (z * z)) / (y * x)
else if (z <= 2.5d+145) then
tmp = 1.0d0 / ((z * z) * (y * x))
else
tmp = 1.0d0 / (y * (z * (z * x)))
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if (z <= 0.86) {
tmp = (1.0 - (z * z)) / (y * x);
} else if (z <= 2.5e+145) {
tmp = 1.0 / ((z * z) * (y * x));
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if z <= 0.86: tmp = (1.0 - (z * z)) / (y * x) elif z <= 2.5e+145: tmp = 1.0 / ((z * z) * (y * x)) else: tmp = 1.0 / (y * (z * (z * x))) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (z <= 0.86) tmp = Float64(Float64(1.0 - Float64(z * z)) / Float64(y * x)); elseif (z <= 2.5e+145) tmp = Float64(1.0 / Float64(Float64(z * z) * Float64(y * x))); else tmp = Float64(1.0 / Float64(y * Float64(z * Float64(z * x)))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if (z <= 0.86)
tmp = (1.0 - (z * z)) / (y * x);
elseif (z <= 2.5e+145)
tmp = 1.0 / ((z * z) * (y * x));
else
tmp = 1.0 / (y * (z * (z * x)));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[z, 0.86], N[(N[(1.0 - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.5e+145], N[(1.0 / N[(N[(z * z), $MachinePrecision] * N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(y * N[(z * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 0.86:\\
\;\;\;\;\frac{1 - z \cdot z}{y \cdot x}\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+145}:\\
\;\;\;\;\frac{1}{\left(z \cdot z\right) \cdot \left(y \cdot x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{y \cdot \left(z \cdot \left(z \cdot x\right)\right)}\\
\end{array}
\end{array}
if z < 0.859999999999999987Initial program 96.5%
associate-/r*96.2%
*-commutative96.2%
sqr-neg96.2%
+-commutative96.2%
distribute-lft1-in96.2%
*-commutative96.2%
fma-def96.2%
sqr-neg96.2%
Simplified96.2%
Taylor expanded in z around 0 61.0%
*-commutative61.0%
mul-1-neg61.0%
unsub-neg61.0%
unpow261.0%
*-commutative61.0%
div-sub69.3%
*-commutative69.3%
Simplified69.3%
if 0.859999999999999987 < z < 2.49999999999999983e145Initial program 87.1%
associate-/r*85.8%
*-commutative85.8%
sqr-neg85.8%
+-commutative85.8%
distribute-lft1-in85.8%
*-commutative85.8%
fma-def85.8%
sqr-neg85.8%
Simplified85.8%
associate-/r*87.1%
fma-udef87.1%
*-rgt-identity87.1%
distribute-lft-in87.1%
+-commutative87.1%
associate-/r*95.6%
associate-/r*95.7%
*-un-lft-identity95.7%
+-commutative95.7%
fma-udef95.7%
add-sqr-sqrt95.6%
times-frac95.4%
fma-udef95.4%
+-commutative95.4%
hypot-1-def95.4%
fma-udef95.4%
+-commutative95.4%
hypot-1-def95.4%
Applied egg-rr95.4%
Taylor expanded in z around inf 86.4%
associate-*r*82.3%
unpow282.3%
*-commutative82.3%
unpow282.3%
associate-*r*90.6%
*-commutative90.6%
unpow290.6%
Simplified90.6%
if 2.49999999999999983e145 < z Initial program 68.7%
associate-/r*68.7%
*-commutative68.7%
sqr-neg68.7%
+-commutative68.7%
distribute-lft1-in68.7%
*-commutative68.7%
fma-def68.7%
sqr-neg68.7%
Simplified68.7%
Taylor expanded in z around inf 68.7%
unpow268.7%
associate-*l*81.5%
Simplified81.5%
Final simplification74.5%
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(if (<= z 0.86)
(/ (- 1.0 (* z z)) (* y x))
(if (<= z 6.6e+145)
(/ (/ (/ 1.0 y) x) (* z z))
(/ 1.0 (* y (* z (* z x)))))))z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if (z <= 0.86) {
tmp = (1.0 - (z * z)) / (y * x);
} else if (z <= 6.6e+145) {
tmp = ((1.0 / y) / x) / (z * z);
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 0.86d0) then
tmp = (1.0d0 - (z * z)) / (y * x)
else if (z <= 6.6d+145) then
tmp = ((1.0d0 / y) / x) / (z * z)
else
tmp = 1.0d0 / (y * (z * (z * x)))
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if (z <= 0.86) {
tmp = (1.0 - (z * z)) / (y * x);
} else if (z <= 6.6e+145) {
tmp = ((1.0 / y) / x) / (z * z);
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if z <= 0.86: tmp = (1.0 - (z * z)) / (y * x) elif z <= 6.6e+145: tmp = ((1.0 / y) / x) / (z * z) else: tmp = 1.0 / (y * (z * (z * x))) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (z <= 0.86) tmp = Float64(Float64(1.0 - Float64(z * z)) / Float64(y * x)); elseif (z <= 6.6e+145) tmp = Float64(Float64(Float64(1.0 / y) / x) / Float64(z * z)); else tmp = Float64(1.0 / Float64(y * Float64(z * Float64(z * x)))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if (z <= 0.86)
tmp = (1.0 - (z * z)) / (y * x);
elseif (z <= 6.6e+145)
tmp = ((1.0 / y) / x) / (z * z);
else
tmp = 1.0 / (y * (z * (z * x)));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[z, 0.86], N[(N[(1.0 - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.6e+145], N[(N[(N[(1.0 / y), $MachinePrecision] / x), $MachinePrecision] / N[(z * z), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(y * N[(z * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 0.86:\\
\;\;\;\;\frac{1 - z \cdot z}{y \cdot x}\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{+145}:\\
\;\;\;\;\frac{\frac{\frac{1}{y}}{x}}{z \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{y \cdot \left(z \cdot \left(z \cdot x\right)\right)}\\
\end{array}
\end{array}
if z < 0.859999999999999987Initial program 96.5%
associate-/r*96.2%
*-commutative96.2%
sqr-neg96.2%
+-commutative96.2%
distribute-lft1-in96.2%
*-commutative96.2%
fma-def96.2%
sqr-neg96.2%
Simplified96.2%
Taylor expanded in z around 0 61.0%
*-commutative61.0%
mul-1-neg61.0%
unsub-neg61.0%
unpow261.0%
*-commutative61.0%
div-sub69.3%
*-commutative69.3%
Simplified69.3%
if 0.859999999999999987 < z < 6.60000000000000054e145Initial program 87.1%
associate-/r*85.8%
*-commutative85.8%
sqr-neg85.8%
+-commutative85.8%
distribute-lft1-in85.8%
*-commutative85.8%
fma-def85.8%
sqr-neg85.8%
Simplified85.8%
associate-/r*87.1%
fma-udef87.1%
*-rgt-identity87.1%
distribute-lft-in87.1%
+-commutative87.1%
associate-/r*95.6%
associate-/r*95.7%
*-un-lft-identity95.7%
+-commutative95.7%
fma-udef95.7%
add-sqr-sqrt95.6%
times-frac95.4%
fma-udef95.4%
+-commutative95.4%
hypot-1-def95.4%
fma-udef95.4%
+-commutative95.4%
hypot-1-def95.4%
Applied egg-rr95.4%
frac-times95.6%
*-un-lft-identity95.6%
hypot-udef95.6%
hypot-udef95.6%
add-sqr-sqrt95.7%
metadata-eval95.7%
Applied egg-rr95.7%
Taylor expanded in z around inf 86.4%
associate-/r*86.3%
unpow286.3%
*-commutative86.3%
associate-/r*92.1%
Simplified92.1%
if 6.60000000000000054e145 < z Initial program 68.7%
associate-/r*68.7%
*-commutative68.7%
sqr-neg68.7%
+-commutative68.7%
distribute-lft1-in68.7%
*-commutative68.7%
fma-def68.7%
sqr-neg68.7%
Simplified68.7%
Taylor expanded in z around inf 68.7%
unpow268.7%
associate-*l*81.5%
Simplified81.5%
Final simplification74.7%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= z 1.0) (/ (/ 1.0 y) x) (/ 1.0 (* y (* z (* z x))))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / y) / x;
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 1.0d0) then
tmp = (1.0d0 / y) / x
else
tmp = 1.0d0 / (y * (z * (z * x)))
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / y) / x;
} else {
tmp = 1.0 / (y * (z * (z * x)));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if z <= 1.0: tmp = (1.0 / y) / x else: tmp = 1.0 / (y * (z * (z * x))) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (z <= 1.0) tmp = Float64(Float64(1.0 / y) / x); else tmp = Float64(1.0 / Float64(y * Float64(z * Float64(z * x)))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if (z <= 1.0)
tmp = (1.0 / y) / x;
else
tmp = 1.0 / (y * (z * (z * x)));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[z, 1.0], N[(N[(1.0 / y), $MachinePrecision] / x), $MachinePrecision], N[(1.0 / N[(y * N[(z * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 1:\\
\;\;\;\;\frac{\frac{1}{y}}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{y \cdot \left(z \cdot \left(z \cdot x\right)\right)}\\
\end{array}
\end{array}
if z < 1Initial program 96.5%
associate-/r*96.2%
*-commutative96.2%
sqr-neg96.2%
+-commutative96.2%
distribute-lft1-in96.2%
*-commutative96.2%
fma-def96.2%
sqr-neg96.2%
Simplified96.2%
associate-/r*96.5%
fma-udef96.5%
*-rgt-identity96.5%
distribute-lft-in96.5%
+-commutative96.5%
associate-/r*96.5%
associate-/r*96.2%
*-un-lft-identity96.2%
+-commutative96.2%
fma-udef96.2%
add-sqr-sqrt96.2%
times-frac96.1%
fma-udef96.1%
+-commutative96.1%
hypot-1-def96.1%
fma-udef96.1%
+-commutative96.1%
hypot-1-def98.2%
Applied egg-rr98.2%
frac-times96.2%
*-un-lft-identity96.2%
hypot-udef96.2%
hypot-udef96.2%
add-sqr-sqrt96.2%
metadata-eval96.2%
Applied egg-rr96.2%
Taylor expanded in z around 0 72.2%
associate-/r*72.5%
Simplified72.5%
if 1 < z Initial program 79.7%
associate-/r*79.0%
*-commutative79.0%
sqr-neg79.0%
+-commutative79.0%
distribute-lft1-in79.0%
*-commutative79.0%
fma-def79.0%
sqr-neg79.0%
Simplified79.0%
Taylor expanded in z around inf 79.3%
unpow279.3%
associate-*l*84.4%
Simplified84.4%
Final simplification76.0%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= z 1.0) (/ (/ 1.0 y) x) (/ 1.0 (* y (* z x)))))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / y) / x;
} else {
tmp = 1.0 / (y * (z * x));
}
return tmp;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (z <= 1.0d0) then
tmp = (1.0d0 / y) / x
else
tmp = 1.0d0 / (y * (z * x))
end if
code = tmp
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
double tmp;
if (z <= 1.0) {
tmp = (1.0 / y) / x;
} else {
tmp = 1.0 / (y * (z * x));
}
return tmp;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): tmp = 0 if z <= 1.0: tmp = (1.0 / y) / x else: tmp = 1.0 / (y * (z * x)) return tmp
z = abs(z) x, y = sort([x, y]) function code(x, y, z) tmp = 0.0 if (z <= 1.0) tmp = Float64(Float64(1.0 / y) / x); else tmp = Float64(1.0 / Float64(y * Float64(z * x))); end return tmp end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if (z <= 1.0)
tmp = (1.0 / y) / x;
else
tmp = 1.0 / (y * (z * x));
end
tmp_2 = tmp;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[z, 1.0], N[(N[(1.0 / y), $MachinePrecision] / x), $MachinePrecision], N[(1.0 / N[(y * N[(z * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 1:\\
\;\;\;\;\frac{\frac{1}{y}}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{y \cdot \left(z \cdot x\right)}\\
\end{array}
\end{array}
if z < 1Initial program 96.5%
associate-/r*96.2%
*-commutative96.2%
sqr-neg96.2%
+-commutative96.2%
distribute-lft1-in96.2%
*-commutative96.2%
fma-def96.2%
sqr-neg96.2%
Simplified96.2%
associate-/r*96.5%
fma-udef96.5%
*-rgt-identity96.5%
distribute-lft-in96.5%
+-commutative96.5%
associate-/r*96.5%
associate-/r*96.2%
*-un-lft-identity96.2%
+-commutative96.2%
fma-udef96.2%
add-sqr-sqrt96.2%
times-frac96.1%
fma-udef96.1%
+-commutative96.1%
hypot-1-def96.1%
fma-udef96.1%
+-commutative96.1%
hypot-1-def98.2%
Applied egg-rr98.2%
frac-times96.2%
*-un-lft-identity96.2%
hypot-udef96.2%
hypot-udef96.2%
add-sqr-sqrt96.2%
metadata-eval96.2%
Applied egg-rr96.2%
Taylor expanded in z around 0 72.2%
associate-/r*72.5%
Simplified72.5%
if 1 < z Initial program 79.7%
associate-/r*79.0%
*-commutative79.0%
sqr-neg79.0%
+-commutative79.0%
distribute-lft1-in79.0%
*-commutative79.0%
fma-def79.0%
sqr-neg79.0%
Simplified79.0%
associate-/r*79.7%
fma-udef79.7%
*-rgt-identity79.7%
distribute-lft-in79.7%
+-commutative79.7%
associate-/r*85.5%
associate-/r*85.6%
*-un-lft-identity85.6%
+-commutative85.6%
fma-udef85.6%
add-sqr-sqrt85.5%
times-frac85.4%
fma-udef85.4%
+-commutative85.4%
hypot-1-def85.4%
fma-udef85.4%
+-commutative85.4%
hypot-1-def88.1%
Applied egg-rr88.1%
Taylor expanded in z around inf 91.8%
associate-*r*91.6%
*-commutative91.6%
Simplified91.6%
Taylor expanded in z around 0 34.4%
Final simplification61.3%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (/ 1.0 (* y x)))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
return 1.0 / (y * x);
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
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 / (y * x)
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
return 1.0 / (y * x);
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): return 1.0 / (y * x)
z = abs(z) x, y = sort([x, y]) function code(x, y, z) return Float64(1.0 / Float64(y * x)) end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
tmp = 1.0 / (y * x);
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := N[(1.0 / N[(y * x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{1}{y \cdot x}
\end{array}
Initial program 91.6%
associate-/r*91.1%
*-commutative91.1%
sqr-neg91.1%
+-commutative91.1%
distribute-lft1-in91.1%
*-commutative91.1%
fma-def91.1%
sqr-neg91.1%
Simplified91.1%
Taylor expanded in z around 0 56.2%
Final simplification56.2%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (/ (/ 1.0 x) y))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
return (1.0 / x) / y;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
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
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
return (1.0 / x) / y;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): return (1.0 / x) / y
z = abs(z) x, y = sort([x, y]) function code(x, y, z) return Float64(Float64(1.0 / x) / y) end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
tmp = (1.0 / x) / y;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := N[(N[(1.0 / x), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{\frac{1}{x}}{y}
\end{array}
Initial program 91.6%
associate-/r*91.1%
*-commutative91.1%
sqr-neg91.1%
+-commutative91.1%
distribute-lft1-in91.1%
*-commutative91.1%
fma-def91.1%
sqr-neg91.1%
Simplified91.1%
Taylor expanded in z around 0 56.2%
associate-/r*56.3%
div-inv56.3%
Applied egg-rr56.3%
associate-*l/56.3%
*-un-lft-identity56.3%
Applied egg-rr56.3%
Final simplification56.3%
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (/ (/ 1.0 y) x))
z = abs(z);
assert(x < y);
double code(double x, double y, double z) {
return (1.0 / y) / x;
}
NOTE: z should be positive before calling this function
NOTE: x and y should be sorted in increasing order before calling this function.
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 / y) / x
end function
z = Math.abs(z);
assert x < y;
public static double code(double x, double y, double z) {
return (1.0 / y) / x;
}
z = abs(z) [x, y] = sort([x, y]) def code(x, y, z): return (1.0 / y) / x
z = abs(z) x, y = sort([x, y]) function code(x, y, z) return Float64(Float64(1.0 / y) / x) end
z = abs(z)
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
tmp = (1.0 / y) / x;
end
NOTE: z should be positive before calling this function NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_, z_] := N[(N[(1.0 / y), $MachinePrecision] / x), $MachinePrecision]
\begin{array}{l}
z = |z|\\
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{\frac{1}{y}}{x}
\end{array}
Initial program 91.6%
associate-/r*91.1%
*-commutative91.1%
sqr-neg91.1%
+-commutative91.1%
distribute-lft1-in91.1%
*-commutative91.1%
fma-def91.1%
sqr-neg91.1%
Simplified91.1%
associate-/r*91.6%
fma-udef91.6%
*-rgt-identity91.6%
distribute-lft-in91.6%
+-commutative91.6%
associate-/r*93.3%
associate-/r*93.1%
*-un-lft-identity93.1%
+-commutative93.1%
fma-udef93.1%
add-sqr-sqrt93.0%
times-frac93.0%
fma-udef93.0%
+-commutative93.0%
hypot-1-def93.0%
fma-udef93.0%
+-commutative93.0%
hypot-1-def95.3%
Applied egg-rr95.3%
frac-times93.0%
*-un-lft-identity93.0%
hypot-udef93.1%
hypot-udef93.0%
add-sqr-sqrt93.1%
metadata-eval93.1%
Applied egg-rr93.1%
Taylor expanded in z around 0 56.2%
associate-/r*56.3%
Simplified56.3%
Final simplification56.3%
(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 2023309
(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)))))