
(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}
z_m = (fabs.f64 z) x_m = (fabs.f64 x) (FPCore (x_m y z_m) :precision binary64 (* 0.5 (fma (+ z_m x_m) (/ (- x_m z_m) y) y)))
z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
return 0.5 * fma((z_m + x_m), ((x_m - z_m) / y), y);
}
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) return Float64(0.5 * fma(Float64(z_m + x_m), Float64(Float64(x_m - z_m) / y), y)) end
z_m = N[Abs[z], $MachinePrecision] x_m = N[Abs[x], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := N[(0.5 * N[(N[(z$95$m + x$95$m), $MachinePrecision] * N[(N[(x$95$m - z$95$m), $MachinePrecision] / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
0.5 \cdot \mathsf{fma}\left(z\_m + x\_m, \frac{x\_m - z\_m}{y}, y\right)
\end{array}
Initial program 64.8%
Taylor expanded in x around 0
distribute-lft-outN/A
lower-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
lower-fma.f64N/A
Simplified99.9%
z_m = (fabs.f64 z)
x_m = (fabs.f64 x)
(FPCore (x_m y z_m)
:precision binary64
(let* ((t_0 (* (* z_m -0.5) (/ z_m y)))
(t_1 (/ (- (+ (* x_m x_m) (* y y)) (* z_m z_m)) (* y 2.0))))
(if (<= t_1 -5e-109)
t_0
(if (<= t_1 2e+114)
(* 0.5 y)
(if (<= t_1 INFINITY) (* x_m (/ (* 0.5 x_m) y)) t_0)))))z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
double t_0 = (z_m * -0.5) * (z_m / y);
double t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_1 <= -5e-109) {
tmp = t_0;
} else if (t_1 <= 2e+114) {
tmp = 0.5 * y;
} else if (t_1 <= ((double) INFINITY)) {
tmp = x_m * ((0.5 * x_m) / y);
} else {
tmp = t_0;
}
return tmp;
}
z_m = Math.abs(z);
x_m = Math.abs(x);
public static double code(double x_m, double y, double z_m) {
double t_0 = (z_m * -0.5) * (z_m / y);
double t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_1 <= -5e-109) {
tmp = t_0;
} else if (t_1 <= 2e+114) {
tmp = 0.5 * y;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = x_m * ((0.5 * x_m) / y);
} else {
tmp = t_0;
}
return tmp;
}
z_m = math.fabs(z) x_m = math.fabs(x) def code(x_m, y, z_m): t_0 = (z_m * -0.5) * (z_m / y) t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0) tmp = 0 if t_1 <= -5e-109: tmp = t_0 elif t_1 <= 2e+114: tmp = 0.5 * y elif t_1 <= math.inf: tmp = x_m * ((0.5 * x_m) / y) else: tmp = t_0 return tmp
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) t_0 = Float64(Float64(z_m * -0.5) * Float64(z_m / y)) t_1 = Float64(Float64(Float64(Float64(x_m * x_m) + Float64(y * y)) - Float64(z_m * z_m)) / Float64(y * 2.0)) tmp = 0.0 if (t_1 <= -5e-109) tmp = t_0; elseif (t_1 <= 2e+114) tmp = Float64(0.5 * y); elseif (t_1 <= Inf) tmp = Float64(x_m * Float64(Float64(0.5 * x_m) / y)); else tmp = t_0; end return tmp end
z_m = abs(z); x_m = abs(x); function tmp_2 = code(x_m, y, z_m) t_0 = (z_m * -0.5) * (z_m / y); t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0); tmp = 0.0; if (t_1 <= -5e-109) tmp = t_0; elseif (t_1 <= 2e+114) tmp = 0.5 * y; elseif (t_1 <= Inf) tmp = x_m * ((0.5 * x_m) / y); else tmp = t_0; end tmp_2 = tmp; end
z_m = N[Abs[z], $MachinePrecision]
x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_, y_, z$95$m_] := Block[{t$95$0 = N[(N[(z$95$m * -0.5), $MachinePrecision] * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(N[(x$95$m * x$95$m), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e-109], t$95$0, If[LessEqual[t$95$1, 2e+114], N[(0.5 * y), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(x$95$m * N[(N[(0.5 * x$95$m), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
\begin{array}{l}
t_0 := \left(z\_m \cdot -0.5\right) \cdot \frac{z\_m}{y}\\
t_1 := \frac{\left(x\_m \cdot x\_m + y \cdot y\right) - z\_m \cdot z\_m}{y \cdot 2}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-109}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+114}:\\
\;\;\;\;0.5 \cdot y\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;x\_m \cdot \frac{0.5 \cdot x\_m}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -5.0000000000000002e-109 or +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 62.9%
Taylor expanded in z around inf
associate-*r/N/A
metadata-evalN/A
associate-*r*N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6436.1
Simplified36.1%
associate-*l*N/A
associate-/l*N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
div-invN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6439.7
Applied egg-rr39.7%
if -5.0000000000000002e-109 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < 2e114Initial program 83.8%
Taylor expanded in y around inf
lower-*.f6468.2
Simplified68.2%
if 2e114 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 64.3%
Taylor expanded in x around inf
unpow2N/A
lower-*.f6437.5
Simplified37.5%
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
lower-/.f64N/A
div-invN/A
metadata-evalN/A
lower-*.f6441.8
Applied egg-rr41.8%
Final simplification42.4%
z_m = (fabs.f64 z)
x_m = (fabs.f64 x)
(FPCore (x_m y z_m)
:precision binary64
(let* ((t_0 (/ (- (+ (* x_m x_m) (* y y)) (* z_m z_m)) (* y 2.0))))
(if (<= t_0 -5e-109)
(* (* z_m -0.5) (/ z_m y))
(if (<= t_0 INFINITY)
(* 0.5 (fma x_m (/ x_m y) y))
(fma y 0.5 (* z_m (/ z_m (* y -2.0))))))))z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
double t_0 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_0 <= -5e-109) {
tmp = (z_m * -0.5) * (z_m / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x_m, (x_m / y), y);
} else {
tmp = fma(y, 0.5, (z_m * (z_m / (y * -2.0))));
}
return tmp;
}
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) t_0 = Float64(Float64(Float64(Float64(x_m * x_m) + Float64(y * y)) - Float64(z_m * z_m)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -5e-109) tmp = Float64(Float64(z_m * -0.5) * Float64(z_m / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x_m, Float64(x_m / y), y)); else tmp = fma(y, 0.5, Float64(z_m * Float64(z_m / Float64(y * -2.0)))); end return tmp end
z_m = N[Abs[z], $MachinePrecision]
x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_, y_, z$95$m_] := Block[{t$95$0 = N[(N[(N[(N[(x$95$m * x$95$m), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -5e-109], N[(N[(z$95$m * -0.5), $MachinePrecision] * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x$95$m * N[(x$95$m / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(y * 0.5 + N[(z$95$m * N[(z$95$m / N[(y * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
\begin{array}{l}
t_0 := \frac{\left(x\_m \cdot x\_m + y \cdot y\right) - z\_m \cdot z\_m}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-109}:\\
\;\;\;\;\left(z\_m \cdot -0.5\right) \cdot \frac{z\_m}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x\_m, \frac{x\_m}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, 0.5, z\_m \cdot \frac{z\_m}{y \cdot -2}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -5.0000000000000002e-109Initial program 81.0%
Taylor expanded in z around inf
associate-*r/N/A
metadata-evalN/A
associate-*r*N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6437.5
Simplified37.5%
associate-*l*N/A
associate-/l*N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
div-invN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6439.0
Applied egg-rr39.0%
if -5.0000000000000002e-109 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 67.6%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified76.2%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
lower-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
lower-fma.f64N/A
Simplified99.9%
Taylor expanded in x around 0
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unpow2N/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6478.7
Simplified78.7%
lift-neg.f64N/A
lift-/.f64N/A
distribute-rgt-inN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lift-/.f64N/A
associate-*r/N/A
associate-*r/N/A
associate-*l/N/A
metadata-evalN/A
lift-neg.f64N/A
frac-2negN/A
lift-/.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.7
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
div-invN/A
lower-*.f64N/A
metadata-eval78.7
Applied egg-rr78.7%
z_m = (fabs.f64 z)
x_m = (fabs.f64 x)
(FPCore (x_m y z_m)
:precision binary64
(let* ((t_0 (/ (- (+ (* x_m x_m) (* y y)) (* z_m z_m)) (* y 2.0))))
(if (<= t_0 -5e-109)
(* (* z_m -0.5) (/ z_m y))
(if (<= t_0 INFINITY)
(* 0.5 (fma x_m (/ x_m y) y))
(* 0.5 (fma z_m (/ (- z_m) y) y))))))z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
double t_0 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_0 <= -5e-109) {
tmp = (z_m * -0.5) * (z_m / y);
} else if (t_0 <= ((double) INFINITY)) {
tmp = 0.5 * fma(x_m, (x_m / y), y);
} else {
tmp = 0.5 * fma(z_m, (-z_m / y), y);
}
return tmp;
}
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) t_0 = Float64(Float64(Float64(Float64(x_m * x_m) + Float64(y * y)) - Float64(z_m * z_m)) / Float64(y * 2.0)) tmp = 0.0 if (t_0 <= -5e-109) tmp = Float64(Float64(z_m * -0.5) * Float64(z_m / y)); elseif (t_0 <= Inf) tmp = Float64(0.5 * fma(x_m, Float64(x_m / y), y)); else tmp = Float64(0.5 * fma(z_m, Float64(Float64(-z_m) / y), y)); end return tmp end
z_m = N[Abs[z], $MachinePrecision]
x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_, y_, z$95$m_] := Block[{t$95$0 = N[(N[(N[(N[(x$95$m * x$95$m), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -5e-109], N[(N[(z$95$m * -0.5), $MachinePrecision] * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, Infinity], N[(0.5 * N[(x$95$m * N[(x$95$m / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(z$95$m * N[((-z$95$m) / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
\begin{array}{l}
t_0 := \frac{\left(x\_m \cdot x\_m + y \cdot y\right) - z\_m \cdot z\_m}{y \cdot 2}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-109}:\\
\;\;\;\;\left(z\_m \cdot -0.5\right) \cdot \frac{z\_m}{y}\\
\mathbf{elif}\;t\_0 \leq \infty:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x\_m, \frac{x\_m}{y}, y\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(z\_m, \frac{-z\_m}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -5.0000000000000002e-109Initial program 81.0%
Taylor expanded in z around inf
associate-*r/N/A
metadata-evalN/A
associate-*r*N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6437.5
Simplified37.5%
associate-*l*N/A
associate-/l*N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
div-invN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6439.0
Applied egg-rr39.0%
if -5.0000000000000002e-109 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 67.6%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified76.2%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 0.0%
Taylor expanded in x around 0
distribute-lft-outN/A
lower-*.f64N/A
+-commutativeN/A
div-subN/A
sub-negN/A
+-commutativeN/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
associate-+r+N/A
sub-negN/A
div-subN/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
associate-/l*N/A
lower-fma.f64N/A
Simplified99.9%
Taylor expanded in x around 0
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unpow2N/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6478.7
Simplified78.7%
Final simplification59.4%
z_m = (fabs.f64 z)
x_m = (fabs.f64 x)
(FPCore (x_m y z_m)
:precision binary64
(let* ((t_0 (* (* z_m -0.5) (/ z_m y)))
(t_1 (/ (- (+ (* x_m x_m) (* y y)) (* z_m z_m)) (* y 2.0))))
(if (<= t_1 -5e-109) t_0 (if (<= t_1 INFINITY) (* 0.5 y) t_0))))z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
double t_0 = (z_m * -0.5) * (z_m / y);
double t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_1 <= -5e-109) {
tmp = t_0;
} else if (t_1 <= ((double) INFINITY)) {
tmp = 0.5 * y;
} else {
tmp = t_0;
}
return tmp;
}
z_m = Math.abs(z);
x_m = Math.abs(x);
public static double code(double x_m, double y, double z_m) {
double t_0 = (z_m * -0.5) * (z_m / y);
double t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0);
double tmp;
if (t_1 <= -5e-109) {
tmp = t_0;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = 0.5 * y;
} else {
tmp = t_0;
}
return tmp;
}
z_m = math.fabs(z) x_m = math.fabs(x) def code(x_m, y, z_m): t_0 = (z_m * -0.5) * (z_m / y) t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0) tmp = 0 if t_1 <= -5e-109: tmp = t_0 elif t_1 <= math.inf: tmp = 0.5 * y else: tmp = t_0 return tmp
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) t_0 = Float64(Float64(z_m * -0.5) * Float64(z_m / y)) t_1 = Float64(Float64(Float64(Float64(x_m * x_m) + Float64(y * y)) - Float64(z_m * z_m)) / Float64(y * 2.0)) tmp = 0.0 if (t_1 <= -5e-109) tmp = t_0; elseif (t_1 <= Inf) tmp = Float64(0.5 * y); else tmp = t_0; end return tmp end
z_m = abs(z); x_m = abs(x); function tmp_2 = code(x_m, y, z_m) t_0 = (z_m * -0.5) * (z_m / y); t_1 = (((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0); tmp = 0.0; if (t_1 <= -5e-109) tmp = t_0; elseif (t_1 <= Inf) tmp = 0.5 * y; else tmp = t_0; end tmp_2 = tmp; end
z_m = N[Abs[z], $MachinePrecision]
x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_, y_, z$95$m_] := Block[{t$95$0 = N[(N[(z$95$m * -0.5), $MachinePrecision] * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(N[(x$95$m * x$95$m), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e-109], t$95$0, If[LessEqual[t$95$1, Infinity], N[(0.5 * y), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
\begin{array}{l}
t_0 := \left(z\_m \cdot -0.5\right) \cdot \frac{z\_m}{y}\\
t_1 := \frac{\left(x\_m \cdot x\_m + y \cdot y\right) - z\_m \cdot z\_m}{y \cdot 2}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-109}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;0.5 \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -5.0000000000000002e-109 or +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 62.9%
Taylor expanded in z around inf
associate-*r/N/A
metadata-evalN/A
associate-*r*N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6436.1
Simplified36.1%
associate-*l*N/A
associate-/l*N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
div-invN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6439.7
Applied egg-rr39.7%
if -5.0000000000000002e-109 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < +inf.0Initial program 67.6%
Taylor expanded in y around inf
lower-*.f6441.0
Simplified41.0%
z_m = (fabs.f64 z) x_m = (fabs.f64 x) (FPCore (x_m y z_m) :precision binary64 (if (<= (/ (- (+ (* x_m x_m) (* y y)) (* z_m z_m)) (* y 2.0)) -5e-109) (* (* z_m -0.5) (/ z_m y)) (* 0.5 (fma x_m (/ x_m y) y))))
z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
double tmp;
if (((((x_m * x_m) + (y * y)) - (z_m * z_m)) / (y * 2.0)) <= -5e-109) {
tmp = (z_m * -0.5) * (z_m / y);
} else {
tmp = 0.5 * fma(x_m, (x_m / y), y);
}
return tmp;
}
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) tmp = 0.0 if (Float64(Float64(Float64(Float64(x_m * x_m) + Float64(y * y)) - Float64(z_m * z_m)) / Float64(y * 2.0)) <= -5e-109) tmp = Float64(Float64(z_m * -0.5) * Float64(z_m / y)); else tmp = Float64(0.5 * fma(x_m, Float64(x_m / y), y)); end return tmp end
z_m = N[Abs[z], $MachinePrecision] x_m = N[Abs[x], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := If[LessEqual[N[(N[(N[(N[(x$95$m * x$95$m), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0), $MachinePrecision]), $MachinePrecision], -5e-109], N[(N[(z$95$m * -0.5), $MachinePrecision] * N[(z$95$m / y), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(x$95$m * N[(x$95$m / y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{\left(x\_m \cdot x\_m + y \cdot y\right) - z\_m \cdot z\_m}{y \cdot 2} \leq -5 \cdot 10^{-109}:\\
\;\;\;\;\left(z\_m \cdot -0.5\right) \cdot \frac{z\_m}{y}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \mathsf{fma}\left(x\_m, \frac{x\_m}{y}, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) < -5.0000000000000002e-109Initial program 81.0%
Taylor expanded in z around inf
associate-*r/N/A
metadata-evalN/A
associate-*r*N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6437.5
Simplified37.5%
associate-*l*N/A
associate-/l*N/A
div-invN/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
div-invN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6439.0
Applied egg-rr39.0%
if -5.0000000000000002e-109 < (/.f64 (-.f64 (+.f64 (*.f64 x x) (*.f64 y y)) (*.f64 z z)) (*.f64 y #s(literal 2 binary64))) Initial program 51.0%
Taylor expanded in z around 0
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-*l/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
distribute-lft-inN/A
*-rgt-identityN/A
*-commutativeN/A
associate-/r/N/A
unpow2N/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
Simplified69.7%
z_m = (fabs.f64 z) x_m = (fabs.f64 x) (FPCore (x_m y z_m) :precision binary64 (* 0.5 y))
z_m = fabs(z);
x_m = fabs(x);
double code(double x_m, double y, double z_m) {
return 0.5 * y;
}
z_m = abs(z)
x_m = abs(x)
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
z_m = Math.abs(z);
x_m = Math.abs(x);
public static double code(double x_m, double y, double z_m) {
return 0.5 * y;
}
z_m = math.fabs(z) x_m = math.fabs(x) def code(x_m, y, z_m): return 0.5 * y
z_m = abs(z) x_m = abs(x) function code(x_m, y, z_m) return Float64(0.5 * y) end
z_m = abs(z); x_m = abs(x); function tmp = code(x_m, y, z_m) tmp = 0.5 * y; end
z_m = N[Abs[z], $MachinePrecision] x_m = N[Abs[x], $MachinePrecision] code[x$95$m_, y_, z$95$m_] := N[(0.5 * y), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
x_m = \left|x\right|
\\
0.5 \cdot y
\end{array}
Initial program 64.8%
Taylor expanded in y around inf
lower-*.f6436.8
Simplified36.8%
(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 2024212
(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)))