
(FPCore (x y z) :precision binary64 (/ (* x y) (* (* z z) (+ z 1.0))))
double code(double x, double y, double z) {
return (x * y) / ((z * z) * (z + 1.0));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x * y) / ((z * z) * (z + 1.0d0))
end function
public static double code(double x, double y, double z) {
return (x * y) / ((z * z) * (z + 1.0));
}
def code(x, y, z): return (x * y) / ((z * z) * (z + 1.0))
function code(x, y, z) return Float64(Float64(x * y) / Float64(Float64(z * z) * Float64(z + 1.0))) end
function tmp = code(x, y, z) tmp = (x * y) / ((z * z) * (z + 1.0)); end
code[x_, y_, z_] := N[(N[(x * y), $MachinePrecision] / N[(N[(z * z), $MachinePrecision] * N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (* x y) (* (* z z) (+ z 1.0))))
double code(double x, double y, double z) {
return (x * y) / ((z * z) * (z + 1.0));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x * y) / ((z * z) * (z + 1.0d0))
end function
public static double code(double x, double y, double z) {
return (x * y) / ((z * z) * (z + 1.0));
}
def code(x, y, z): return (x * y) / ((z * z) * (z + 1.0))
function code(x, y, z) return Float64(Float64(x * y) / Float64(Float64(z * z) * Float64(z + 1.0))) end
function tmp = code(x, y, z) tmp = (x * y) / ((z * z) * (z + 1.0)); end
code[x_, y_, z_] := N[(N[(x * y), $MachinePrecision] / N[(N[(z * z), $MachinePrecision] * N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)}
\end{array}
(FPCore (x y z) :precision binary64 (/ (* (/ x z) (/ y z)) (+ z 1.0)))
double code(double x, double y, double z) {
return ((x / z) * (y / z)) / (z + 1.0);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((x / z) * (y / z)) / (z + 1.0d0)
end function
public static double code(double x, double y, double z) {
return ((x / z) * (y / z)) / (z + 1.0);
}
def code(x, y, z): return ((x / z) * (y / z)) / (z + 1.0)
function code(x, y, z) return Float64(Float64(Float64(x / z) * Float64(y / z)) / Float64(z + 1.0)) end
function tmp = code(x, y, z) tmp = ((x / z) * (y / z)) / (z + 1.0); end
code[x_, y_, z_] := N[(N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision] / N[(z + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{z} \cdot \frac{y}{z}}{z + 1}
\end{array}
Initial program 82.8%
associate-*l*82.8%
times-frac96.7%
associate-/r*97.4%
associate-*r/98.7%
Simplified98.7%
Final simplification98.7%
(FPCore (x y z) :precision binary64 (if (or (<= z -1.0) (not (<= z 0.75))) (* (/ y z) (/ x (* z z))) (* (/ y z) (- (/ x z) x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= 0.75)) {
tmp = (y / z) * (x / (z * z));
} else {
tmp = (y / z) * ((x / z) - x);
}
return tmp;
}
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)) .or. (.not. (z <= 0.75d0))) then
tmp = (y / z) * (x / (z * z))
else
tmp = (y / z) * ((x / z) - x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= 0.75)) {
tmp = (y / z) * (x / (z * z));
} else {
tmp = (y / z) * ((x / z) - x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -1.0) or not (z <= 0.75): tmp = (y / z) * (x / (z * z)) else: tmp = (y / z) * ((x / z) - x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -1.0) || !(z <= 0.75)) tmp = Float64(Float64(y / z) * Float64(x / Float64(z * z))); else tmp = Float64(Float64(y / z) * Float64(Float64(x / z) - x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -1.0) || ~((z <= 0.75))) tmp = (y / z) * (x / (z * z)); else tmp = (y / z) * ((x / z) - x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, 0.75]], $MachinePrecision]], N[(N[(y / z), $MachinePrecision] * N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 0.75\right):\\
\;\;\;\;\frac{y}{z} \cdot \frac{x}{z \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z} \cdot \left(\frac{x}{z} - x\right)\\
\end{array}
\end{array}
if z < -1 or 0.75 < z Initial program 85.5%
associate-*l*85.5%
times-frac96.0%
associate-/r*97.4%
associate-*r/99.8%
Simplified99.8%
frac-times91.0%
associate-/r*85.5%
*-commutative85.5%
frac-times95.9%
associate-*l/97.0%
times-frac97.5%
Applied egg-rr97.5%
Taylor expanded in z around inf 95.0%
unpow295.0%
Simplified95.0%
if -1 < z < 0.75Initial program 79.9%
associate-*l*79.9%
times-frac97.4%
associate-/r*97.4%
associate-*r/97.4%
Simplified97.4%
frac-times79.9%
associate-/r*79.9%
*-commutative79.9%
frac-times82.9%
associate-*l/79.9%
times-frac97.4%
Applied egg-rr97.4%
Taylor expanded in z around 0 96.9%
neg-mul-196.9%
+-commutative96.9%
unsub-neg96.9%
Simplified96.9%
Final simplification95.9%
(FPCore (x y z) :precision binary64 (if (or (<= z -1.0) (not (<= z 0.76))) (* (/ y z) (/ (/ x z) z)) (* (/ y z) (- (/ x z) x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= 0.76)) {
tmp = (y / z) * ((x / z) / z);
} else {
tmp = (y / z) * ((x / z) - x);
}
return tmp;
}
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)) .or. (.not. (z <= 0.76d0))) then
tmp = (y / z) * ((x / z) / z)
else
tmp = (y / z) * ((x / z) - x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= 0.76)) {
tmp = (y / z) * ((x / z) / z);
} else {
tmp = (y / z) * ((x / z) - x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -1.0) or not (z <= 0.76): tmp = (y / z) * ((x / z) / z) else: tmp = (y / z) * ((x / z) - x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -1.0) || !(z <= 0.76)) tmp = Float64(Float64(y / z) * Float64(Float64(x / z) / z)); else tmp = Float64(Float64(y / z) * Float64(Float64(x / z) - x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -1.0) || ~((z <= 0.76))) tmp = (y / z) * ((x / z) / z); else tmp = (y / z) * ((x / z) - x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, 0.76]], $MachinePrecision]], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 0.76\right):\\
\;\;\;\;\frac{y}{z} \cdot \frac{\frac{x}{z}}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z} \cdot \left(\frac{x}{z} - x\right)\\
\end{array}
\end{array}
if z < -1 or 0.76000000000000001 < z Initial program 85.5%
associate-*l*85.5%
times-frac96.0%
associate-/r*97.4%
associate-*r/99.8%
Simplified99.8%
frac-times91.0%
associate-/r*85.5%
*-commutative85.5%
frac-times95.9%
associate-*l/97.0%
times-frac97.5%
Applied egg-rr97.5%
Taylor expanded in z around inf 96.4%
if -1 < z < 0.76000000000000001Initial program 79.9%
associate-*l*79.9%
times-frac97.4%
associate-/r*97.4%
associate-*r/97.4%
Simplified97.4%
frac-times79.9%
associate-/r*79.9%
*-commutative79.9%
frac-times82.9%
associate-*l/79.9%
times-frac97.4%
Applied egg-rr97.4%
Taylor expanded in z around 0 96.9%
neg-mul-196.9%
+-commutative96.9%
unsub-neg96.9%
Simplified96.9%
Final simplification96.6%
(FPCore (x y z) :precision binary64 (if (<= z -1.0) (* y (/ x (* z (- z)))) (if (<= z 0.62) (* (/ y z) (- (/ x z) x)) (* x (/ y (* z z))))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = y * (x / (z * -z));
} else if (z <= 0.62) {
tmp = (y / z) * ((x / z) - x);
} else {
tmp = x * (y / (z * z));
}
return tmp;
}
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 = y * (x / (z * -z))
else if (z <= 0.62d0) then
tmp = (y / z) * ((x / z) - x)
else
tmp = x * (y / (z * z))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = y * (x / (z * -z));
} else if (z <= 0.62) {
tmp = (y / z) * ((x / z) - x);
} else {
tmp = x * (y / (z * z));
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1.0: tmp = y * (x / (z * -z)) elif z <= 0.62: tmp = (y / z) * ((x / z) - x) else: tmp = x * (y / (z * z)) return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1.0) tmp = Float64(y * Float64(x / Float64(z * Float64(-z)))); elseif (z <= 0.62) tmp = Float64(Float64(y / z) * Float64(Float64(x / z) - x)); else tmp = Float64(x * Float64(y / Float64(z * z))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -1.0) tmp = y * (x / (z * -z)); elseif (z <= 0.62) tmp = (y / z) * ((x / z) - x); else tmp = x * (y / (z * z)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1.0], N[(y * N[(x / N[(z * (-z)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.62], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], N[(x * N[(y / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1:\\
\;\;\;\;y \cdot \frac{x}{z \cdot \left(-z\right)}\\
\mathbf{elif}\;z \leq 0.62:\\
\;\;\;\;\frac{y}{z} \cdot \left(\frac{x}{z} - x\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{y}{z \cdot z}\\
\end{array}
\end{array}
if z < -1Initial program 86.6%
*-commutative86.6%
associate-*r/92.7%
sqr-neg92.7%
associate-*l*92.7%
associate-*l*92.7%
sqr-neg92.7%
associate-*l*92.7%
distribute-lft-in92.7%
fma-def92.7%
*-rgt-identity92.7%
Simplified92.7%
Taylor expanded in z around 0 62.1%
unpow262.1%
Simplified62.1%
associate-*r/59.0%
*-commutative59.0%
times-frac53.0%
clear-num53.0%
frac-2neg53.0%
frac-times57.9%
*-un-lft-identity57.9%
add-sqr-sqrt23.4%
sqrt-unprod56.8%
sqr-neg56.8%
sqrt-unprod36.4%
add-sqr-sqrt63.7%
Applied egg-rr63.7%
associate-*l/68.9%
associate-/l*64.8%
*-rgt-identity64.8%
associate-*r/64.8%
associate-*l*68.0%
associate-*r/68.0%
*-rgt-identity68.0%
Simplified68.0%
if -1 < z < 0.619999999999999996Initial program 79.9%
associate-*l*79.9%
times-frac97.4%
associate-/r*97.4%
associate-*r/97.4%
Simplified97.4%
frac-times79.9%
associate-/r*79.9%
*-commutative79.9%
frac-times82.9%
associate-*l/79.9%
times-frac97.4%
Applied egg-rr97.4%
Taylor expanded in z around 0 96.9%
neg-mul-196.9%
+-commutative96.9%
unsub-neg96.9%
Simplified96.9%
if 0.619999999999999996 < z Initial program 84.3%
*-commutative84.3%
sqr-neg84.3%
times-frac94.8%
sqr-neg94.8%
Simplified94.8%
Taylor expanded in z around 0 66.9%
Final simplification81.6%
(FPCore (x y z) :precision binary64 (if (<= z -1.0) (* (/ y z) (/ (/ x z) z)) (if (<= z 0.75) (* (/ y z) (- (/ x z) x)) (/ (* x (/ y z)) (* z z)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = (y / z) * ((x / z) / z);
} else if (z <= 0.75) {
tmp = (y / z) * ((x / z) - x);
} else {
tmp = (x * (y / z)) / (z * z);
}
return tmp;
}
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 = (y / z) * ((x / z) / z)
else if (z <= 0.75d0) then
tmp = (y / z) * ((x / z) - x)
else
tmp = (x * (y / z)) / (z * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = (y / z) * ((x / z) / z);
} else if (z <= 0.75) {
tmp = (y / z) * ((x / z) - x);
} else {
tmp = (x * (y / z)) / (z * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1.0: tmp = (y / z) * ((x / z) / z) elif z <= 0.75: tmp = (y / z) * ((x / z) - x) else: tmp = (x * (y / z)) / (z * z) return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1.0) tmp = Float64(Float64(y / z) * Float64(Float64(x / z) / z)); elseif (z <= 0.75) tmp = Float64(Float64(y / z) * Float64(Float64(x / z) - x)); else tmp = Float64(Float64(x * Float64(y / z)) / Float64(z * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -1.0) tmp = (y / z) * ((x / z) / z); elseif (z <= 0.75) tmp = (y / z) * ((x / z) - x); else tmp = (x * (y / z)) / (z * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1.0], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.75], N[(N[(y / z), $MachinePrecision] * N[(N[(x / z), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision] / N[(z * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1:\\
\;\;\;\;\frac{y}{z} \cdot \frac{\frac{x}{z}}{z}\\
\mathbf{elif}\;z \leq 0.75:\\
\;\;\;\;\frac{y}{z} \cdot \left(\frac{x}{z} - x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{y}{z}}{z \cdot z}\\
\end{array}
\end{array}
if z < -1Initial program 86.6%
associate-*l*86.7%
times-frac97.0%
associate-/r*98.5%
associate-*r/99.9%
Simplified99.9%
frac-times89.5%
associate-/r*86.6%
*-commutative86.6%
frac-times97.0%
associate-*l/95.6%
times-frac98.3%
Applied egg-rr98.3%
Taylor expanded in z around inf 97.9%
if -1 < z < 0.75Initial program 79.9%
associate-*l*79.9%
times-frac97.4%
associate-/r*97.4%
associate-*r/97.4%
Simplified97.4%
frac-times79.9%
associate-/r*79.9%
*-commutative79.9%
frac-times82.9%
associate-*l/79.9%
times-frac97.4%
Applied egg-rr97.4%
Taylor expanded in z around 0 96.9%
neg-mul-196.9%
+-commutative96.9%
unsub-neg96.9%
Simplified96.9%
if 0.75 < z Initial program 84.3%
associate-*l*84.3%
times-frac95.0%
associate-/r*96.4%
associate-*r/99.8%
Simplified99.8%
frac-times92.5%
associate-/r*84.3%
*-commutative84.3%
frac-times94.8%
associate-*l/98.3%
times-frac96.6%
Applied egg-rr96.6%
Taylor expanded in z around inf 93.5%
unpow293.5%
Simplified93.5%
associate-*r/96.6%
frac-2neg96.6%
distribute-lft-neg-out96.6%
distribute-frac-neg96.6%
*-commutative96.6%
add-sqr-sqrt57.7%
sqrt-unprod69.7%
sqr-neg69.7%
sqrt-unprod24.7%
add-sqr-sqrt65.7%
distribute-rgt-neg-out65.7%
add-sqr-sqrt0.0%
sqrt-unprod81.4%
swap-sqr81.4%
sqr-neg81.4%
sqrt-unprod96.6%
add-sqr-sqrt96.6%
Applied egg-rr96.6%
Final simplification97.1%
(FPCore (x y z) :precision binary64 (if (<= x -3.15e+19) (* x (/ y (* z z))) (if (<= x -5e-301) (* (/ x z) (/ y z)) (/ y (* z (/ z x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -3.15e+19) {
tmp = x * (y / (z * z));
} else if (x <= -5e-301) {
tmp = (x / z) * (y / z);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
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 (x <= (-3.15d+19)) then
tmp = x * (y / (z * z))
else if (x <= (-5d-301)) then
tmp = (x / z) * (y / z)
else
tmp = y / (z * (z / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -3.15e+19) {
tmp = x * (y / (z * z));
} else if (x <= -5e-301) {
tmp = (x / z) * (y / z);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -3.15e+19: tmp = x * (y / (z * z)) elif x <= -5e-301: tmp = (x / z) * (y / z) else: tmp = y / (z * (z / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -3.15e+19) tmp = Float64(x * Float64(y / Float64(z * z))); elseif (x <= -5e-301) tmp = Float64(Float64(x / z) * Float64(y / z)); else tmp = Float64(y / Float64(z * Float64(z / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -3.15e+19) tmp = x * (y / (z * z)); elseif (x <= -5e-301) tmp = (x / z) * (y / z); else tmp = y / (z * (z / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -3.15e+19], N[(x * N[(y / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -5e-301], N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(y / N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.15 \cdot 10^{+19}:\\
\;\;\;\;x \cdot \frac{y}{z \cdot z}\\
\mathbf{elif}\;x \leq -5 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot \frac{z}{x}}\\
\end{array}
\end{array}
if x < -3.15e19Initial program 87.7%
*-commutative87.7%
sqr-neg87.7%
times-frac96.6%
sqr-neg96.6%
Simplified96.6%
Taylor expanded in z around 0 78.5%
if -3.15e19 < x < -5.00000000000000013e-301Initial program 81.5%
associate-*l*81.4%
times-frac99.7%
associate-/r*99.8%
associate-*r/99.8%
Simplified99.8%
frac-times82.7%
associate-/r*81.5%
*-commutative81.5%
frac-times87.5%
associate-*l/82.8%
times-frac96.7%
Applied egg-rr96.7%
Taylor expanded in z around 0 87.5%
if -5.00000000000000013e-301 < x Initial program 81.1%
*-commutative81.1%
associate-*r/82.4%
sqr-neg82.4%
associate-*l*82.4%
associate-*l*82.4%
sqr-neg82.4%
associate-*l*82.4%
distribute-lft-in82.4%
fma-def82.4%
*-rgt-identity82.4%
Simplified82.4%
Taylor expanded in z around 0 66.6%
unpow266.6%
Simplified66.6%
associate-*r/66.1%
*-commutative66.1%
times-frac70.6%
clear-num70.7%
frac-times73.6%
*-un-lft-identity73.6%
Applied egg-rr73.6%
Final simplification78.5%
(FPCore (x y z) :precision binary64 (if (<= x -2200000000.0) (* x (/ y (* z z))) (if (<= x -7e-301) (/ (/ y z) (/ z x)) (/ y (* z (/ z x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -2200000000.0) {
tmp = x * (y / (z * z));
} else if (x <= -7e-301) {
tmp = (y / z) / (z / x);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
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 (x <= (-2200000000.0d0)) then
tmp = x * (y / (z * z))
else if (x <= (-7d-301)) then
tmp = (y / z) / (z / x)
else
tmp = y / (z * (z / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -2200000000.0) {
tmp = x * (y / (z * z));
} else if (x <= -7e-301) {
tmp = (y / z) / (z / x);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -2200000000.0: tmp = x * (y / (z * z)) elif x <= -7e-301: tmp = (y / z) / (z / x) else: tmp = y / (z * (z / x)) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -2200000000.0) tmp = Float64(x * Float64(y / Float64(z * z))); elseif (x <= -7e-301) tmp = Float64(Float64(y / z) / Float64(z / x)); else tmp = Float64(y / Float64(z * Float64(z / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -2200000000.0) tmp = x * (y / (z * z)); elseif (x <= -7e-301) tmp = (y / z) / (z / x); else tmp = y / (z * (z / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -2200000000.0], N[(x * N[(y / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7e-301], N[(N[(y / z), $MachinePrecision] / N[(z / x), $MachinePrecision]), $MachinePrecision], N[(y / N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2200000000:\\
\;\;\;\;x \cdot \frac{y}{z \cdot z}\\
\mathbf{elif}\;x \leq -7 \cdot 10^{-301}:\\
\;\;\;\;\frac{\frac{y}{z}}{\frac{z}{x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot \frac{z}{x}}\\
\end{array}
\end{array}
if x < -2.2e9Initial program 87.9%
*-commutative87.9%
sqr-neg87.9%
times-frac96.7%
sqr-neg96.7%
Simplified96.7%
Taylor expanded in z around 0 77.4%
if -2.2e9 < x < -6.99999999999999984e-301Initial program 81.2%
*-commutative81.2%
associate-*r/82.8%
sqr-neg82.8%
associate-*l*82.8%
associate-*l*82.8%
sqr-neg82.8%
associate-*l*82.8%
distribute-lft-in82.8%
fma-def82.8%
*-rgt-identity82.8%
Simplified82.8%
Taylor expanded in z around 0 78.8%
unpow278.8%
Simplified78.8%
associate-*r/73.0%
frac-times88.7%
clear-num88.6%
un-div-inv88.7%
Applied egg-rr88.7%
if -6.99999999999999984e-301 < x Initial program 81.1%
*-commutative81.1%
associate-*r/82.4%
sqr-neg82.4%
associate-*l*82.4%
associate-*l*82.4%
sqr-neg82.4%
associate-*l*82.4%
distribute-lft-in82.4%
fma-def82.4%
*-rgt-identity82.4%
Simplified82.4%
Taylor expanded in z around 0 66.6%
unpow266.6%
Simplified66.6%
associate-*r/66.1%
*-commutative66.1%
times-frac70.6%
clear-num70.7%
frac-times73.6%
*-un-lft-identity73.6%
Applied egg-rr73.6%
Final simplification78.5%
(FPCore (x y z) :precision binary64 (if (<= z -1.0) (* y (/ x (* z (- z)))) (if (<= z 2.55e-144) (/ (/ y z) (/ z x)) (/ y (* z (/ z x))))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = y * (x / (z * -z));
} else if (z <= 2.55e-144) {
tmp = (y / z) / (z / x);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
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 = y * (x / (z * -z))
else if (z <= 2.55d-144) then
tmp = (y / z) / (z / x)
else
tmp = y / (z * (z / x))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -1.0) {
tmp = y * (x / (z * -z));
} else if (z <= 2.55e-144) {
tmp = (y / z) / (z / x);
} else {
tmp = y / (z * (z / x));
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1.0: tmp = y * (x / (z * -z)) elif z <= 2.55e-144: tmp = (y / z) / (z / x) else: tmp = y / (z * (z / x)) return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1.0) tmp = Float64(y * Float64(x / Float64(z * Float64(-z)))); elseif (z <= 2.55e-144) tmp = Float64(Float64(y / z) / Float64(z / x)); else tmp = Float64(y / Float64(z * Float64(z / x))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -1.0) tmp = y * (x / (z * -z)); elseif (z <= 2.55e-144) tmp = (y / z) / (z / x); else tmp = y / (z * (z / x)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1.0], N[(y * N[(x / N[(z * (-z)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.55e-144], N[(N[(y / z), $MachinePrecision] / N[(z / x), $MachinePrecision]), $MachinePrecision], N[(y / N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1:\\
\;\;\;\;y \cdot \frac{x}{z \cdot \left(-z\right)}\\
\mathbf{elif}\;z \leq 2.55 \cdot 10^{-144}:\\
\;\;\;\;\frac{\frac{y}{z}}{\frac{z}{x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot \frac{z}{x}}\\
\end{array}
\end{array}
if z < -1Initial program 86.6%
*-commutative86.6%
associate-*r/92.7%
sqr-neg92.7%
associate-*l*92.7%
associate-*l*92.7%
sqr-neg92.7%
associate-*l*92.7%
distribute-lft-in92.7%
fma-def92.7%
*-rgt-identity92.7%
Simplified92.7%
Taylor expanded in z around 0 62.1%
unpow262.1%
Simplified62.1%
associate-*r/59.0%
*-commutative59.0%
times-frac53.0%
clear-num53.0%
frac-2neg53.0%
frac-times57.9%
*-un-lft-identity57.9%
add-sqr-sqrt23.4%
sqrt-unprod56.8%
sqr-neg56.8%
sqrt-unprod36.4%
add-sqr-sqrt63.7%
Applied egg-rr63.7%
associate-*l/68.9%
associate-/l*64.8%
*-rgt-identity64.8%
associate-*r/64.8%
associate-*l*68.0%
associate-*r/68.0%
*-rgt-identity68.0%
Simplified68.0%
if -1 < z < 2.55e-144Initial program 78.2%
*-commutative78.2%
associate-*r/77.9%
sqr-neg77.9%
associate-*l*77.9%
associate-*l*77.9%
sqr-neg77.9%
associate-*l*77.9%
distribute-lft-in77.9%
fma-def77.9%
*-rgt-identity77.9%
Simplified77.9%
Taylor expanded in z around 0 76.6%
unpow276.6%
Simplified76.6%
associate-*r/76.9%
frac-times96.4%
clear-num96.4%
un-div-inv96.4%
Applied egg-rr96.4%
if 2.55e-144 < z Initial program 84.8%
*-commutative84.8%
associate-*r/86.8%
sqr-neg86.8%
associate-*l*86.8%
associate-*l*86.8%
sqr-neg86.8%
associate-*l*86.8%
distribute-lft-in86.8%
fma-def86.8%
*-rgt-identity86.8%
Simplified86.8%
Taylor expanded in z around 0 72.6%
unpow272.6%
Simplified72.6%
associate-*r/69.6%
*-commutative69.6%
times-frac68.7%
clear-num68.7%
frac-times72.6%
*-un-lft-identity72.6%
Applied egg-rr72.6%
Final simplification80.3%
(FPCore (x y z) :precision binary64 (* (/ y z) (/ (/ x (+ z 1.0)) z)))
double code(double x, double y, double z) {
return (y / z) * ((x / (z + 1.0)) / z);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (y / z) * ((x / (z + 1.0d0)) / z)
end function
public static double code(double x, double y, double z) {
return (y / z) * ((x / (z + 1.0)) / z);
}
def code(x, y, z): return (y / z) * ((x / (z + 1.0)) / z)
function code(x, y, z) return Float64(Float64(y / z) * Float64(Float64(x / Float64(z + 1.0)) / z)) end
function tmp = code(x, y, z) tmp = (y / z) * ((x / (z + 1.0)) / z); end
code[x_, y_, z_] := N[(N[(y / z), $MachinePrecision] * N[(N[(x / N[(z + 1.0), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{y}{z} \cdot \frac{\frac{x}{z + 1}}{z}
\end{array}
Initial program 82.8%
associate-*l*82.8%
times-frac96.7%
associate-/r*97.4%
associate-*r/98.7%
Simplified98.7%
frac-times85.7%
associate-/r*82.8%
*-commutative82.8%
frac-times89.6%
associate-*l/88.8%
times-frac97.4%
Applied egg-rr97.4%
Final simplification97.4%
(FPCore (x y z) :precision binary64 (if (or (<= z -1.0) (not (<= z -2e-310))) (/ x (/ z y)) (* (/ y z) (- x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= -2e-310)) {
tmp = x / (z / y);
} else {
tmp = (y / z) * -x;
}
return tmp;
}
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)) .or. (.not. (z <= (-2d-310)))) then
tmp = x / (z / y)
else
tmp = (y / z) * -x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -1.0) || !(z <= -2e-310)) {
tmp = x / (z / y);
} else {
tmp = (y / z) * -x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -1.0) or not (z <= -2e-310): tmp = x / (z / y) else: tmp = (y / z) * -x return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -1.0) || !(z <= -2e-310)) tmp = Float64(x / Float64(z / y)); else tmp = Float64(Float64(y / z) * Float64(-x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -1.0) || ~((z <= -2e-310))) tmp = x / (z / y); else tmp = (y / z) * -x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, -2e-310]], $MachinePrecision]], N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision], N[(N[(y / z), $MachinePrecision] * (-x)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1 \lor \neg \left(z \leq -2 \cdot 10^{-310}\right):\\
\;\;\;\;\frac{x}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z} \cdot \left(-x\right)\\
\end{array}
\end{array}
if z < -1 or -1.999999999999994e-310 < z Initial program 82.7%
associate-*l*82.7%
times-frac96.1%
associate-/r*97.2%
associate-*r/98.8%
Simplified98.8%
Taylor expanded in z around 0 37.5%
*-commutative37.5%
unpow237.5%
times-frac43.6%
associate-*r/43.6%
*-commutative43.6%
neg-mul-143.6%
distribute-rgt-neg-out43.6%
associate-*l/44.5%
distribute-lft-out54.5%
Simplified54.5%
Taylor expanded in z around inf 23.7%
mul-1-neg23.7%
associate-*l/27.9%
*-commutative27.9%
distribute-rgt-neg-in27.9%
distribute-neg-frac27.9%
Simplified27.9%
add-sqr-sqrt14.4%
sqrt-unprod35.7%
sqr-neg35.7%
sqrt-unprod21.0%
add-sqr-sqrt41.7%
clear-num42.7%
div-inv42.7%
Applied egg-rr42.7%
if -1 < z < -1.999999999999994e-310Initial program 83.2%
associate-*l*83.2%
times-frac98.2%
associate-/r*98.2%
associate-*r/98.2%
Simplified98.2%
Taylor expanded in z around 0 82.7%
*-commutative82.7%
unpow282.7%
times-frac97.7%
associate-*r/97.7%
*-commutative97.7%
neg-mul-197.7%
distribute-rgt-neg-out97.7%
associate-*l/97.7%
distribute-lft-out97.7%
Simplified97.7%
Taylor expanded in z around inf 30.6%
mul-1-neg30.6%
associate-*l/36.3%
*-commutative36.3%
distribute-rgt-neg-in36.3%
distribute-neg-frac36.3%
Simplified36.3%
Final simplification41.0%
(FPCore (x y z) :precision binary64 (if (<= y 4.2e+87) (* (/ x z) (/ y z)) (* y (/ x (* z z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= 4.2e+87) {
tmp = (x / z) * (y / z);
} else {
tmp = y * (x / (z * z));
}
return tmp;
}
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 (y <= 4.2d+87) then
tmp = (x / z) * (y / z)
else
tmp = y * (x / (z * z))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 4.2e+87) {
tmp = (x / z) * (y / z);
} else {
tmp = y * (x / (z * z));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 4.2e+87: tmp = (x / z) * (y / z) else: tmp = y * (x / (z * z)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 4.2e+87) tmp = Float64(Float64(x / z) * Float64(y / z)); else tmp = Float64(y * Float64(x / Float64(z * z))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 4.2e+87) tmp = (x / z) * (y / z); else tmp = y * (x / (z * z)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 4.2e+87], N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(y * N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.2 \cdot 10^{+87}:\\
\;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{x}{z \cdot z}\\
\end{array}
\end{array}
if y < 4.2e87Initial program 83.4%
associate-*l*83.4%
times-frac97.3%
associate-/r*97.8%
associate-*r/99.3%
Simplified99.3%
frac-times85.9%
associate-/r*83.4%
*-commutative83.4%
frac-times88.8%
associate-*l/87.8%
times-frac98.3%
Applied egg-rr98.3%
Taylor expanded in z around 0 77.8%
if 4.2e87 < y Initial program 80.0%
*-commutative80.0%
associate-*r/84.8%
sqr-neg84.8%
associate-*l*84.9%
associate-*l*84.8%
sqr-neg84.8%
associate-*l*84.9%
distribute-lft-in84.9%
fma-def84.9%
*-rgt-identity84.9%
Simplified84.9%
Taylor expanded in z around 0 76.0%
unpow276.0%
Simplified76.0%
Final simplification77.5%
(FPCore (x y z) :precision binary64 (* y (/ x (* z z))))
double code(double x, double y, double z) {
return y * (x / (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 = y * (x / (z * z))
end function
public static double code(double x, double y, double z) {
return y * (x / (z * z));
}
def code(x, y, z): return y * (x / (z * z))
function code(x, y, z) return Float64(y * Float64(x / Float64(z * z))) end
function tmp = code(x, y, z) tmp = y * (x / (z * z)); end
code[x_, y_, z_] := N[(y * N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
y \cdot \frac{x}{z \cdot z}
\end{array}
Initial program 82.8%
*-commutative82.8%
associate-*r/85.0%
sqr-neg85.0%
associate-*l*85.0%
associate-*l*85.0%
sqr-neg85.0%
associate-*l*85.0%
distribute-lft-in85.0%
fma-def85.0%
*-rgt-identity85.0%
Simplified85.0%
Taylor expanded in z around 0 71.4%
unpow271.4%
Simplified71.4%
Final simplification71.4%
(FPCore (x y z) :precision binary64 (* (/ x z) y))
double code(double x, double y, double z) {
return (x / z) * y;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x / z) * y
end function
public static double code(double x, double y, double z) {
return (x / z) * y;
}
def code(x, y, z): return (x / z) * y
function code(x, y, z) return Float64(Float64(x / z) * y) end
function tmp = code(x, y, z) tmp = (x / z) * y; end
code[x_, y_, z_] := N[(N[(x / z), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{z} \cdot y
\end{array}
Initial program 82.8%
associate-*l*82.8%
times-frac96.7%
associate-/r*97.4%
associate-*r/98.7%
Simplified98.7%
Taylor expanded in z around 0 49.2%
*-commutative49.2%
unpow249.2%
times-frac57.6%
associate-*r/57.6%
*-commutative57.6%
neg-mul-157.6%
distribute-rgt-neg-out57.6%
associate-*l/58.2%
distribute-lft-out65.6%
Simplified65.6%
Taylor expanded in z around inf 25.4%
mul-1-neg25.4%
associate-*l/30.1%
*-commutative30.1%
distribute-rgt-neg-in30.1%
distribute-neg-frac30.1%
Simplified30.1%
expm1-log1p-u27.5%
expm1-udef39.7%
add-sqr-sqrt19.7%
sqrt-unprod38.4%
sqr-neg38.4%
sqrt-unprod20.7%
add-sqr-sqrt41.1%
Applied egg-rr41.1%
expm1-def28.9%
expm1-log1p32.4%
associate-*r/27.7%
associate-*l/31.3%
*-commutative31.3%
Simplified31.3%
Final simplification31.3%
(FPCore (x y z) :precision binary64 (/ x (/ z y)))
double code(double x, double y, double z) {
return x / (z / y);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x / (z / y)
end function
public static double code(double x, double y, double z) {
return x / (z / y);
}
def code(x, y, z): return x / (z / y)
function code(x, y, z) return Float64(x / Float64(z / y)) end
function tmp = code(x, y, z) tmp = x / (z / y); end
code[x_, y_, z_] := N[(x / N[(z / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{\frac{z}{y}}
\end{array}
Initial program 82.8%
associate-*l*82.8%
times-frac96.7%
associate-/r*97.4%
associate-*r/98.7%
Simplified98.7%
Taylor expanded in z around 0 49.2%
*-commutative49.2%
unpow249.2%
times-frac57.6%
associate-*r/57.6%
*-commutative57.6%
neg-mul-157.6%
distribute-rgt-neg-out57.6%
associate-*l/58.2%
distribute-lft-out65.6%
Simplified65.6%
Taylor expanded in z around inf 25.4%
mul-1-neg25.4%
associate-*l/30.1%
*-commutative30.1%
distribute-rgt-neg-in30.1%
distribute-neg-frac30.1%
Simplified30.1%
add-sqr-sqrt14.8%
sqrt-unprod31.9%
sqr-neg31.9%
sqrt-unprod16.9%
add-sqr-sqrt32.4%
clear-num33.1%
div-inv33.1%
Applied egg-rr33.1%
Final simplification33.1%
(FPCore (x y z) :precision binary64 (if (< z 249.6182814532307) (/ (* y (/ x z)) (+ z (* z z))) (/ (* (/ (/ y z) (+ 1.0 z)) x) z)))
double code(double x, double y, double z) {
double tmp;
if (z < 249.6182814532307) {
tmp = (y * (x / z)) / (z + (z * z));
} else {
tmp = (((y / z) / (1.0 + z)) * x) / z;
}
return tmp;
}
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 < 249.6182814532307d0) then
tmp = (y * (x / z)) / (z + (z * z))
else
tmp = (((y / z) / (1.0d0 + z)) * x) / z
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z < 249.6182814532307) {
tmp = (y * (x / z)) / (z + (z * z));
} else {
tmp = (((y / z) / (1.0 + z)) * x) / z;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z < 249.6182814532307: tmp = (y * (x / z)) / (z + (z * z)) else: tmp = (((y / z) / (1.0 + z)) * x) / z return tmp
function code(x, y, z) tmp = 0.0 if (z < 249.6182814532307) tmp = Float64(Float64(y * Float64(x / z)) / Float64(z + Float64(z * z))); else tmp = Float64(Float64(Float64(Float64(y / z) / Float64(1.0 + z)) * x) / z); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z < 249.6182814532307) tmp = (y * (x / z)) / (z + (z * z)); else tmp = (((y / z) / (1.0 + z)) * x) / z; end tmp_2 = tmp; end
code[x_, y_, z_] := If[Less[z, 249.6182814532307], N[(N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision] / N[(z + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(y / z), $MachinePrecision] / N[(1.0 + z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] / z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z < 249.6182814532307:\\
\;\;\;\;\frac{y \cdot \frac{x}{z}}{z + z \cdot z}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{y}{z}}{1 + z} \cdot x}{z}\\
\end{array}
\end{array}
herbie shell --seed 2023268
(FPCore (x y z)
:name "Statistics.Distribution.Beta:$cvariance from math-functions-0.1.5.2"
:precision binary64
:herbie-target
(if (< z 249.6182814532307) (/ (* y (/ x z)) (+ z (* z z))) (/ (* (/ (/ y z) (+ 1.0 z)) x) z))
(/ (* x y) (* (* z z) (+ z 1.0))))