
(FPCore (x y z) :precision binary64 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))
double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.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 * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function
public static double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
def code(x, y, z): return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) end
function tmp = code(x, y, z) tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); end
code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))
double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.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 * x) + (y * y)) - (z * z)) / (y * 2.0d0)
end function
public static double code(double x, double y, double z) {
return (((x * x) + (y * y)) - (z * z)) / (y * 2.0);
}
def code(x, y, z): return (((x * x) + (y * y)) - (z * z)) / (y * 2.0)
function code(x, y, z) return Float64(Float64(Float64(Float64(x * x) + Float64(y * y)) - Float64(z * z)) / Float64(y * 2.0)) end
function tmp = code(x, y, z) tmp = (((x * x) + (y * y)) - (z * z)) / (y * 2.0); end
code[x_, y_, z_] := N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z * z), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot x + y \cdot y\right) - z \cdot z}{y \cdot 2}
\end{array}
(FPCore (x y z) :precision binary64 (/ (+ y (* (+ z x) (/ (- x z) y))) 2.0))
double code(double x, double y, double z) {
return (y + ((z + x) * ((x - z) / y))) / 2.0;
}
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) * ((x - z) / y))) / 2.0d0
end function
public static double code(double x, double y, double z) {
return (y + ((z + x) * ((x - z) / y))) / 2.0;
}
def code(x, y, z): return (y + ((z + x) * ((x - z) / y))) / 2.0
function code(x, y, z) return Float64(Float64(y + Float64(Float64(z + x) * Float64(Float64(x - z) / y))) / 2.0) end
function tmp = code(x, y, z) tmp = (y + ((z + x) * ((x - z) / y))) / 2.0; end
code[x_, y_, z_] := N[(N[(y + N[(N[(z + x), $MachinePrecision] * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{y + \left(z + x\right) \cdot \frac{x - z}{y}}{2}
\end{array}
Initial program 66.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.8%
Simplified85.8%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (* x (/ 0.5 y)))))
(if (<= z 2.8e-264)
t_0
(if (<= z 1.16e-41)
(/ y 2.0)
(if (<= z 3.8e+56) t_0 (* z (/ z (/ y -0.5))))))))
double code(double x, double y, double z) {
double t_0 = x * (x * (0.5 / y));
double tmp;
if (z <= 2.8e-264) {
tmp = t_0;
} else if (z <= 1.16e-41) {
tmp = y / 2.0;
} else if (z <= 3.8e+56) {
tmp = t_0;
} else {
tmp = z * (z / (y / -0.5));
}
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) :: t_0
real(8) :: tmp
t_0 = x * (x * (0.5d0 / y))
if (z <= 2.8d-264) then
tmp = t_0
else if (z <= 1.16d-41) then
tmp = y / 2.0d0
else if (z <= 3.8d+56) then
tmp = t_0
else
tmp = z * (z / (y / (-0.5d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (x * (0.5 / y));
double tmp;
if (z <= 2.8e-264) {
tmp = t_0;
} else if (z <= 1.16e-41) {
tmp = y / 2.0;
} else if (z <= 3.8e+56) {
tmp = t_0;
} else {
tmp = z * (z / (y / -0.5));
}
return tmp;
}
def code(x, y, z): t_0 = x * (x * (0.5 / y)) tmp = 0 if z <= 2.8e-264: tmp = t_0 elif z <= 1.16e-41: tmp = y / 2.0 elif z <= 3.8e+56: tmp = t_0 else: tmp = z * (z / (y / -0.5)) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(x * Float64(0.5 / y))) tmp = 0.0 if (z <= 2.8e-264) tmp = t_0; elseif (z <= 1.16e-41) tmp = Float64(y / 2.0); elseif (z <= 3.8e+56) tmp = t_0; else tmp = Float64(z * Float64(z / Float64(y / -0.5))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (x * (0.5 / y)); tmp = 0.0; if (z <= 2.8e-264) tmp = t_0; elseif (z <= 1.16e-41) tmp = y / 2.0; elseif (z <= 3.8e+56) tmp = t_0; else tmp = z * (z / (y / -0.5)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(x * N[(0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, 2.8e-264], t$95$0, If[LessEqual[z, 1.16e-41], N[(y / 2.0), $MachinePrecision], If[LessEqual[z, 3.8e+56], t$95$0, N[(z * N[(z / N[(y / -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot \frac{0.5}{y}\right)\\
\mathbf{if}\;z \leq 2.8 \cdot 10^{-264}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 1.16 \cdot 10^{-41}:\\
\;\;\;\;\frac{y}{2}\\
\mathbf{elif}\;z \leq 3.8 \cdot 10^{+56}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;z \cdot \frac{z}{\frac{y}{-0.5}}\\
\end{array}
\end{array}
if z < 2.80000000000000012e-264 or 1.1600000000000001e-41 < z < 3.79999999999999996e56Initial program 68.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.3%
Simplified87.3%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.4%
Applied egg-rr99.4%
*-commutativeN/A
associate-/r/N/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.4%
Applied egg-rr99.4%
Taylor expanded in z around 0
/-lowering-/.f6479.8%
Simplified79.8%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6439.5%
Simplified39.5%
if 2.80000000000000012e-264 < z < 1.1600000000000001e-41Initial program 62.3%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6495.3%
Simplified95.3%
Taylor expanded in y around inf
Simplified58.2%
if 3.79999999999999996e56 < z Initial program 65.2%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.7%
Simplified69.7%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.9%
Applied egg-rr99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l*N/A
associate-*r/N/A
distribute-lft-inN/A
associate-*r*N/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r/N/A
Simplified71.1%
*-commutativeN/A
*-lowering-*.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6471.1%
Applied egg-rr71.1%
Final simplification48.9%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (* x (/ 0.5 y)))))
(if (<= z 2.9e-264)
t_0
(if (<= z 3e-42)
(/ y 2.0)
(if (<= z 7.3e+56) t_0 (* z (* z (/ -0.5 y))))))))
double code(double x, double y, double z) {
double t_0 = x * (x * (0.5 / y));
double tmp;
if (z <= 2.9e-264) {
tmp = t_0;
} else if (z <= 3e-42) {
tmp = y / 2.0;
} else if (z <= 7.3e+56) {
tmp = t_0;
} else {
tmp = z * (z * (-0.5 / y));
}
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) :: t_0
real(8) :: tmp
t_0 = x * (x * (0.5d0 / y))
if (z <= 2.9d-264) then
tmp = t_0
else if (z <= 3d-42) then
tmp = y / 2.0d0
else if (z <= 7.3d+56) then
tmp = t_0
else
tmp = z * (z * ((-0.5d0) / y))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (x * (0.5 / y));
double tmp;
if (z <= 2.9e-264) {
tmp = t_0;
} else if (z <= 3e-42) {
tmp = y / 2.0;
} else if (z <= 7.3e+56) {
tmp = t_0;
} else {
tmp = z * (z * (-0.5 / y));
}
return tmp;
}
def code(x, y, z): t_0 = x * (x * (0.5 / y)) tmp = 0 if z <= 2.9e-264: tmp = t_0 elif z <= 3e-42: tmp = y / 2.0 elif z <= 7.3e+56: tmp = t_0 else: tmp = z * (z * (-0.5 / y)) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(x * Float64(0.5 / y))) tmp = 0.0 if (z <= 2.9e-264) tmp = t_0; elseif (z <= 3e-42) tmp = Float64(y / 2.0); elseif (z <= 7.3e+56) tmp = t_0; else tmp = Float64(z * Float64(z * Float64(-0.5 / y))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (x * (0.5 / y)); tmp = 0.0; if (z <= 2.9e-264) tmp = t_0; elseif (z <= 3e-42) tmp = y / 2.0; elseif (z <= 7.3e+56) tmp = t_0; else tmp = z * (z * (-0.5 / y)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(x * N[(0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, 2.9e-264], t$95$0, If[LessEqual[z, 3e-42], N[(y / 2.0), $MachinePrecision], If[LessEqual[z, 7.3e+56], t$95$0, N[(z * N[(z * N[(-0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot \frac{0.5}{y}\right)\\
\mathbf{if}\;z \leq 2.9 \cdot 10^{-264}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 3 \cdot 10^{-42}:\\
\;\;\;\;\frac{y}{2}\\
\mathbf{elif}\;z \leq 7.3 \cdot 10^{+56}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(z \cdot \frac{-0.5}{y}\right)\\
\end{array}
\end{array}
if z < 2.8999999999999999e-264 or 3.00000000000000027e-42 < z < 7.3e56Initial program 68.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.3%
Simplified87.3%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.4%
Applied egg-rr99.4%
*-commutativeN/A
associate-/r/N/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.4%
Applied egg-rr99.4%
Taylor expanded in z around 0
/-lowering-/.f6479.8%
Simplified79.8%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6439.5%
Simplified39.5%
if 2.8999999999999999e-264 < z < 3.00000000000000027e-42Initial program 62.3%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6495.3%
Simplified95.3%
Taylor expanded in y around inf
Simplified58.2%
if 7.3e56 < z Initial program 65.2%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.7%
Simplified69.7%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.9%
Applied egg-rr99.9%
Taylor expanded in z around inf
unpow2N/A
associate-*l*N/A
associate-*r/N/A
distribute-lft-inN/A
associate-*r*N/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r/N/A
Simplified71.1%
(FPCore (x y z) :precision binary64 (if (<= (* z z) 2e+65) (/ (+ y (/ x (/ y x))) 2.0) (/ (* (+ z x) (/ (- x z) y)) 2.0)))
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+65) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = ((z + x) * ((x - z) / y)) / 2.0;
}
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 * z) <= 2d+65) then
tmp = (y + (x / (y / x))) / 2.0d0
else
tmp = ((z + x) * ((x - z) / y)) / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+65) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = ((z + x) * ((x - z) / y)) / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z * z) <= 2e+65: tmp = (y + (x / (y / x))) / 2.0 else: tmp = ((z + x) * ((x - z) / y)) / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e+65) tmp = Float64(Float64(y + Float64(x / Float64(y / x))) / 2.0); else tmp = Float64(Float64(Float64(z + x) * Float64(Float64(x - z) / y)) / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z * z) <= 2e+65) tmp = (y + (x / (y / x))) / 2.0; else tmp = ((z + x) * ((x - z) / y)) / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e+65], N[(N[(y + N[(x / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(z + x), $MachinePrecision] * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{+65}:\\
\;\;\;\;\frac{y + \frac{x}{\frac{y}{x}}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(z + x\right) \cdot \frac{x - z}{y}}{2}\\
\end{array}
\end{array}
if (*.f64 z z) < 2e65Initial program 65.4%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.5%
Simplified92.5%
Taylor expanded in z around 0
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6486.6%
Simplified86.6%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6492.4%
Applied egg-rr92.4%
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
remove-double-divN/A
times-fracN/A
metadata-evalN/A
associate-/r/N/A
remove-double-divN/A
/-lowering-/.f64N/A
*-commutativeN/A
div-invN/A
/-lowering-/.f6492.4%
Applied egg-rr92.4%
if 2e65 < (*.f64 z z) Initial program 69.4%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.6%
Simplified74.6%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6483.4%
Simplified83.4%
Final simplification89.0%
(FPCore (x y z) :precision binary64 (if (<= (* z z) 5e+106) (/ (+ y (/ x (/ y x))) 2.0) (/ (- y (* z (/ z y))) 2.0)))
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 5e+106) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = (y - (z * (z / y))) / 2.0;
}
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 * z) <= 5d+106) then
tmp = (y + (x / (y / x))) / 2.0d0
else
tmp = (y - (z * (z / y))) / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 5e+106) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = (y - (z * (z / y))) / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z * z) <= 5e+106: tmp = (y + (x / (y / x))) / 2.0 else: tmp = (y - (z * (z / y))) / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 5e+106) tmp = Float64(Float64(y + Float64(x / Float64(y / x))) / 2.0); else tmp = Float64(Float64(y - Float64(z * Float64(z / y))) / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z * z) <= 5e+106) tmp = (y + (x / (y / x))) / 2.0; else tmp = (y - (z * (z / y))) / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 5e+106], N[(N[(y + N[(x / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(y - N[(z * N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 5 \cdot 10^{+106}:\\
\;\;\;\;\frac{y + \frac{x}{\frac{y}{x}}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{y - z \cdot \frac{z}{y}}{2}\\
\end{array}
\end{array}
if (*.f64 z z) < 4.9999999999999998e106Initial program 66.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6493.0%
Simplified93.0%
Taylor expanded in z around 0
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6486.1%
Simplified86.1%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6491.6%
Applied egg-rr91.6%
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
remove-double-divN/A
times-fracN/A
metadata-evalN/A
associate-/r/N/A
remove-double-divN/A
/-lowering-/.f64N/A
*-commutativeN/A
div-invN/A
/-lowering-/.f6491.6%
Applied egg-rr91.6%
if 4.9999999999999998e106 < (*.f64 z z) Initial program 66.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.7%
Simplified71.7%
Taylor expanded in x around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6470.5%
Simplified70.5%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6480.7%
Applied egg-rr80.7%
Final simplification87.9%
(FPCore (x y z) :precision binary64 (if (<= (* z z) 2e+126) (/ (+ y (/ x (/ y x))) 2.0) (/ (* z (/ (- x z) y)) 2.0)))
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+126) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = (z * ((x - z) / y)) / 2.0;
}
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 * z) <= 2d+126) then
tmp = (y + (x / (y / x))) / 2.0d0
else
tmp = (z * ((x - z) / y)) / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+126) {
tmp = (y + (x / (y / x))) / 2.0;
} else {
tmp = (z * ((x - z) / y)) / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z * z) <= 2e+126: tmp = (y + (x / (y / x))) / 2.0 else: tmp = (z * ((x - z) / y)) / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e+126) tmp = Float64(Float64(y + Float64(x / Float64(y / x))) / 2.0); else tmp = Float64(Float64(z * Float64(Float64(x - z) / y)) / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z * z) <= 2e+126) tmp = (y + (x / (y / x))) / 2.0; else tmp = (z * ((x - z) / y)) / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e+126], N[(N[(y + N[(x / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{+126}:\\
\;\;\;\;\frac{y + \frac{x}{\frac{y}{x}}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{z \cdot \frac{x - z}{y}}{2}\\
\end{array}
\end{array}
if (*.f64 z z) < 1.99999999999999985e126Initial program 67.1%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in z around 0
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6484.7%
Simplified84.7%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6490.6%
Applied egg-rr90.6%
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
remove-double-divN/A
times-fracN/A
metadata-evalN/A
associate-/r/N/A
remove-double-divN/A
/-lowering-/.f64N/A
*-commutativeN/A
div-invN/A
/-lowering-/.f6490.7%
Applied egg-rr90.7%
if 1.99999999999999985e126 < (*.f64 z z) Initial program 66.5%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.5%
Simplified71.5%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6485.4%
Simplified85.4%
Taylor expanded in x around 0
Simplified72.5%
Final simplification84.8%
(FPCore (x y z) :precision binary64 (if (<= (* z z) 2e+126) (/ (+ y (* x (/ x y))) 2.0) (/ (* z (/ (- x z) y)) 2.0)))
double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+126) {
tmp = (y + (x * (x / y))) / 2.0;
} else {
tmp = (z * ((x - z) / y)) / 2.0;
}
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 * z) <= 2d+126) then
tmp = (y + (x * (x / y))) / 2.0d0
else
tmp = (z * ((x - z) / y)) / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z * z) <= 2e+126) {
tmp = (y + (x * (x / y))) / 2.0;
} else {
tmp = (z * ((x - z) / y)) / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z * z) <= 2e+126: tmp = (y + (x * (x / y))) / 2.0 else: tmp = (z * ((x - z) / y)) / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (Float64(z * z) <= 2e+126) tmp = Float64(Float64(y + Float64(x * Float64(x / y))) / 2.0); else tmp = Float64(Float64(z * Float64(Float64(x - z) / y)) / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z * z) <= 2e+126) tmp = (y + (x * (x / y))) / 2.0; else tmp = (z * ((x - z) / y)) / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[(z * z), $MachinePrecision], 2e+126], N[(N[(y + N[(x * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot z \leq 2 \cdot 10^{+126}:\\
\;\;\;\;\frac{y + x \cdot \frac{x}{y}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{z \cdot \frac{x - z}{y}}{2}\\
\end{array}
\end{array}
if (*.f64 z z) < 1.99999999999999985e126Initial program 67.1%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in z around 0
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6484.7%
Simplified84.7%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6490.6%
Applied egg-rr90.6%
if 1.99999999999999985e126 < (*.f64 z z) Initial program 66.5%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.5%
Simplified71.5%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6485.4%
Simplified85.4%
Taylor expanded in x around 0
Simplified72.5%
Final simplification84.8%
(FPCore (x y z) :precision binary64 (if (<= y 1.25e+98) (/ (* z (/ (- x z) y)) 2.0) (/ y 2.0)))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.25e+98) {
tmp = (z * ((x - z) / y)) / 2.0;
} else {
tmp = y / 2.0;
}
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 <= 1.25d+98) then
tmp = (z * ((x - z) / y)) / 2.0d0
else
tmp = y / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.25e+98) {
tmp = (z * ((x - z) / y)) / 2.0;
} else {
tmp = y / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.25e+98: tmp = (z * ((x - z) / y)) / 2.0 else: tmp = y / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.25e+98) tmp = Float64(Float64(z * Float64(Float64(x - z) / y)) / 2.0); else tmp = Float64(y / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.25e+98) tmp = (z * ((x - z) / y)) / 2.0; else tmp = y / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.25e+98], N[(N[(z * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(y / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.25 \cdot 10^{+98}:\\
\;\;\;\;\frac{z \cdot \frac{x - z}{y}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{2}\\
\end{array}
\end{array}
if y < 1.25e98Initial program 72.7%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in y around 0
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6469.0%
Simplified69.0%
Taylor expanded in x around 0
Simplified39.5%
if 1.25e98 < y Initial program 26.4%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6479.0%
Simplified79.0%
Taylor expanded in y around inf
Simplified84.4%
(FPCore (x y z) :precision binary64 (if (<= y 1.05e+81) (* x (* x (/ 0.5 y))) (/ y 2.0)))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+81) {
tmp = x * (x * (0.5 / y));
} else {
tmp = y / 2.0;
}
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 <= 1.05d+81) then
tmp = x * (x * (0.5d0 / y))
else
tmp = y / 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+81) {
tmp = x * (x * (0.5 / y));
} else {
tmp = y / 2.0;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.05e+81: tmp = x * (x * (0.5 / y)) else: tmp = y / 2.0 return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.05e+81) tmp = Float64(x * Float64(x * Float64(0.5 / y))); else tmp = Float64(y / 2.0); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.05e+81) tmp = x * (x * (0.5 / y)); else tmp = y / 2.0; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.05e+81], N[(x * N[(x * N[(0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.05 \cdot 10^{+81}:\\
\;\;\;\;x \cdot \left(x \cdot \frac{0.5}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{2}\\
\end{array}
\end{array}
if y < 1.0499999999999999e81Initial program 72.8%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.3%
Simplified87.3%
difference-of-squaresN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f6499.5%
Applied egg-rr99.5%
*-commutativeN/A
associate-/r/N/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.5%
Applied egg-rr99.5%
Taylor expanded in z around 0
/-lowering-/.f6474.8%
Simplified74.8%
Taylor expanded in x around inf
*-commutativeN/A
unpow2N/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6439.6%
Simplified39.6%
if 1.0499999999999999e81 < y Initial program 33.2%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6477.5%
Simplified77.5%
Taylor expanded in y around inf
Simplified76.5%
(FPCore (x y z) :precision binary64 (/ y 2.0))
double code(double x, double y, double z) {
return y / 2.0;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = y / 2.0d0
end function
public static double code(double x, double y, double z) {
return y / 2.0;
}
def code(x, y, z): return y / 2.0
function code(x, y, z) return Float64(y / 2.0) end
function tmp = code(x, y, z) tmp = y / 2.0; end
code[x_, y_, z_] := N[(y / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{y}{2}
\end{array}
Initial program 66.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate--l+N/A
+-commutativeN/A
associate-+l-N/A
div-subN/A
associate-/l*N/A
*-commutativeN/A
*-inversesN/A
*-lft-identityN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.8%
Simplified85.8%
Taylor expanded in y around inf
Simplified38.9%
(FPCore (x y z) :precision binary64 (- (* y 0.5) (* (* (/ 0.5 y) (+ z x)) (- z x))))
double code(double x, double y, double z) {
return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (y * 0.5d0) - (((0.5d0 / y) * (z + x)) * (z - x))
end function
public static double code(double x, double y, double z) {
return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x));
}
def code(x, y, z): return (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x))
function code(x, y, z) return Float64(Float64(y * 0.5) - Float64(Float64(Float64(0.5 / y) * Float64(z + x)) * Float64(z - x))) end
function tmp = code(x, y, z) tmp = (y * 0.5) - (((0.5 / y) * (z + x)) * (z - x)); end
code[x_, y_, z_] := N[(N[(y * 0.5), $MachinePrecision] - N[(N[(N[(0.5 / y), $MachinePrecision] * N[(z + x), $MachinePrecision]), $MachinePrecision] * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
y \cdot 0.5 - \left(\frac{0.5}{y} \cdot \left(z + x\right)\right) \cdot \left(z - x\right)
\end{array}
herbie shell --seed 2024152
(FPCore (x y z)
:name "Diagrams.TwoD.Apollonian:initialConfig from diagrams-contrib-1.3.0.5, A"
:precision binary64
:alt
(! :herbie-platform default (- (* y 1/2) (* (* (/ 1/2 y) (+ z x)) (- z x))))
(/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))