
(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 6 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}
z_m = (fabs.f64 z)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
(FPCore (y_s x y_m z_m)
:precision binary64
(*
y_s
(if (<= (/ (- (+ (* x x) (* y_m y_m)) (* z_m z_m)) (* y_m 2.0)) -4e-74)
(* 0.5 (* (hypot x (+ y_m z_m)) (/ z_m (- y_m))))
(* 0.5 (+ y_m (* x (/ x y_m)))))))z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) {
tmp = 0.5 * (hypot(x, (y_m + z_m)) * (z_m / -y_m));
} else {
tmp = 0.5 * (y_m + (x * (x / y_m)));
}
return y_s * tmp;
}
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) {
tmp = 0.5 * (Math.hypot(x, (y_m + z_m)) * (z_m / -y_m));
} else {
tmp = 0.5 * (y_m + (x * (x / y_m)));
}
return y_s * tmp;
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): tmp = 0 if ((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74: tmp = 0.5 * (math.hypot(x, (y_m + z_m)) * (z_m / -y_m)) else: tmp = 0.5 * (y_m + (x * (x / y_m))) return y_s * tmp
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) tmp = 0.0 if (Float64(Float64(Float64(Float64(x * x) + Float64(y_m * y_m)) - Float64(z_m * z_m)) / Float64(y_m * 2.0)) <= -4e-74) tmp = Float64(0.5 * Float64(hypot(x, Float64(y_m + z_m)) * Float64(z_m / Float64(-y_m)))); else tmp = Float64(0.5 * Float64(y_m + Float64(x * Float64(x / y_m)))); end return Float64(y_s * tmp) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp_2 = code(y_s, x, y_m, z_m) tmp = 0.0; if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) tmp = 0.5 * (hypot(x, (y_m + z_m)) * (z_m / -y_m)); else tmp = 0.5 * (y_m + (x * (x / y_m))); end tmp_2 = y_s * tmp; end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * If[LessEqual[N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y$95$m * 2.0), $MachinePrecision]), $MachinePrecision], -4e-74], N[(0.5 * N[(N[Sqrt[x ^ 2 + N[(y$95$m + z$95$m), $MachinePrecision] ^ 2], $MachinePrecision] * N[(z$95$m / (-y$95$m)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y$95$m + N[(x * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left(x \cdot x + y\_m \cdot y\_m\right) - z\_m \cdot z\_m}{y\_m \cdot 2} \leq -4 \cdot 10^{-74}:\\
\;\;\;\;0.5 \cdot \left(\mathsf{hypot}\left(x, y\_m + z\_m\right) \cdot \frac{z\_m}{-y\_m}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(y\_m + x \cdot \frac{x}{y\_m}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -3.99999999999999983e-74Initial program 81.8%
remove-double-neg81.8%
distribute-lft-neg-out81.8%
distribute-frac-neg281.8%
distribute-frac-neg81.8%
neg-mul-181.8%
distribute-lft-neg-out81.8%
*-commutative81.8%
distribute-lft-neg-in81.8%
times-frac81.8%
metadata-eval81.8%
metadata-eval81.8%
associate--l+81.8%
fma-define81.8%
Simplified81.8%
prod-diff68.7%
fma-neg68.7%
difference-of-squares68.7%
fma-define68.6%
pow268.6%
Applied egg-rr68.6%
add-sqr-sqrt54.1%
associate-/l*54.1%
Applied egg-rr70.2%
Taylor expanded in z around -inf 25.5%
associate-*r/25.5%
mul-1-neg25.5%
Simplified25.5%
if -3.99999999999999983e-74 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 62.8%
remove-double-neg62.8%
distribute-lft-neg-out62.8%
distribute-frac-neg262.8%
distribute-frac-neg62.8%
neg-mul-162.8%
distribute-lft-neg-out62.8%
*-commutative62.8%
distribute-lft-neg-in62.8%
times-frac62.8%
metadata-eval62.8%
metadata-eval62.8%
associate--l+62.8%
fma-define63.5%
Simplified63.5%
Taylor expanded in z around 0 41.4%
associate-*r/41.4%
rem-square-sqrt41.4%
unpow241.4%
unpow241.4%
hypot-undefine41.4%
unpow241.4%
unpow241.4%
hypot-undefine41.4%
unpow241.4%
associate-*r/41.4%
*-commutative41.4%
metadata-eval41.4%
times-frac41.4%
associate-/l*41.3%
Simplified41.3%
Taylor expanded in x around 0 58.7%
distribute-lft-out58.7%
Simplified58.7%
unpow258.7%
associate-/l*62.8%
Applied egg-rr62.8%
Final simplification44.9%
z_m = (fabs.f64 z)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
(FPCore (y_s x y_m z_m)
:precision binary64
(*
y_s
(if (<= (/ (- (+ (* x x) (* y_m y_m)) (* z_m z_m)) (* y_m 2.0)) -4e-74)
(/ 1.0 (/ (/ (* y_m -2.0) z_m) z_m))
(* 0.5 (+ y_m (* x (/ x y_m)))))))z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) {
tmp = 1.0 / (((y_m * -2.0) / z_m) / z_m);
} else {
tmp = 0.5 * (y_m + (x * (x / y_m)));
}
return y_s * tmp;
}
z_m = abs(z)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z_m)
real(8), intent (in) :: y_s
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8) :: tmp
if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0d0)) <= (-4d-74)) then
tmp = 1.0d0 / (((y_m * (-2.0d0)) / z_m) / z_m)
else
tmp = 0.5d0 * (y_m + (x * (x / y_m)))
end if
code = y_s * tmp
end function
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) {
tmp = 1.0 / (((y_m * -2.0) / z_m) / z_m);
} else {
tmp = 0.5 * (y_m + (x * (x / y_m)));
}
return y_s * tmp;
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): tmp = 0 if ((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74: tmp = 1.0 / (((y_m * -2.0) / z_m) / z_m) else: tmp = 0.5 * (y_m + (x * (x / y_m))) return y_s * tmp
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) tmp = 0.0 if (Float64(Float64(Float64(Float64(x * x) + Float64(y_m * y_m)) - Float64(z_m * z_m)) / Float64(y_m * 2.0)) <= -4e-74) tmp = Float64(1.0 / Float64(Float64(Float64(y_m * -2.0) / z_m) / z_m)); else tmp = Float64(0.5 * Float64(y_m + Float64(x * Float64(x / y_m)))); end return Float64(y_s * tmp) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp_2 = code(y_s, x, y_m, z_m) tmp = 0.0; if (((((x * x) + (y_m * y_m)) - (z_m * z_m)) / (y_m * 2.0)) <= -4e-74) tmp = 1.0 / (((y_m * -2.0) / z_m) / z_m); else tmp = 0.5 * (y_m + (x * (x / y_m))); end tmp_2 = y_s * tmp; end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * If[LessEqual[N[(N[(N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y$95$m * 2.0), $MachinePrecision]), $MachinePrecision], -4e-74], N[(1.0 / N[(N[(N[(y$95$m * -2.0), $MachinePrecision] / z$95$m), $MachinePrecision] / z$95$m), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y$95$m + N[(x * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left(x \cdot x + y\_m \cdot y\_m\right) - z\_m \cdot z\_m}{y\_m \cdot 2} \leq -4 \cdot 10^{-74}:\\
\;\;\;\;\frac{1}{\frac{\frac{y\_m \cdot -2}{z\_m}}{z\_m}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(y\_m + x \cdot \frac{x}{y\_m}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -3.99999999999999983e-74Initial program 81.8%
remove-double-neg81.8%
distribute-lft-neg-out81.8%
distribute-frac-neg281.8%
distribute-frac-neg81.8%
neg-mul-181.8%
distribute-lft-neg-out81.8%
*-commutative81.8%
distribute-lft-neg-in81.8%
times-frac81.8%
metadata-eval81.8%
metadata-eval81.8%
associate--l+81.8%
fma-define81.8%
Simplified81.8%
fma-undefine81.8%
associate--l+81.8%
metadata-eval81.8%
times-frac81.8%
*-un-lft-identity81.8%
*-commutative81.8%
clear-num81.7%
associate-/l*81.6%
add-sqr-sqrt81.6%
pow281.6%
hypot-define81.6%
pow281.6%
Applied egg-rr81.6%
Taylor expanded in z around inf 28.9%
associate-*r/28.9%
unpow228.9%
associate-/r*30.4%
Applied egg-rr30.4%
if -3.99999999999999983e-74 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 62.8%
remove-double-neg62.8%
distribute-lft-neg-out62.8%
distribute-frac-neg262.8%
distribute-frac-neg62.8%
neg-mul-162.8%
distribute-lft-neg-out62.8%
*-commutative62.8%
distribute-lft-neg-in62.8%
times-frac62.8%
metadata-eval62.8%
metadata-eval62.8%
associate--l+62.8%
fma-define63.5%
Simplified63.5%
Taylor expanded in z around 0 41.4%
associate-*r/41.4%
rem-square-sqrt41.4%
unpow241.4%
unpow241.4%
hypot-undefine41.4%
unpow241.4%
unpow241.4%
hypot-undefine41.4%
unpow241.4%
associate-*r/41.4%
*-commutative41.4%
metadata-eval41.4%
times-frac41.4%
associate-/l*41.3%
Simplified41.3%
Taylor expanded in x around 0 58.7%
distribute-lft-out58.7%
Simplified58.7%
unpow258.7%
associate-/l*62.8%
Applied egg-rr62.8%
Final simplification47.2%
z_m = (fabs.f64 z) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) (FPCore (y_s x y_m z_m) :precision binary64 (* y_s (if (<= x 3.45e+165) (* y_m 0.5) (* 0.5 (* z_m (/ z_m y_m))))))
z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (x <= 3.45e+165) {
tmp = y_m * 0.5;
} else {
tmp = 0.5 * (z_m * (z_m / y_m));
}
return y_s * tmp;
}
z_m = abs(z)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z_m)
real(8), intent (in) :: y_s
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8) :: tmp
if (x <= 3.45d+165) then
tmp = y_m * 0.5d0
else
tmp = 0.5d0 * (z_m * (z_m / y_m))
end if
code = y_s * tmp
end function
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
double tmp;
if (x <= 3.45e+165) {
tmp = y_m * 0.5;
} else {
tmp = 0.5 * (z_m * (z_m / y_m));
}
return y_s * tmp;
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): tmp = 0 if x <= 3.45e+165: tmp = y_m * 0.5 else: tmp = 0.5 * (z_m * (z_m / y_m)) return y_s * tmp
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) tmp = 0.0 if (x <= 3.45e+165) tmp = Float64(y_m * 0.5); else tmp = Float64(0.5 * Float64(z_m * Float64(z_m / y_m))); end return Float64(y_s * tmp) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp_2 = code(y_s, x, y_m, z_m) tmp = 0.0; if (x <= 3.45e+165) tmp = y_m * 0.5; else tmp = 0.5 * (z_m * (z_m / y_m)); end tmp_2 = y_s * tmp; end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * If[LessEqual[x, 3.45e+165], N[(y$95$m * 0.5), $MachinePrecision], N[(0.5 * N[(z$95$m * N[(z$95$m / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot \begin{array}{l}
\mathbf{if}\;x \leq 3.45 \cdot 10^{+165}:\\
\;\;\;\;y\_m \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(z\_m \cdot \frac{z\_m}{y\_m}\right)\\
\end{array}
\end{array}
if x < 3.45000000000000003e165Initial program 73.0%
remove-double-neg73.0%
distribute-lft-neg-out73.0%
distribute-frac-neg273.0%
distribute-frac-neg73.0%
neg-mul-173.0%
distribute-lft-neg-out73.0%
*-commutative73.0%
distribute-lft-neg-in73.0%
times-frac73.0%
metadata-eval73.0%
metadata-eval73.0%
associate--l+73.0%
fma-define73.4%
Simplified73.4%
Taylor expanded in y around inf 39.1%
*-commutative39.1%
Simplified39.1%
if 3.45000000000000003e165 < x Initial program 63.5%
remove-double-neg63.5%
distribute-lft-neg-out63.5%
distribute-frac-neg263.5%
distribute-frac-neg63.5%
neg-mul-163.5%
distribute-lft-neg-out63.5%
*-commutative63.5%
distribute-lft-neg-in63.5%
times-frac63.5%
metadata-eval63.5%
metadata-eval63.5%
associate--l+63.5%
fma-define63.5%
Simplified63.5%
prod-diff63.5%
fma-neg63.5%
difference-of-squares63.7%
fma-define74.1%
pow274.1%
Applied egg-rr74.1%
Applied egg-rr45.4%
Taylor expanded in z around inf 8.1%
unpow28.1%
associate-*r*8.1%
*-commutative8.1%
associate-*r*8.1%
add-sqr-sqrt12.6%
div-inv12.6%
Applied egg-rr12.6%
Final simplification36.1%
z_m = (fabs.f64 z) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) (FPCore (y_s x y_m z_m) :precision binary64 (* y_s (* 0.5 (+ y_m (* x (/ x y_m))))))
z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
return y_s * (0.5 * (y_m + (x * (x / y_m))));
}
z_m = abs(z)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z_m)
real(8), intent (in) :: y_s
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
code = y_s * (0.5d0 * (y_m + (x * (x / y_m))))
end function
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
return y_s * (0.5 * (y_m + (x * (x / y_m))));
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): return y_s * (0.5 * (y_m + (x * (x / y_m))))
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) return Float64(y_s * Float64(0.5 * Float64(y_m + Float64(x * Float64(x / y_m))))) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp = code(y_s, x, y_m, z_m) tmp = y_s * (0.5 * (y_m + (x * (x / y_m)))); end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * N[(0.5 * N[(y$95$m + N[(x * N[(x / y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot \left(0.5 \cdot \left(y\_m + x \cdot \frac{x}{y\_m}\right)\right)
\end{array}
Initial program 71.9%
remove-double-neg71.9%
distribute-lft-neg-out71.9%
distribute-frac-neg271.9%
distribute-frac-neg71.9%
neg-mul-171.9%
distribute-lft-neg-out71.9%
*-commutative71.9%
distribute-lft-neg-in71.9%
times-frac71.9%
metadata-eval71.9%
metadata-eval71.9%
associate--l+71.9%
fma-define72.3%
Simplified72.3%
Taylor expanded in z around 0 47.4%
associate-*r/47.4%
rem-square-sqrt47.4%
unpow247.4%
unpow247.4%
hypot-undefine47.4%
unpow247.4%
unpow247.4%
hypot-undefine47.4%
unpow247.4%
associate-*r/47.4%
*-commutative47.4%
metadata-eval47.4%
times-frac47.4%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in x around 0 62.6%
distribute-lft-out62.6%
Simplified62.6%
unpow262.6%
associate-/l*66.5%
Applied egg-rr66.5%
Final simplification66.5%
z_m = (fabs.f64 z) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) (FPCore (y_s x y_m z_m) :precision binary64 (* y_s (* y_m 0.5)))
z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
return y_s * (y_m * 0.5);
}
z_m = abs(z)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z_m)
real(8), intent (in) :: y_s
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
code = y_s * (y_m * 0.5d0)
end function
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
return y_s * (y_m * 0.5);
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): return y_s * (y_m * 0.5)
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) return Float64(y_s * Float64(y_m * 0.5)) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp = code(y_s, x, y_m, z_m) tmp = y_s * (y_m * 0.5); end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * N[(y$95$m * 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot \left(y\_m \cdot 0.5\right)
\end{array}
Initial program 71.9%
remove-double-neg71.9%
distribute-lft-neg-out71.9%
distribute-frac-neg271.9%
distribute-frac-neg71.9%
neg-mul-171.9%
distribute-lft-neg-out71.9%
*-commutative71.9%
distribute-lft-neg-in71.9%
times-frac71.9%
metadata-eval71.9%
metadata-eval71.9%
associate--l+71.9%
fma-define72.3%
Simplified72.3%
Taylor expanded in y around inf 35.4%
*-commutative35.4%
Simplified35.4%
Final simplification35.4%
z_m = (fabs.f64 z) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) (FPCore (y_s x y_m z_m) :precision binary64 (* y_s z_m))
z_m = fabs(z);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
double code(double y_s, double x, double y_m, double z_m) {
return y_s * z_m;
}
z_m = abs(z)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
real(8) function code(y_s, x, y_m, z_m)
real(8), intent (in) :: y_s
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
code = y_s * z_m
end function
z_m = Math.abs(z);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
public static double code(double y_s, double x, double y_m, double z_m) {
return y_s * z_m;
}
z_m = math.fabs(z) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) def code(y_s, x, y_m, z_m): return y_s * z_m
z_m = abs(z) y\_m = abs(y) y\_s = copysign(1.0, y) function code(y_s, x, y_m, z_m) return Float64(y_s * z_m) end
z_m = abs(z); y\_m = abs(y); y\_s = sign(y) * abs(1.0); function tmp = code(y_s, x, y_m, z_m) tmp = y_s * z_m; end
z_m = N[Abs[z], $MachinePrecision]
y\_m = N[Abs[y], $MachinePrecision]
y\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[y]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[y$95$s_, x_, y$95$m_, z$95$m_] := N[(y$95$s * z$95$m), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
y\_s \cdot z\_m
\end{array}
Initial program 71.9%
remove-double-neg71.9%
distribute-lft-neg-out71.9%
distribute-frac-neg271.9%
distribute-frac-neg71.9%
neg-mul-171.9%
distribute-lft-neg-out71.9%
*-commutative71.9%
distribute-lft-neg-in71.9%
times-frac71.9%
metadata-eval71.9%
metadata-eval71.9%
associate--l+71.9%
fma-define72.3%
Simplified72.3%
prod-diff60.1%
fma-neg60.1%
difference-of-squares60.6%
fma-define63.7%
pow263.7%
Applied egg-rr63.7%
add-sqr-sqrt47.3%
associate-/l*47.3%
Applied egg-rr65.8%
Taylor expanded in y around inf 39.9%
Taylor expanded in y around 0 3.0%
Final simplification3.0%
(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 2024071
(FPCore (x y z)
:name "Diagrams.TwoD.Apollonian:initialConfig from diagrams-contrib-1.3.0.5, A"
:precision binary64
:alt
(- (* y 0.5) (* (* (/ 0.5 y) (+ z x)) (- z x)))
(/ (- (+ (* x x) (* y y)) (* z z)) (* y 2.0)))