
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * z) - (t * a)));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = ((x * y) * z) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))
double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / sqrt(((z * z) - (t * a)));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = ((x * y) * z) / sqrt(((z * z) - (t * a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return ((x * y) * z) / Math.sqrt(((z * z) - (t * a)));
}
def code(x, y, z, t, a): return ((x * y) * z) / math.sqrt(((z * z) - (t * a)))
function code(x, y, z, t, a) return Float64(Float64(Float64(x * y) * z) / sqrt(Float64(Float64(z * z) - Float64(t * a)))) end
function tmp = code(x, y, z, t, a) tmp = ((x * y) * z) / sqrt(((z * z) - (t * a))); end
code[x_, y_, z_, t_, a_] := N[(N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision] / N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot y\right) \cdot z}{\sqrt{z \cdot z - t \cdot a}}
\end{array}
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 2.5e+20)
(* (/ x_m (sqrt (- (* z_m z_m) (* t a)))) (* z_m y_m))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.5e+20) {
tmp = (x_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * y_m);
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 2.5d+20) then
tmp = (x_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * y_m)
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.5e+20) {
tmp = (x_m / Math.sqrt(((z_m * z_m) - (t * a)))) * (z_m * y_m);
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 2.5e+20: tmp = (x_m / math.sqrt(((z_m * z_m) - (t * a)))) * (z_m * y_m) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 2.5e+20) tmp = Float64(Float64(x_m / sqrt(Float64(Float64(z_m * z_m) - Float64(t * a)))) * Float64(z_m * y_m)); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 2.5e+20)
tmp = (x_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * y_m);
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 2.5e+20], N[(N[(x$95$m / N[Sqrt[N[(N[(z$95$m * z$95$m), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(z$95$m * y$95$m), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 2.5 \cdot 10^{+20}:\\
\;\;\;\;\frac{x\_m}{\sqrt{z\_m \cdot z\_m - t \cdot a}} \cdot \left(z\_m \cdot y\_m\right)\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 2.5e20Initial program 69.1%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.3%
Simplified69.3%
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6470.4%
Applied egg-rr70.4%
if 2.5e20 < z Initial program 50.6%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.2%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6474.7%
Simplified74.7%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr93.1%
Final simplification76.3%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 7.7e-115)
(* (* z_m y_m) (/ x_m (sqrt (- 0.0 (* t a)))))
(if (<= z_m 2e+134)
(* (/ y_m (sqrt (- (* z_m z_m) (* t a)))) (* z_m x_m))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m))))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7.7e-115) {
tmp = (z_m * y_m) * (x_m / sqrt((0.0 - (t * a))));
} else if (z_m <= 2e+134) {
tmp = (y_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * x_m);
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 7.7d-115) then
tmp = (z_m * y_m) * (x_m / sqrt((0.0d0 - (t * a))))
else if (z_m <= 2d+134) then
tmp = (y_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * x_m)
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7.7e-115) {
tmp = (z_m * y_m) * (x_m / Math.sqrt((0.0 - (t * a))));
} else if (z_m <= 2e+134) {
tmp = (y_m / Math.sqrt(((z_m * z_m) - (t * a)))) * (z_m * x_m);
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 7.7e-115: tmp = (z_m * y_m) * (x_m / math.sqrt((0.0 - (t * a)))) elif z_m <= 2e+134: tmp = (y_m / math.sqrt(((z_m * z_m) - (t * a)))) * (z_m * x_m) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 7.7e-115) tmp = Float64(Float64(z_m * y_m) * Float64(x_m / sqrt(Float64(0.0 - Float64(t * a))))); elseif (z_m <= 2e+134) tmp = Float64(Float64(y_m / sqrt(Float64(Float64(z_m * z_m) - Float64(t * a)))) * Float64(z_m * x_m)); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 7.7e-115)
tmp = (z_m * y_m) * (x_m / sqrt((0.0 - (t * a))));
elseif (z_m <= 2e+134)
tmp = (y_m / sqrt(((z_m * z_m) - (t * a)))) * (z_m * x_m);
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 7.7e-115], N[(N[(z$95$m * y$95$m), $MachinePrecision] * N[(x$95$m / N[Sqrt[N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z$95$m, 2e+134], N[(N[(y$95$m / N[Sqrt[N[(N[(z$95$m * z$95$m), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(z$95$m * x$95$m), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 7.7 \cdot 10^{-115}:\\
\;\;\;\;\left(z\_m \cdot y\_m\right) \cdot \frac{x\_m}{\sqrt{0 - t \cdot a}}\\
\mathbf{elif}\;z\_m \leq 2 \cdot 10^{+134}:\\
\;\;\;\;\frac{y\_m}{\sqrt{z\_m \cdot z\_m - t \cdot a}} \cdot \left(z\_m \cdot x\_m\right)\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 7.7000000000000002e-115Initial program 65.0%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6464.6%
Simplified64.6%
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.5%
Applied egg-rr66.5%
Taylor expanded in z around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6444.1%
Simplified44.1%
if 7.7000000000000002e-115 < z < 1.99999999999999984e134Initial program 92.2%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.0%
Simplified92.0%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.1%
Applied egg-rr92.1%
if 1.99999999999999984e134 < z Initial program 28.2%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified53.4%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.8%
Simplified70.8%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr97.8%
Final simplification62.3%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 2.9e-25)
(* (* z_m y_m) (/ x_m (sqrt (- 0.0 (* t a)))))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.9e-25) {
tmp = (z_m * y_m) * (x_m / sqrt((0.0 - (t * a))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 2.9d-25) then
tmp = (z_m * y_m) * (x_m / sqrt((0.0d0 - (t * a))))
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.9e-25) {
tmp = (z_m * y_m) * (x_m / Math.sqrt((0.0 - (t * a))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 2.9e-25: tmp = (z_m * y_m) * (x_m / math.sqrt((0.0 - (t * a)))) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 2.9e-25) tmp = Float64(Float64(z_m * y_m) * Float64(x_m / sqrt(Float64(0.0 - Float64(t * a))))); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 2.9e-25)
tmp = (z_m * y_m) * (x_m / sqrt((0.0 - (t * a))));
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 2.9e-25], N[(N[(z$95$m * y$95$m), $MachinePrecision] * N[(x$95$m / N[Sqrt[N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 2.9 \cdot 10^{-25}:\\
\;\;\;\;\left(z\_m \cdot y\_m\right) \cdot \frac{x\_m}{\sqrt{0 - t \cdot a}}\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 2.9000000000000001e-25Initial program 67.0%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6467.2%
Simplified67.2%
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.0%
Applied egg-rr69.0%
Taylor expanded in z around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6447.0%
Simplified47.0%
if 2.9000000000000001e-25 < z Initial program 58.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.3%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6473.0%
Simplified73.0%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr88.5%
Final simplification59.8%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 3e-25)
(* x_m (/ (* z_m y_m) (sqrt (- 0.0 (* t a)))))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 3e-25) {
tmp = x_m * ((z_m * y_m) / sqrt((0.0 - (t * a))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 3d-25) then
tmp = x_m * ((z_m * y_m) / sqrt((0.0d0 - (t * a))))
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 3e-25) {
tmp = x_m * ((z_m * y_m) / Math.sqrt((0.0 - (t * a))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 3e-25: tmp = x_m * ((z_m * y_m) / math.sqrt((0.0 - (t * a)))) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 3e-25) tmp = Float64(x_m * Float64(Float64(z_m * y_m) / sqrt(Float64(0.0 - Float64(t * a))))); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 3e-25)
tmp = x_m * ((z_m * y_m) / sqrt((0.0 - (t * a))));
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 3e-25], N[(x$95$m * N[(N[(z$95$m * y$95$m), $MachinePrecision] / N[Sqrt[N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 3 \cdot 10^{-25}:\\
\;\;\;\;x\_m \cdot \frac{z\_m \cdot y\_m}{\sqrt{0 - t \cdot a}}\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 2.9999999999999998e-25Initial program 67.0%
Taylor expanded in z around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6447.2%
Simplified47.2%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f6446.0%
Applied egg-rr46.0%
if 2.9999999999999998e-25 < z Initial program 58.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.3%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6473.0%
Simplified73.0%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr88.5%
Final simplification59.1%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 3.2e-25)
(* x_m (* z_m (/ y_m (sqrt (- 0.0 (* t a))))))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 3.2e-25) {
tmp = x_m * (z_m * (y_m / sqrt((0.0 - (t * a)))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 3.2d-25) then
tmp = x_m * (z_m * (y_m / sqrt((0.0d0 - (t * a)))))
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 3.2e-25) {
tmp = x_m * (z_m * (y_m / Math.sqrt((0.0 - (t * a)))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 3.2e-25: tmp = x_m * (z_m * (y_m / math.sqrt((0.0 - (t * a))))) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 3.2e-25) tmp = Float64(x_m * Float64(z_m * Float64(y_m / sqrt(Float64(0.0 - Float64(t * a)))))); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 3.2e-25)
tmp = x_m * (z_m * (y_m / sqrt((0.0 - (t * a)))));
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 3.2e-25], N[(x$95$m * N[(z$95$m * N[(y$95$m / N[Sqrt[N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 3.2 \cdot 10^{-25}:\\
\;\;\;\;x\_m \cdot \left(z\_m \cdot \frac{y\_m}{\sqrt{0 - t \cdot a}}\right)\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 3.2000000000000001e-25Initial program 67.0%
Taylor expanded in z around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6447.2%
Simplified47.2%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f6446.0%
Applied egg-rr46.0%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6445.4%
Applied egg-rr45.4%
if 3.2000000000000001e-25 < z Initial program 58.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.3%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6473.0%
Simplified73.0%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr88.5%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 2.9e-25)
(* x_m (* y_m (/ z_m (sqrt (- 0.0 (* t a))))))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.9e-25) {
tmp = x_m * (y_m * (z_m / sqrt((0.0 - (t * a)))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 2.9d-25) then
tmp = x_m * (y_m * (z_m / sqrt((0.0d0 - (t * a)))))
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.9e-25) {
tmp = x_m * (y_m * (z_m / Math.sqrt((0.0 - (t * a)))));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 2.9e-25: tmp = x_m * (y_m * (z_m / math.sqrt((0.0 - (t * a))))) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 2.9e-25) tmp = Float64(x_m * Float64(y_m * Float64(z_m / sqrt(Float64(0.0 - Float64(t * a)))))); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 2.9e-25)
tmp = x_m * (y_m * (z_m / sqrt((0.0 - (t * a)))));
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 2.9e-25], N[(x$95$m * N[(y$95$m * N[(z$95$m / N[Sqrt[N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 2.9 \cdot 10^{-25}:\\
\;\;\;\;x\_m \cdot \left(y\_m \cdot \frac{z\_m}{\sqrt{0 - t \cdot a}}\right)\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 2.9000000000000001e-25Initial program 67.0%
Taylor expanded in z around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6447.2%
Simplified47.2%
associate-/l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f6444.9%
Applied egg-rr44.9%
if 2.9000000000000001e-25 < z Initial program 58.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.3%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6473.0%
Simplified73.0%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr88.5%
Final simplification58.4%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 2.1e+20)
(* x_m (/ (* z_m y_m) (+ z_m (/ (* (* t a) -0.5) z_m))))
(*
y_m
(*
x_m
(/
z_m
(+
z_m
(*
t
(*
a
(+
(/ (* a -0.125) (/ (* z_m (* z_m z_m)) t))
(/ -0.5 z_m)))))))))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.1e+20) {
tmp = x_m * ((z_m * y_m) / (z_m + (((t * a) * -0.5) / z_m)));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 2.1d+20) then
tmp = x_m * ((z_m * y_m) / (z_m + (((t * a) * (-0.5d0)) / z_m)))
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * (-0.125d0)) / ((z_m * (z_m * z_m)) / t)) + ((-0.5d0) / z_m)))))))
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.1e+20) {
tmp = x_m * ((z_m * y_m) / (z_m + (((t * a) * -0.5) / z_m)));
} else {
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 2.1e+20: tmp = x_m * ((z_m * y_m) / (z_m + (((t * a) * -0.5) / z_m))) else: tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m))))))) return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 2.1e+20) tmp = Float64(x_m * Float64(Float64(z_m * y_m) / Float64(z_m + Float64(Float64(Float64(t * a) * -0.5) / z_m)))); else tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(t * Float64(a * Float64(Float64(Float64(a * -0.125) / Float64(Float64(z_m * Float64(z_m * z_m)) / t)) + Float64(-0.5 / z_m)))))))); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 2.1e+20)
tmp = x_m * ((z_m * y_m) / (z_m + (((t * a) * -0.5) / z_m)));
else
tmp = y_m * (x_m * (z_m / (z_m + (t * (a * (((a * -0.125) / ((z_m * (z_m * z_m)) / t)) + (-0.5 / z_m)))))));
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 2.1e+20], N[(x$95$m * N[(N[(z$95$m * y$95$m), $MachinePrecision] / N[(z$95$m + N[(N[(N[(t * a), $MachinePrecision] * -0.5), $MachinePrecision] / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(t * N[(a * N[(N[(N[(a * -0.125), $MachinePrecision] / N[(N[(z$95$m * N[(z$95$m * z$95$m), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 2.1 \cdot 10^{+20}:\\
\;\;\;\;x\_m \cdot \frac{z\_m \cdot y\_m}{z\_m + \frac{\left(t \cdot a\right) \cdot -0.5}{z\_m}}\\
\mathbf{else}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + t \cdot \left(a \cdot \left(\frac{a \cdot -0.125}{\frac{z\_m \cdot \left(z\_m \cdot z\_m\right)}{t}} + \frac{-0.5}{z\_m}\right)\right)}\right)\\
\end{array}\right)\right)
\end{array}
if z < 2.1e20Initial program 69.1%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.3%
Simplified69.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6429.4%
Simplified29.4%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr31.3%
if 2.1e20 < z Initial program 50.6%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified62.2%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6474.7%
Simplified74.7%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr93.1%
Final simplification47.4%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
y\_m = (fabs.f64 y)
y\_s = (copysign.f64 #s(literal 1 binary64) y)
z\_m = (fabs.f64 z)
z\_s = (copysign.f64 #s(literal 1 binary64) z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
(FPCore (z_s y_s x_s x_m y_m z_m t a)
:precision binary64
(*
z_s
(*
y_s
(*
x_s
(if (<= z_m 6e+156)
(* y_m (* x_m (/ z_m (+ z_m (/ (* (* t a) -0.5) z_m)))))
(* x_m y_m))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 6e+156) {
tmp = y_m * (x_m * (z_m / (z_m + (((t * a) * -0.5) / z_m))));
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 6d+156) then
tmp = y_m * (x_m * (z_m / (z_m + (((t * a) * (-0.5d0)) / z_m))))
else
tmp = x_m * y_m
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 6e+156) {
tmp = y_m * (x_m * (z_m / (z_m + (((t * a) * -0.5) / z_m))));
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 6e+156: tmp = y_m * (x_m * (z_m / (z_m + (((t * a) * -0.5) / z_m)))) else: tmp = x_m * y_m return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 6e+156) tmp = Float64(y_m * Float64(x_m * Float64(z_m / Float64(z_m + Float64(Float64(Float64(t * a) * -0.5) / z_m))))); else tmp = Float64(x_m * y_m); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 6e+156)
tmp = y_m * (x_m * (z_m / (z_m + (((t * a) * -0.5) / z_m))));
else
tmp = x_m * y_m;
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 6e+156], N[(y$95$m * N[(x$95$m * N[(z$95$m / N[(z$95$m + N[(N[(N[(t * a), $MachinePrecision] * -0.5), $MachinePrecision] / z$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x$95$m * y$95$m), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 6 \cdot 10^{+156}:\\
\;\;\;\;y\_m \cdot \left(x\_m \cdot \frac{z\_m}{z\_m + \frac{\left(t \cdot a\right) \cdot -0.5}{z\_m}}\right)\\
\mathbf{else}:\\
\;\;\;\;x\_m \cdot y\_m\\
\end{array}\right)\right)
\end{array}
if z < 5.9999999999999999e156Initial program 71.5%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
associate-*l/N/A
associate-*r*N/A
/-lowering-/.f64N/A
Simplified26.2%
Taylor expanded in a around 0
*-lowering-*.f64N/A
sub-negN/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6437.1%
Simplified37.1%
associate-/l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Applied egg-rr38.5%
Taylor expanded in t around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6439.4%
Simplified39.4%
if 5.9999999999999999e156 < z Initial program 16.9%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6416.7%
Simplified16.7%
Taylor expanded in z around inf
*-lowering-*.f64100.0%
Simplified100.0%
Final simplification47.5%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) z\_m = (fabs.f64 z) z\_s = (copysign.f64 #s(literal 1 binary64) z) NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function. (FPCore (z_s y_s x_s x_m y_m z_m t a) :precision binary64 (* z_s (* y_s (* x_s (if (<= z_m 1.45e-74) (/ (* y_m (* z_m x_m)) z_m) (* x_m y_m))))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 1.45e-74) {
tmp = (y_m * (z_m * x_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 1.45d-74) then
tmp = (y_m * (z_m * x_m)) / z_m
else
tmp = x_m * y_m
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 1.45e-74) {
tmp = (y_m * (z_m * x_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 1.45e-74: tmp = (y_m * (z_m * x_m)) / z_m else: tmp = x_m * y_m return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 1.45e-74) tmp = Float64(Float64(y_m * Float64(z_m * x_m)) / z_m); else tmp = Float64(x_m * y_m); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 1.45e-74)
tmp = (y_m * (z_m * x_m)) / z_m;
else
tmp = x_m * y_m;
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 1.45e-74], N[(N[(y$95$m * N[(z$95$m * x$95$m), $MachinePrecision]), $MachinePrecision] / z$95$m), $MachinePrecision], N[(x$95$m * y$95$m), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 1.45 \cdot 10^{-74}:\\
\;\;\;\;\frac{y\_m \cdot \left(z\_m \cdot x\_m\right)}{z\_m}\\
\mathbf{else}:\\
\;\;\;\;x\_m \cdot y\_m\\
\end{array}\right)\right)
\end{array}
if z < 1.45e-74Initial program 65.9%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.1%
Simplified66.1%
Taylor expanded in z around inf
Simplified25.5%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6426.0%
Applied egg-rr26.0%
if 1.45e-74 < z Initial program 61.1%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6458.6%
Simplified58.6%
Taylor expanded in z around inf
*-lowering-*.f6483.6%
Simplified83.6%
Final simplification45.1%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) z\_m = (fabs.f64 z) z\_s = (copysign.f64 #s(literal 1 binary64) z) NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function. (FPCore (z_s y_s x_s x_m y_m z_m t a) :precision binary64 (* z_s (* y_s (* x_s (if (<= z_m 7.5e-98) (/ (* z_m (* x_m y_m)) z_m) (* x_m y_m))))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7.5e-98) {
tmp = (z_m * (x_m * y_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 7.5d-98) then
tmp = (z_m * (x_m * y_m)) / z_m
else
tmp = x_m * y_m
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7.5e-98) {
tmp = (z_m * (x_m * y_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 7.5e-98: tmp = (z_m * (x_m * y_m)) / z_m else: tmp = x_m * y_m return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 7.5e-98) tmp = Float64(Float64(z_m * Float64(x_m * y_m)) / z_m); else tmp = Float64(x_m * y_m); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 7.5e-98)
tmp = (z_m * (x_m * y_m)) / z_m;
else
tmp = x_m * y_m;
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 7.5e-98], N[(N[(z$95$m * N[(x$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] / z$95$m), $MachinePrecision], N[(x$95$m * y$95$m), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 7.5 \cdot 10^{-98}:\\
\;\;\;\;\frac{z\_m \cdot \left(x\_m \cdot y\_m\right)}{z\_m}\\
\mathbf{else}:\\
\;\;\;\;x\_m \cdot y\_m\\
\end{array}\right)\right)
\end{array}
if z < 7.5000000000000006e-98Initial program 65.6%
Taylor expanded in z around inf
Simplified24.3%
if 7.5000000000000006e-98 < z Initial program 61.7%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6460.4%
Simplified60.4%
Taylor expanded in z around inf
*-lowering-*.f6481.1%
Simplified81.1%
Final simplification44.0%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) z\_m = (fabs.f64 z) z\_s = (copysign.f64 #s(literal 1 binary64) z) NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function. (FPCore (z_s y_s x_s x_m y_m z_m t a) :precision binary64 (* z_s (* y_s (* x_s (if (<= z_m 7e-98) (/ (* x_m (* z_m y_m)) z_m) (* x_m y_m))))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7e-98) {
tmp = (x_m * (z_m * y_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 7d-98) then
tmp = (x_m * (z_m * y_m)) / z_m
else
tmp = x_m * y_m
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 7e-98) {
tmp = (x_m * (z_m * y_m)) / z_m;
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 7e-98: tmp = (x_m * (z_m * y_m)) / z_m else: tmp = x_m * y_m return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 7e-98) tmp = Float64(Float64(x_m * Float64(z_m * y_m)) / z_m); else tmp = Float64(x_m * y_m); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 7e-98)
tmp = (x_m * (z_m * y_m)) / z_m;
else
tmp = x_m * y_m;
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 7e-98], N[(N[(x$95$m * N[(z$95$m * y$95$m), $MachinePrecision]), $MachinePrecision] / z$95$m), $MachinePrecision], N[(x$95$m * y$95$m), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 7 \cdot 10^{-98}:\\
\;\;\;\;\frac{x\_m \cdot \left(z\_m \cdot y\_m\right)}{z\_m}\\
\mathbf{else}:\\
\;\;\;\;x\_m \cdot y\_m\\
\end{array}\right)\right)
\end{array}
if z < 7.0000000000000004e-98Initial program 65.6%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6465.3%
Simplified65.3%
Taylor expanded in z around inf
Simplified25.4%
if 7.0000000000000004e-98 < z Initial program 61.7%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6460.4%
Simplified60.4%
Taylor expanded in z around inf
*-lowering-*.f6481.1%
Simplified81.1%
Final simplification44.8%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) z\_m = (fabs.f64 z) z\_s = (copysign.f64 #s(literal 1 binary64) z) NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function. (FPCore (z_s y_s x_s x_m y_m z_m t a) :precision binary64 (* z_s (* y_s (* x_s (if (<= z_m 2.2e-183) (* (* z_m x_m) (/ y_m z_m)) (* x_m y_m))))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.2e-183) {
tmp = (z_m * x_m) * (y_m / z_m);
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z_m <= 2.2d-183) then
tmp = (z_m * x_m) * (y_m / z_m)
else
tmp = x_m * y_m
end if
code = z_s * (y_s * (x_s * tmp))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
double tmp;
if (z_m <= 2.2e-183) {
tmp = (z_m * x_m) * (y_m / z_m);
} else {
tmp = x_m * y_m;
}
return z_s * (y_s * (x_s * tmp));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): tmp = 0 if z_m <= 2.2e-183: tmp = (z_m * x_m) * (y_m / z_m) else: tmp = x_m * y_m return z_s * (y_s * (x_s * tmp))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) tmp = 0.0 if (z_m <= 2.2e-183) tmp = Float64(Float64(z_m * x_m) * Float64(y_m / z_m)); else tmp = Float64(x_m * y_m); end return Float64(z_s * Float64(y_s * Float64(x_s * tmp))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp_2 = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = 0.0;
if (z_m <= 2.2e-183)
tmp = (z_m * x_m) * (y_m / z_m);
else
tmp = x_m * y_m;
end
tmp_2 = z_s * (y_s * (x_s * tmp));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * If[LessEqual[z$95$m, 2.2e-183], N[(N[(z$95$m * x$95$m), $MachinePrecision] * N[(y$95$m / z$95$m), $MachinePrecision]), $MachinePrecision], N[(x$95$m * y$95$m), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \begin{array}{l}
\mathbf{if}\;z\_m \leq 2.2 \cdot 10^{-183}:\\
\;\;\;\;\left(z\_m \cdot x\_m\right) \cdot \frac{y\_m}{z\_m}\\
\mathbf{else}:\\
\;\;\;\;x\_m \cdot y\_m\\
\end{array}\right)\right)
\end{array}
if z < 2.2e-183Initial program 63.4%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.6%
Simplified63.6%
Taylor expanded in z around inf
Simplified24.1%
div-invN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6415.5%
Applied egg-rr15.5%
associate-*r*N/A
div-invN/A
*-commutativeN/A
associate-*r/N/A
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6420.3%
Applied egg-rr20.3%
if 2.2e-183 < z Initial program 65.6%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.6%
Simplified63.6%
Taylor expanded in z around inf
*-lowering-*.f6475.2%
Simplified75.2%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) y\_m = (fabs.f64 y) y\_s = (copysign.f64 #s(literal 1 binary64) y) z\_m = (fabs.f64 z) z\_s = (copysign.f64 #s(literal 1 binary64) z) NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function. (FPCore (z_s y_s x_s x_m y_m z_m t a) :precision binary64 (* z_s (* y_s (* x_s (* x_m y_m)))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
y\_m = fabs(y);
y\_s = copysign(1.0, y);
z\_m = fabs(z);
z\_s = copysign(1.0, z);
assert(x_m < y_m && y_m < z_m && z_m < t && t < a);
double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
return z_s * (y_s * (x_s * (x_m * y_m)));
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
y\_m = abs(y)
y\_s = copysign(1.0d0, y)
z\_m = abs(z)
z\_s = copysign(1.0d0, z)
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
real(8) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
real(8), intent (in) :: z_s
real(8), intent (in) :: y_s
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y_m
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
code = z_s * (y_s * (x_s * (x_m * y_m)))
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
y\_m = Math.abs(y);
y\_s = Math.copySign(1.0, y);
z\_m = Math.abs(z);
z\_s = Math.copySign(1.0, z);
assert x_m < y_m && y_m < z_m && z_m < t && t < a;
public static double code(double z_s, double y_s, double x_s, double x_m, double y_m, double z_m, double t, double a) {
return z_s * (y_s * (x_s * (x_m * y_m)));
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) y\_m = math.fabs(y) y\_s = math.copysign(1.0, y) z\_m = math.fabs(z) z\_s = math.copysign(1.0, z) [x_m, y_m, z_m, t, a] = sort([x_m, y_m, z_m, t, a]) def code(z_s, y_s, x_s, x_m, y_m, z_m, t, a): return z_s * (y_s * (x_s * (x_m * y_m)))
x\_m = abs(x) x\_s = copysign(1.0, x) y\_m = abs(y) y\_s = copysign(1.0, y) z\_m = abs(z) z\_s = copysign(1.0, z) x_m, y_m, z_m, t, a = sort([x_m, y_m, z_m, t, a]) function code(z_s, y_s, x_s, x_m, y_m, z_m, t, a) return Float64(z_s * Float64(y_s * Float64(x_s * Float64(x_m * y_m)))) end
x\_m = abs(x);
x\_s = sign(x) * abs(1.0);
y\_m = abs(y);
y\_s = sign(y) * abs(1.0);
z\_m = abs(z);
z\_s = sign(z) * abs(1.0);
x_m, y_m, z_m, t, a = num2cell(sort([x_m, y_m, z_m, t, a])){:}
function tmp = code(z_s, y_s, x_s, x_m, y_m, z_m, t, a)
tmp = z_s * (y_s * (x_s * (x_m * y_m)));
end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $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]
z\_m = N[Abs[z], $MachinePrecision]
z\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[z]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: x_m, y_m, z_m, t, and a should be sorted in increasing order before calling this function.
code[z$95$s_, y$95$s_, x$95$s_, x$95$m_, y$95$m_, z$95$m_, t_, a_] := N[(z$95$s * N[(y$95$s * N[(x$95$s * N[(x$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
y\_m = \left|y\right|
\\
y\_s = \mathsf{copysign}\left(1, y\right)
\\
z\_m = \left|z\right|
\\
z\_s = \mathsf{copysign}\left(1, z\right)
\\
[x_m, y_m, z_m, t, a] = \mathsf{sort}([x_m, y_m, z_m, t, a])\\
\\
z\_s \cdot \left(y\_s \cdot \left(x\_s \cdot \left(x\_m \cdot y\_m\right)\right)\right)
\end{array}
Initial program 64.3%
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.6%
Simplified63.6%
Taylor expanded in z around inf
*-lowering-*.f6439.3%
Simplified39.3%
(FPCore (x y z t a)
:precision binary64
(if (< z -3.1921305903852764e+46)
(- (* y x))
(if (< z 5.976268120920894e+90)
(/ (* x z) (/ (sqrt (- (* z z) (* a t))) y))
(* y x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z < (-3.1921305903852764d+46)) then
tmp = -(y * x)
else if (z < 5.976268120920894d+90) then
tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y)
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z < -3.1921305903852764e+46) {
tmp = -(y * x);
} else if (z < 5.976268120920894e+90) {
tmp = (x * z) / (Math.sqrt(((z * z) - (a * t))) / y);
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z < -3.1921305903852764e+46: tmp = -(y * x) elif z < 5.976268120920894e+90: tmp = (x * z) / (math.sqrt(((z * z) - (a * t))) / y) else: tmp = y * x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z < -3.1921305903852764e+46) tmp = Float64(-Float64(y * x)); elseif (z < 5.976268120920894e+90) tmp = Float64(Float64(x * z) / Float64(sqrt(Float64(Float64(z * z) - Float64(a * t))) / y)); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z < -3.1921305903852764e+46) tmp = -(y * x); elseif (z < 5.976268120920894e+90) tmp = (x * z) / (sqrt(((z * z) - (a * t))) / y); else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Less[z, -3.1921305903852764e+46], (-N[(y * x), $MachinePrecision]), If[Less[z, 5.976268120920894e+90], N[(N[(x * z), $MachinePrecision] / N[(N[Sqrt[N[(N[(z * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z < -3.1921305903852764 \cdot 10^{+46}:\\
\;\;\;\;-y \cdot x\\
\mathbf{elif}\;z < 5.976268120920894 \cdot 10^{+90}:\\
\;\;\;\;\frac{x \cdot z}{\frac{\sqrt{z \cdot z - a \cdot t}}{y}}\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
herbie shell --seed 2024138
(FPCore (x y z t a)
:name "Statistics.Math.RootFinding:ridders from math-functions-0.1.5.2"
:precision binary64
:alt
(! :herbie-platform default (if (< z -31921305903852764000000000000000000000000000000) (- (* y x)) (if (< z 5976268120920894000000000000000000000000000000000000000000000000000000000000000000000000000) (/ (* x z) (/ (sqrt (- (* z z) (* a t))) y)) (* y x))))
(/ (* (* x y) z) (sqrt (- (* z z) (* t a)))))