
(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 7 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}
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (* 0.5 (+ y (* (+ z_m x_m) (/ (- x_m z_m) y)))))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
return 0.5 * (y + ((z_m + x_m) * ((x_m - z_m) / y)));
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
code = 0.5d0 * (y + ((z_m + x_m) * ((x_m - z_m) / y)))
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
return 0.5 * (y + ((z_m + x_m) * ((x_m - z_m) / y)));
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): return 0.5 * (y + ((z_m + x_m) * ((x_m - z_m) / y)))
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) return Float64(0.5 * Float64(y + Float64(Float64(z_m + x_m) * Float64(Float64(x_m - z_m) / y)))) end
x_m = abs(x); z_m = abs(z); function tmp = code(x_m, y, z_m) tmp = 0.5 * (y + ((z_m + x_m) * ((x_m - z_m) / y))); end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := N[(0.5 * N[(y + N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(N[(x$95$m - z$95$m), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
0.5 \cdot \left(y + \left(z\_m + x\_m\right) \cdot \frac{x\_m - z\_m}{y}\right)
\end{array}
Initial program 74.6%
remove-double-neg74.6%
distribute-lft-neg-out74.6%
distribute-frac-neg274.6%
distribute-frac-neg74.6%
neg-mul-174.6%
distribute-lft-neg-out74.6%
*-commutative74.6%
distribute-lft-neg-in74.6%
times-frac74.6%
metadata-eval74.6%
metadata-eval74.6%
associate--l+74.6%
fma-define76.9%
Simplified76.9%
Taylor expanded in x around 0 83.0%
associate--l+83.0%
div-sub86.9%
Simplified86.9%
unpow286.9%
unpow286.9%
difference-of-squares91.6%
Applied egg-rr91.6%
*-un-lft-identity91.6%
fma-define91.6%
associate-/l*99.9%
Applied egg-rr99.9%
fma-undefine99.9%
*-lft-identity99.9%
+-commutative99.9%
Simplified99.9%
Final simplification99.9%
x_m = (fabs.f64 x)
z_m = (fabs.f64 z)
(FPCore (x_m y z_m)
:precision binary64
(if (<= z_m 3400.0)
(* 0.5 (+ y (* (+ z_m x_m) (/ x_m y))))
(if (<= z_m 7.2e+94)
(* 0.5 (* (+ z_m x_m) (/ (- x_m z_m) y)))
(* 0.5 (- y (* z_m (/ z_m y)))))))x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
double tmp;
if (z_m <= 3400.0) {
tmp = 0.5 * (y + ((z_m + x_m) * (x_m / y)));
} else if (z_m <= 7.2e+94) {
tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y));
} else {
tmp = 0.5 * (y - (z_m * (z_m / y)));
}
return tmp;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8) :: tmp
if (z_m <= 3400.0d0) then
tmp = 0.5d0 * (y + ((z_m + x_m) * (x_m / y)))
else if (z_m <= 7.2d+94) then
tmp = 0.5d0 * ((z_m + x_m) * ((x_m - z_m) / y))
else
tmp = 0.5d0 * (y - (z_m * (z_m / y)))
end if
code = tmp
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
double tmp;
if (z_m <= 3400.0) {
tmp = 0.5 * (y + ((z_m + x_m) * (x_m / y)));
} else if (z_m <= 7.2e+94) {
tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y));
} else {
tmp = 0.5 * (y - (z_m * (z_m / y)));
}
return tmp;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): tmp = 0 if z_m <= 3400.0: tmp = 0.5 * (y + ((z_m + x_m) * (x_m / y))) elif z_m <= 7.2e+94: tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y)) else: tmp = 0.5 * (y - (z_m * (z_m / y))) return tmp
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) tmp = 0.0 if (z_m <= 3400.0) tmp = Float64(0.5 * Float64(y + Float64(Float64(z_m + x_m) * Float64(x_m / y)))); elseif (z_m <= 7.2e+94) tmp = Float64(0.5 * Float64(Float64(z_m + x_m) * Float64(Float64(x_m - z_m) / y))); else tmp = Float64(0.5 * Float64(y - Float64(z_m * Float64(z_m / y)))); end return tmp end
x_m = abs(x); z_m = abs(z); function tmp_2 = code(x_m, y, z_m) tmp = 0.0; if (z_m <= 3400.0) tmp = 0.5 * (y + ((z_m + x_m) * (x_m / y))); elseif (z_m <= 7.2e+94) tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y)); else tmp = 0.5 * (y - (z_m * (z_m / y))); end tmp_2 = tmp; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[z$95$m, 3400.0], N[(0.5 * N[(y + N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(x$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z$95$m, 7.2e+94], N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(N[(x$95$m - z$95$m), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y - N[(z$95$m * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;z\_m \leq 3400:\\
\;\;\;\;0.5 \cdot \left(y + \left(z\_m + x\_m\right) \cdot \frac{x\_m}{y}\right)\\
\mathbf{elif}\;z\_m \leq 7.2 \cdot 10^{+94}:\\
\;\;\;\;0.5 \cdot \left(\left(z\_m + x\_m\right) \cdot \frac{x\_m - z\_m}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(y - z\_m \cdot \frac{z\_m}{y}\right)\\
\end{array}
\end{array}
if z < 3400Initial program 73.4%
remove-double-neg73.4%
distribute-lft-neg-out73.4%
distribute-frac-neg273.4%
distribute-frac-neg73.4%
neg-mul-173.4%
distribute-lft-neg-out73.4%
*-commutative73.4%
distribute-lft-neg-in73.4%
times-frac73.4%
metadata-eval73.4%
metadata-eval73.4%
associate--l+73.4%
fma-define74.9%
Simplified74.9%
Taylor expanded in x around 0 86.0%
associate--l+86.0%
div-sub87.4%
Simplified87.4%
unpow287.4%
unpow287.4%
difference-of-squares90.8%
Applied egg-rr90.8%
*-un-lft-identity90.8%
fma-define90.8%
associate-/l*99.9%
Applied egg-rr99.9%
fma-undefine99.9%
*-lft-identity99.9%
+-commutative99.9%
Simplified99.9%
Taylor expanded in x around inf 79.3%
if 3400 < z < 7.19999999999999985e94Initial program 94.8%
remove-double-neg94.8%
distribute-lft-neg-out94.8%
distribute-frac-neg294.8%
distribute-frac-neg94.8%
neg-mul-194.8%
distribute-lft-neg-out94.8%
*-commutative94.8%
distribute-lft-neg-in94.8%
times-frac94.8%
metadata-eval94.8%
metadata-eval94.8%
associate--l+94.8%
fma-define94.8%
Simplified94.8%
Taylor expanded in x around 0 88.8%
associate--l+88.8%
div-sub99.9%
Simplified99.9%
unpow299.9%
unpow299.9%
difference-of-squares99.9%
Applied egg-rr99.9%
Taylor expanded in y around 0 78.0%
associate-*r/77.9%
+-commutative77.9%
Simplified77.9%
if 7.19999999999999985e94 < z Initial program 70.7%
remove-double-neg70.7%
distribute-lft-neg-out70.7%
distribute-frac-neg270.7%
distribute-frac-neg70.7%
neg-mul-170.7%
distribute-lft-neg-out70.7%
*-commutative70.7%
distribute-lft-neg-in70.7%
times-frac70.7%
metadata-eval70.7%
metadata-eval70.7%
associate--l+70.7%
fma-define79.8%
Simplified79.8%
Taylor expanded in x around 0 73.9%
div-sub73.9%
unpow273.9%
associate-/l*80.1%
*-inverses80.1%
*-rgt-identity80.1%
Simplified80.1%
div-inv80.1%
unpow280.1%
associate-*l*88.1%
Applied egg-rr88.1%
Taylor expanded in z around 0 88.1%
Final simplification80.4%
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (if (<= y 3.2e+58) (* 0.5 (* (+ z_m x_m) (/ (- x_m z_m) y))) (* 0.5 (- y (* z_m (/ z_m y))))))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
double tmp;
if (y <= 3.2e+58) {
tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y));
} else {
tmp = 0.5 * (y - (z_m * (z_m / y)));
}
return tmp;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8) :: tmp
if (y <= 3.2d+58) then
tmp = 0.5d0 * ((z_m + x_m) * ((x_m - z_m) / y))
else
tmp = 0.5d0 * (y - (z_m * (z_m / y)))
end if
code = tmp
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
double tmp;
if (y <= 3.2e+58) {
tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y));
} else {
tmp = 0.5 * (y - (z_m * (z_m / y)));
}
return tmp;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): tmp = 0 if y <= 3.2e+58: tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y)) else: tmp = 0.5 * (y - (z_m * (z_m / y))) return tmp
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) tmp = 0.0 if (y <= 3.2e+58) tmp = Float64(0.5 * Float64(Float64(z_m + x_m) * Float64(Float64(x_m - z_m) / y))); else tmp = Float64(0.5 * Float64(y - Float64(z_m * Float64(z_m / y)))); end return tmp end
x_m = abs(x); z_m = abs(z); function tmp_2 = code(x_m, y, z_m) tmp = 0.0; if (y <= 3.2e+58) tmp = 0.5 * ((z_m + x_m) * ((x_m - z_m) / y)); else tmp = 0.5 * (y - (z_m * (z_m / y))); end tmp_2 = tmp; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[y, 3.2e+58], N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(N[(x$95$m - z$95$m), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(y - N[(z$95$m * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.2 \cdot 10^{+58}:\\
\;\;\;\;0.5 \cdot \left(\left(z\_m + x\_m\right) \cdot \frac{x\_m - z\_m}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(y - z\_m \cdot \frac{z\_m}{y}\right)\\
\end{array}
\end{array}
if y < 3.20000000000000015e58Initial program 81.4%
remove-double-neg81.4%
distribute-lft-neg-out81.4%
distribute-frac-neg281.4%
distribute-frac-neg81.4%
neg-mul-181.4%
distribute-lft-neg-out81.4%
*-commutative81.4%
distribute-lft-neg-in81.4%
times-frac81.4%
metadata-eval81.4%
metadata-eval81.4%
associate--l+81.4%
fma-define84.2%
Simplified84.2%
Taylor expanded in x around 0 83.6%
associate--l+83.6%
div-sub88.3%
Simplified88.3%
unpow288.3%
unpow288.3%
difference-of-squares93.4%
Applied egg-rr93.4%
Taylor expanded in y around 0 73.2%
associate-*r/75.2%
+-commutative75.2%
Simplified75.2%
if 3.20000000000000015e58 < y Initial program 40.6%
remove-double-neg40.6%
distribute-lft-neg-out40.6%
distribute-frac-neg240.6%
distribute-frac-neg40.6%
neg-mul-140.6%
distribute-lft-neg-out40.6%
*-commutative40.6%
distribute-lft-neg-in40.6%
times-frac40.6%
metadata-eval40.6%
metadata-eval40.6%
associate--l+40.6%
fma-define40.8%
Simplified40.8%
Taylor expanded in x around 0 32.9%
div-sub32.9%
unpow232.9%
associate-/l*78.0%
*-inverses78.0%
*-rgt-identity78.0%
Simplified78.0%
div-inv78.0%
unpow278.0%
associate-*l*86.8%
Applied egg-rr86.8%
Taylor expanded in z around 0 86.8%
Final simplification77.2%
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (if (<= y 2.6e+70) (* 0.5 (* (+ z_m x_m) (/ x_m y))) (* 0.5 y)))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
double tmp;
if (y <= 2.6e+70) {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
} else {
tmp = 0.5 * y;
}
return tmp;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8) :: tmp
if (y <= 2.6d+70) then
tmp = 0.5d0 * ((z_m + x_m) * (x_m / y))
else
tmp = 0.5d0 * y
end if
code = tmp
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
double tmp;
if (y <= 2.6e+70) {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
} else {
tmp = 0.5 * y;
}
return tmp;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): tmp = 0 if y <= 2.6e+70: tmp = 0.5 * ((z_m + x_m) * (x_m / y)) else: tmp = 0.5 * y return tmp
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) tmp = 0.0 if (y <= 2.6e+70) tmp = Float64(0.5 * Float64(Float64(z_m + x_m) * Float64(x_m / y))); else tmp = Float64(0.5 * y); end return tmp end
x_m = abs(x); z_m = abs(z); function tmp_2 = code(x_m, y, z_m) tmp = 0.0; if (y <= 2.6e+70) tmp = 0.5 * ((z_m + x_m) * (x_m / y)); else tmp = 0.5 * y; end tmp_2 = tmp; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[y, 2.6e+70], N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(x$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * y), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.6 \cdot 10^{+70}:\\
\;\;\;\;0.5 \cdot \left(\left(z\_m + x\_m\right) \cdot \frac{x\_m}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot y\\
\end{array}
\end{array}
if y < 2.6e70Initial program 81.5%
remove-double-neg81.5%
distribute-lft-neg-out81.5%
distribute-frac-neg281.5%
distribute-frac-neg81.5%
neg-mul-181.5%
distribute-lft-neg-out81.5%
*-commutative81.5%
distribute-lft-neg-in81.5%
times-frac81.5%
metadata-eval81.5%
metadata-eval81.5%
associate--l+81.5%
fma-define84.3%
Simplified84.3%
Taylor expanded in x around 0 83.7%
associate--l+83.7%
div-sub88.3%
Simplified88.3%
unpow288.3%
unpow288.3%
difference-of-squares93.5%
Applied egg-rr93.5%
Taylor expanded in y around 0 73.4%
associate-*r/75.3%
+-commutative75.3%
Simplified75.3%
Taylor expanded in x around inf 45.7%
if 2.6e70 < y Initial program 39.2%
Taylor expanded in y around inf 74.1%
*-commutative74.1%
Simplified74.1%
Final simplification50.4%
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (if (<= x_m 3.2e+150) (* 0.5 (- y (* z_m (/ z_m y)))) (* 0.5 (* (+ z_m x_m) (/ x_m y)))))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
double tmp;
if (x_m <= 3.2e+150) {
tmp = 0.5 * (y - (z_m * (z_m / y)));
} else {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
}
return tmp;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8) :: tmp
if (x_m <= 3.2d+150) then
tmp = 0.5d0 * (y - (z_m * (z_m / y)))
else
tmp = 0.5d0 * ((z_m + x_m) * (x_m / y))
end if
code = tmp
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
double tmp;
if (x_m <= 3.2e+150) {
tmp = 0.5 * (y - (z_m * (z_m / y)));
} else {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
}
return tmp;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): tmp = 0 if x_m <= 3.2e+150: tmp = 0.5 * (y - (z_m * (z_m / y))) else: tmp = 0.5 * ((z_m + x_m) * (x_m / y)) return tmp
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) tmp = 0.0 if (x_m <= 3.2e+150) tmp = Float64(0.5 * Float64(y - Float64(z_m * Float64(z_m / y)))); else tmp = Float64(0.5 * Float64(Float64(z_m + x_m) * Float64(x_m / y))); end return tmp end
x_m = abs(x); z_m = abs(z); function tmp_2 = code(x_m, y, z_m) tmp = 0.0; if (x_m <= 3.2e+150) tmp = 0.5 * (y - (z_m * (z_m / y))); else tmp = 0.5 * ((z_m + x_m) * (x_m / y)); end tmp_2 = tmp; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[x$95$m, 3.2e+150], N[(0.5 * N[(y - N[(z$95$m * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(x$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;x\_m \leq 3.2 \cdot 10^{+150}:\\
\;\;\;\;0.5 \cdot \left(y - z\_m \cdot \frac{z\_m}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\left(z\_m + x\_m\right) \cdot \frac{x\_m}{y}\right)\\
\end{array}
\end{array}
if x < 3.20000000000000016e150Initial program 78.4%
remove-double-neg78.4%
distribute-lft-neg-out78.4%
distribute-frac-neg278.4%
distribute-frac-neg78.4%
neg-mul-178.4%
distribute-lft-neg-out78.4%
*-commutative78.4%
distribute-lft-neg-in78.4%
times-frac78.4%
metadata-eval78.4%
metadata-eval78.4%
associate--l+78.4%
fma-define78.9%
Simplified78.9%
Taylor expanded in x around 0 51.0%
div-sub51.0%
unpow251.0%
associate-/l*65.7%
*-inverses65.7%
*-rgt-identity65.7%
Simplified65.7%
div-inv65.7%
unpow265.7%
associate-*l*70.3%
Applied egg-rr70.3%
Taylor expanded in z around 0 70.3%
if 3.20000000000000016e150 < x Initial program 49.3%
remove-double-neg49.3%
distribute-lft-neg-out49.3%
distribute-frac-neg249.3%
distribute-frac-neg49.3%
neg-mul-149.3%
distribute-lft-neg-out49.3%
*-commutative49.3%
distribute-lft-neg-in49.3%
times-frac49.3%
metadata-eval49.3%
metadata-eval49.3%
associate--l+49.3%
fma-define64.2%
Simplified64.2%
Taylor expanded in x around 0 46.3%
associate--l+46.3%
div-sub49.3%
Simplified49.3%
unpow249.3%
unpow249.3%
difference-of-squares76.0%
Applied egg-rr76.0%
Taylor expanded in y around 0 76.0%
associate-*r/80.9%
+-commutative80.9%
Simplified80.9%
Taylor expanded in x around inf 72.1%
Final simplification70.5%
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (if (<= x_m 1.7e+150) (* 0.5 (- y (/ z_m (/ y z_m)))) (* 0.5 (* (+ z_m x_m) (/ x_m y)))))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
double tmp;
if (x_m <= 1.7e+150) {
tmp = 0.5 * (y - (z_m / (y / z_m)));
} else {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
}
return tmp;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8) :: tmp
if (x_m <= 1.7d+150) then
tmp = 0.5d0 * (y - (z_m / (y / z_m)))
else
tmp = 0.5d0 * ((z_m + x_m) * (x_m / y))
end if
code = tmp
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
double tmp;
if (x_m <= 1.7e+150) {
tmp = 0.5 * (y - (z_m / (y / z_m)));
} else {
tmp = 0.5 * ((z_m + x_m) * (x_m / y));
}
return tmp;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): tmp = 0 if x_m <= 1.7e+150: tmp = 0.5 * (y - (z_m / (y / z_m))) else: tmp = 0.5 * ((z_m + x_m) * (x_m / y)) return tmp
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) tmp = 0.0 if (x_m <= 1.7e+150) tmp = Float64(0.5 * Float64(y - Float64(z_m / Float64(y / z_m)))); else tmp = Float64(0.5 * Float64(Float64(z_m + x_m) * Float64(x_m / y))); end return tmp end
x_m = abs(x); z_m = abs(z); function tmp_2 = code(x_m, y, z_m) tmp = 0.0; if (x_m <= 1.7e+150) tmp = 0.5 * (y - (z_m / (y / z_m))); else tmp = 0.5 * ((z_m + x_m) * (x_m / y)); end tmp_2 = tmp; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[x$95$m, 1.7e+150], N[(0.5 * N[(y - N[(z$95$m / N[(y / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(x$95$m / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;x\_m \leq 1.7 \cdot 10^{+150}:\\
\;\;\;\;0.5 \cdot \left(y - \frac{z\_m}{\frac{y}{z\_m}}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\left(z\_m + x\_m\right) \cdot \frac{x\_m}{y}\right)\\
\end{array}
\end{array}
if x < 1.69999999999999991e150Initial program 78.4%
remove-double-neg78.4%
distribute-lft-neg-out78.4%
distribute-frac-neg278.4%
distribute-frac-neg78.4%
neg-mul-178.4%
distribute-lft-neg-out78.4%
*-commutative78.4%
distribute-lft-neg-in78.4%
times-frac78.4%
metadata-eval78.4%
metadata-eval78.4%
associate--l+78.4%
fma-define78.9%
Simplified78.9%
Taylor expanded in x around 0 51.0%
div-sub51.0%
unpow251.0%
associate-/l*65.7%
*-inverses65.7%
*-rgt-identity65.7%
Simplified65.7%
div-inv65.7%
unpow265.7%
associate-*l*70.3%
Applied egg-rr70.3%
Taylor expanded in z around 0 70.3%
clear-num70.3%
un-div-inv70.3%
Applied egg-rr70.3%
if 1.69999999999999991e150 < x Initial program 49.3%
remove-double-neg49.3%
distribute-lft-neg-out49.3%
distribute-frac-neg249.3%
distribute-frac-neg49.3%
neg-mul-149.3%
distribute-lft-neg-out49.3%
*-commutative49.3%
distribute-lft-neg-in49.3%
times-frac49.3%
metadata-eval49.3%
metadata-eval49.3%
associate--l+49.3%
fma-define64.2%
Simplified64.2%
Taylor expanded in x around 0 46.3%
associate--l+46.3%
div-sub49.3%
Simplified49.3%
unpow249.3%
unpow249.3%
difference-of-squares76.0%
Applied egg-rr76.0%
Taylor expanded in y around 0 76.0%
associate-*r/80.9%
+-commutative80.9%
Simplified80.9%
Taylor expanded in x around inf 72.1%
Final simplification70.5%
x_m = (fabs.f64 x) z_m = (fabs.f64 z) (FPCore (x_m y z_m) :precision binary64 (* 0.5 y))
x_m = fabs(x);
z_m = fabs(z);
double code(double x_m, double y, double z_m) {
return 0.5 * y;
}
x_m = abs(x)
z_m = abs(z)
real(8) function code(x_m, y, z_m)
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z_m
code = 0.5d0 * y
end function
x_m = Math.abs(x);
z_m = Math.abs(z);
public static double code(double x_m, double y, double z_m) {
return 0.5 * y;
}
x_m = math.fabs(x) z_m = math.fabs(z) def code(x_m, y, z_m): return 0.5 * y
x_m = abs(x) z_m = abs(z) function code(x_m, y, z_m) return Float64(0.5 * y) end
x_m = abs(x); z_m = abs(z); function tmp = code(x_m, y, z_m) tmp = 0.5 * y; end
x_m = N[Abs[x], $MachinePrecision] z_m = N[Abs[z], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := N[(0.5 * y), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
z_m = \left|z\right|
\\
0.5 \cdot y
\end{array}
Initial program 74.6%
Taylor expanded in y around inf 33.4%
*-commutative33.4%
Simplified33.4%
Final simplification33.4%
(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 2024079
(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)))