
(FPCore (x n) :precision binary64 (- (pow (+ x 1.0) (/ 1.0 n)) (pow x (/ 1.0 n))))
double code(double x, double n) {
return pow((x + 1.0), (1.0 / n)) - pow(x, (1.0 / n));
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
code = ((x + 1.0d0) ** (1.0d0 / n)) - (x ** (1.0d0 / n))
end function
public static double code(double x, double n) {
return Math.pow((x + 1.0), (1.0 / n)) - Math.pow(x, (1.0 / n));
}
def code(x, n): return math.pow((x + 1.0), (1.0 / n)) - math.pow(x, (1.0 / n))
function code(x, n) return Float64((Float64(x + 1.0) ^ Float64(1.0 / n)) - (x ^ Float64(1.0 / n))) end
function tmp = code(x, n) tmp = ((x + 1.0) ^ (1.0 / n)) - (x ^ (1.0 / n)); end
code[x_, n_] := N[(N[Power[N[(x + 1.0), $MachinePrecision], N[(1.0 / n), $MachinePrecision]], $MachinePrecision] - N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{\left(x + 1\right)}^{\left(\frac{1}{n}\right)} - {x}^{\left(\frac{1}{n}\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x n) :precision binary64 (- (pow (+ x 1.0) (/ 1.0 n)) (pow x (/ 1.0 n))))
double code(double x, double n) {
return pow((x + 1.0), (1.0 / n)) - pow(x, (1.0 / n));
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
code = ((x + 1.0d0) ** (1.0d0 / n)) - (x ** (1.0d0 / n))
end function
public static double code(double x, double n) {
return Math.pow((x + 1.0), (1.0 / n)) - Math.pow(x, (1.0 / n));
}
def code(x, n): return math.pow((x + 1.0), (1.0 / n)) - math.pow(x, (1.0 / n))
function code(x, n) return Float64((Float64(x + 1.0) ^ Float64(1.0 / n)) - (x ^ Float64(1.0 / n))) end
function tmp = code(x, n) tmp = ((x + 1.0) ^ (1.0 / n)) - (x ^ (1.0 / n)); end
code[x_, n_] := N[(N[Power[N[(x + 1.0), $MachinePrecision], N[(1.0 / n), $MachinePrecision]], $MachinePrecision] - N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{\left(x + 1\right)}^{\left(\frac{1}{n}\right)} - {x}^{\left(\frac{1}{n}\right)}
\end{array}
(FPCore (x n)
:precision binary64
(if (<= x 130.0)
(/
(+
(/
(fma
0.5
(- (pow (log1p x) 2.0) (pow (log x) 2.0))
(/ (* 0.16666666666666666 (- (pow (log1p x) 3.0) (pow (log x) 3.0))) n))
n)
(- (log1p x) (log x)))
n)
(/ (pow x (/ 1.0 n)) (* x n))))
double code(double x, double n) {
double tmp;
if (x <= 130.0) {
tmp = ((fma(0.5, (pow(log1p(x), 2.0) - pow(log(x), 2.0)), ((0.16666666666666666 * (pow(log1p(x), 3.0) - pow(log(x), 3.0))) / n)) / n) + (log1p(x) - log(x))) / n;
} else {
tmp = pow(x, (1.0 / n)) / (x * n);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (x <= 130.0) tmp = Float64(Float64(Float64(fma(0.5, Float64((log1p(x) ^ 2.0) - (log(x) ^ 2.0)), Float64(Float64(0.16666666666666666 * Float64((log1p(x) ^ 3.0) - (log(x) ^ 3.0))) / n)) / n) + Float64(log1p(x) - log(x))) / n); else tmp = Float64((x ^ Float64(1.0 / n)) / Float64(x * n)); end return tmp end
code[x_, n_] := If[LessEqual[x, 130.0], N[(N[(N[(N[(0.5 * N[(N[Power[N[Log[1 + x], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Log[x], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(0.16666666666666666 * N[(N[Power[N[Log[1 + x], $MachinePrecision], 3.0], $MachinePrecision] - N[Power[N[Log[x], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision] + N[(N[Log[1 + x], $MachinePrecision] - N[Log[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision] / N[(x * n), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 130:\\
\;\;\;\;\frac{\frac{\mathsf{fma}\left(0.5, {\left(\mathsf{log1p}\left(x\right)\right)}^{2} - {\log x}^{2}, \frac{0.16666666666666666 \cdot \left({\left(\mathsf{log1p}\left(x\right)\right)}^{3} - {\log x}^{3}\right)}{n}\right)}{n} + \left(\mathsf{log1p}\left(x\right) - \log x\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{{x}^{\left(\frac{1}{n}\right)}}{x \cdot n}\\
\end{array}
\end{array}
if x < 130Initial program 37.6%
Taylor expanded in n around -inf
Simplified85.1%
if 130 < x Initial program 70.9%
Taylor expanded in x around inf
/-lowering-/.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6499.8
Simplified99.8%
Final simplification90.6%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n)))
(t_1 (- (pow (+ x 1.0) (/ 1.0 n)) t_0))
(t_2 (- 1.0 t_0)))
(if (<= t_1 -5e-8) t_2 (if (<= t_1 0.0) (/ (log (/ (+ x 1.0) x)) n) t_2))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double t_1 = pow((x + 1.0), (1.0 / n)) - t_0;
double t_2 = 1.0 - t_0;
double tmp;
if (t_1 <= -5e-8) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = log(((x + 1.0) / x)) / n;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = x ** (1.0d0 / n)
t_1 = ((x + 1.0d0) ** (1.0d0 / n)) - t_0
t_2 = 1.0d0 - t_0
if (t_1 <= (-5d-8)) then
tmp = t_2
else if (t_1 <= 0.0d0) then
tmp = log(((x + 1.0d0) / x)) / n
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = Math.pow(x, (1.0 / n));
double t_1 = Math.pow((x + 1.0), (1.0 / n)) - t_0;
double t_2 = 1.0 - t_0;
double tmp;
if (t_1 <= -5e-8) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = Math.log(((x + 1.0) / x)) / n;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, (1.0 / n)) t_1 = math.pow((x + 1.0), (1.0 / n)) - t_0 t_2 = 1.0 - t_0 tmp = 0 if t_1 <= -5e-8: tmp = t_2 elif t_1 <= 0.0: tmp = math.log(((x + 1.0) / x)) / n else: tmp = t_2 return tmp
function code(x, n) t_0 = x ^ Float64(1.0 / n) t_1 = Float64((Float64(x + 1.0) ^ Float64(1.0 / n)) - t_0) t_2 = Float64(1.0 - t_0) tmp = 0.0 if (t_1 <= -5e-8) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(log(Float64(Float64(x + 1.0) / x)) / n); else tmp = t_2; end return tmp end
function tmp_2 = code(x, n) t_0 = x ^ (1.0 / n); t_1 = ((x + 1.0) ^ (1.0 / n)) - t_0; t_2 = 1.0 - t_0; tmp = 0.0; if (t_1 <= -5e-8) tmp = t_2; elseif (t_1 <= 0.0) tmp = log(((x + 1.0) / x)) / n; else tmp = t_2; end tmp_2 = tmp; end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[N[(x + 1.0), $MachinePrecision], N[(1.0 / n), $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(1.0 - t$95$0), $MachinePrecision]}, If[LessEqual[t$95$1, -5e-8], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[Log[N[(N[(x + 1.0), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
t_1 := {\left(x + 1\right)}^{\left(\frac{1}{n}\right)} - t\_0\\
t_2 := 1 - t\_0\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-8}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{\log \left(\frac{x + 1}{x}\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (-.f64 (pow.f64 (+.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) n)) (pow.f64 x (/.f64 #s(literal 1 binary64) n))) < -4.9999999999999998e-8 or 0.0 < (-.f64 (pow.f64 (+.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) n)) (pow.f64 x (/.f64 #s(literal 1 binary64) n))) Initial program 82.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6479.3
Simplified79.3%
if -4.9999999999999998e-8 < (-.f64 (pow.f64 (+.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) n)) (pow.f64 x (/.f64 #s(literal 1 binary64) n))) < 0.0Initial program 39.1%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6483.7
Simplified83.7%
/-lowering-/.f64N/A
diff-logN/A
+-commutativeN/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6483.7
Applied egg-rr83.7%
Final simplification82.6%
(FPCore (x n)
:precision binary64
(if (<= x 1.0)
(/
(+
(- x (log x))
(/
(fma
-0.16666666666666666
(/ (pow (log x) 3.0) n)
(* (pow (log x) 2.0) -0.5))
n))
n)
(/ (pow x (/ 1.0 n)) (* x n))))
double code(double x, double n) {
double tmp;
if (x <= 1.0) {
tmp = ((x - log(x)) + (fma(-0.16666666666666666, (pow(log(x), 3.0) / n), (pow(log(x), 2.0) * -0.5)) / n)) / n;
} else {
tmp = pow(x, (1.0 / n)) / (x * n);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (x <= 1.0) tmp = Float64(Float64(Float64(x - log(x)) + Float64(fma(-0.16666666666666666, Float64((log(x) ^ 3.0) / n), Float64((log(x) ^ 2.0) * -0.5)) / n)) / n); else tmp = Float64((x ^ Float64(1.0 / n)) / Float64(x * n)); end return tmp end
code[x_, n_] := If[LessEqual[x, 1.0], N[(N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] + N[(N[(-0.16666666666666666 * N[(N[Power[N[Log[x], $MachinePrecision], 3.0], $MachinePrecision] / n), $MachinePrecision] + N[(N[Power[N[Log[x], $MachinePrecision], 2.0], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision] / N[(x * n), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1:\\
\;\;\;\;\frac{\left(x - \log x\right) + \frac{\mathsf{fma}\left(-0.16666666666666666, \frac{{\log x}^{3}}{n}, {\log x}^{2} \cdot -0.5\right)}{n}}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{{x}^{\left(\frac{1}{n}\right)}}{x \cdot n}\\
\end{array}
\end{array}
if x < 1Initial program 37.6%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified25.8%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6436.8
Simplified36.8%
Taylor expanded in n around inf
Simplified84.6%
if 1 < x Initial program 70.9%
Taylor expanded in x around inf
/-lowering-/.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6499.8
Simplified99.8%
Final simplification90.3%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -9e-59)
(/ (pow x (/ 1.0 n)) (* x n))
(if (<= (/ 1.0 n) 5e-26)
(/ (log (/ (+ x 1.0) x)) n)
(if (<= (/ 1.0 n) 1e+209)
(fma x (/ -1.0 (* x (pow x (/ -1.0 n)))) (+ 1.0 (/ x n)))
(+
-1.0
(fma x (fma x (+ (/ 0.5 (* n n)) (/ -0.5 n)) (/ 1.0 n)) 1.0))))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -9e-59) {
tmp = pow(x, (1.0 / n)) / (x * n);
} else if ((1.0 / n) <= 5e-26) {
tmp = log(((x + 1.0) / x)) / n;
} else if ((1.0 / n) <= 1e+209) {
tmp = fma(x, (-1.0 / (x * pow(x, (-1.0 / n)))), (1.0 + (x / n)));
} else {
tmp = -1.0 + fma(x, fma(x, ((0.5 / (n * n)) + (-0.5 / n)), (1.0 / n)), 1.0);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -9e-59) tmp = Float64((x ^ Float64(1.0 / n)) / Float64(x * n)); elseif (Float64(1.0 / n) <= 5e-26) tmp = Float64(log(Float64(Float64(x + 1.0) / x)) / n); elseif (Float64(1.0 / n) <= 1e+209) tmp = fma(x, Float64(-1.0 / Float64(x * (x ^ Float64(-1.0 / n)))), Float64(1.0 + Float64(x / n))); else tmp = Float64(-1.0 + fma(x, fma(x, Float64(Float64(0.5 / Float64(n * n)) + Float64(-0.5 / n)), Float64(1.0 / n)), 1.0)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -9e-59], N[(N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision] / N[(x * n), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 5e-26], N[(N[Log[N[(N[(x + 1.0), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+209], N[(x * N[(-1.0 / N[(x * N[Power[x, N[(-1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 + N[(x / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 + N[(x * N[(x * N[(N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -9 \cdot 10^{-59}:\\
\;\;\;\;\frac{{x}^{\left(\frac{1}{n}\right)}}{x \cdot n}\\
\mathbf{elif}\;\frac{1}{n} \leq 5 \cdot 10^{-26}:\\
\;\;\;\;\frac{\log \left(\frac{x + 1}{x}\right)}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+209}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{-1}{x \cdot {x}^{\left(\frac{-1}{n}\right)}}, 1 + \frac{x}{n}\right)\\
\mathbf{else}:\\
\;\;\;\;-1 + \mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{0.5}{n \cdot n} + \frac{-0.5}{n}, \frac{1}{n}\right), 1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -9.00000000000000023e-59Initial program 79.9%
Taylor expanded in x around inf
/-lowering-/.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6488.8
Simplified88.8%
if -9.00000000000000023e-59 < (/.f64 #s(literal 1 binary64) n) < 5.00000000000000019e-26Initial program 27.9%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6486.7
Simplified86.7%
/-lowering-/.f64N/A
diff-logN/A
+-commutativeN/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6486.7
Applied egg-rr86.7%
if 5.00000000000000019e-26 < (/.f64 #s(literal 1 binary64) n) < 1.0000000000000001e209Initial program 89.5%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified63.2%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6489.8
Simplified89.8%
Taylor expanded in x around inf
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
distribute-rgt-inN/A
lft-mult-inverseN/A
associate-*l/N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Simplified89.8%
if 1.0000000000000001e209 < (/.f64 #s(literal 1 binary64) n) Initial program 23.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified92.5%
Taylor expanded in n around inf
Simplified92.5%
Final simplification88.0%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -9e-59)
(/ t_0 (* x n))
(if (<= (/ 1.0 n) 5e-26)
(/ (log (/ (+ x 1.0) x)) n)
(if (<= (/ 1.0 n) 1e+209)
(+ (/ x n) (- 1.0 t_0))
(+
-1.0
(fma x (fma x (+ (/ 0.5 (* n n)) (/ -0.5 n)) (/ 1.0 n)) 1.0)))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -9e-59) {
tmp = t_0 / (x * n);
} else if ((1.0 / n) <= 5e-26) {
tmp = log(((x + 1.0) / x)) / n;
} else if ((1.0 / n) <= 1e+209) {
tmp = (x / n) + (1.0 - t_0);
} else {
tmp = -1.0 + fma(x, fma(x, ((0.5 / (n * n)) + (-0.5 / n)), (1.0 / n)), 1.0);
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -9e-59) tmp = Float64(t_0 / Float64(x * n)); elseif (Float64(1.0 / n) <= 5e-26) tmp = Float64(log(Float64(Float64(x + 1.0) / x)) / n); elseif (Float64(1.0 / n) <= 1e+209) tmp = Float64(Float64(x / n) + Float64(1.0 - t_0)); else tmp = Float64(-1.0 + fma(x, fma(x, Float64(Float64(0.5 / Float64(n * n)) + Float64(-0.5 / n)), Float64(1.0 / n)), 1.0)); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(1.0 / n), $MachinePrecision], -9e-59], N[(t$95$0 / N[(x * n), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 5e-26], N[(N[Log[N[(N[(x + 1.0), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+209], N[(N[(x / n), $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision], N[(-1.0 + N[(x * N[(x * N[(N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -9 \cdot 10^{-59}:\\
\;\;\;\;\frac{t\_0}{x \cdot n}\\
\mathbf{elif}\;\frac{1}{n} \leq 5 \cdot 10^{-26}:\\
\;\;\;\;\frac{\log \left(\frac{x + 1}{x}\right)}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+209}:\\
\;\;\;\;\frac{x}{n} + \left(1 - t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;-1 + \mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{0.5}{n \cdot n} + \frac{-0.5}{n}, \frac{1}{n}\right), 1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -9.00000000000000023e-59Initial program 79.9%
Taylor expanded in x around inf
/-lowering-/.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6488.8
Simplified88.8%
if -9.00000000000000023e-59 < (/.f64 #s(literal 1 binary64) n) < 5.00000000000000019e-26Initial program 27.9%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6486.7
Simplified86.7%
/-lowering-/.f64N/A
diff-logN/A
+-commutativeN/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6486.7
Applied egg-rr86.7%
if 5.00000000000000019e-26 < (/.f64 #s(literal 1 binary64) n) < 1.0000000000000001e209Initial program 89.5%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified63.2%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f6489.8
Simplified89.8%
associate--l+N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f6489.8
Applied egg-rr89.8%
if 1.0000000000000001e209 < (/.f64 #s(literal 1 binary64) n) Initial program 23.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified92.5%
Taylor expanded in n around inf
Simplified92.5%
Final simplification88.0%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -9e-59)
(/ t_0 (* x n))
(if (<= (/ 1.0 n) 5e-26)
(/ (log (/ (+ x 1.0) x)) n)
(if (<= (/ 1.0 n) 1e+209)
(- 1.0 t_0)
(+
-1.0
(fma x (fma x (+ (/ 0.5 (* n n)) (/ -0.5 n)) (/ 1.0 n)) 1.0)))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -9e-59) {
tmp = t_0 / (x * n);
} else if ((1.0 / n) <= 5e-26) {
tmp = log(((x + 1.0) / x)) / n;
} else if ((1.0 / n) <= 1e+209) {
tmp = 1.0 - t_0;
} else {
tmp = -1.0 + fma(x, fma(x, ((0.5 / (n * n)) + (-0.5 / n)), (1.0 / n)), 1.0);
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -9e-59) tmp = Float64(t_0 / Float64(x * n)); elseif (Float64(1.0 / n) <= 5e-26) tmp = Float64(log(Float64(Float64(x + 1.0) / x)) / n); elseif (Float64(1.0 / n) <= 1e+209) tmp = Float64(1.0 - t_0); else tmp = Float64(-1.0 + fma(x, fma(x, Float64(Float64(0.5 / Float64(n * n)) + Float64(-0.5 / n)), Float64(1.0 / n)), 1.0)); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(1.0 / n), $MachinePrecision], -9e-59], N[(t$95$0 / N[(x * n), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 5e-26], N[(N[Log[N[(N[(x + 1.0), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+209], N[(1.0 - t$95$0), $MachinePrecision], N[(-1.0 + N[(x * N[(x * N[(N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -9 \cdot 10^{-59}:\\
\;\;\;\;\frac{t\_0}{x \cdot n}\\
\mathbf{elif}\;\frac{1}{n} \leq 5 \cdot 10^{-26}:\\
\;\;\;\;\frac{\log \left(\frac{x + 1}{x}\right)}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+209}:\\
\;\;\;\;1 - t\_0\\
\mathbf{else}:\\
\;\;\;\;-1 + \mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{0.5}{n \cdot n} + \frac{-0.5}{n}, \frac{1}{n}\right), 1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -9.00000000000000023e-59Initial program 79.9%
Taylor expanded in x around inf
/-lowering-/.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6488.8
Simplified88.8%
if -9.00000000000000023e-59 < (/.f64 #s(literal 1 binary64) n) < 5.00000000000000019e-26Initial program 27.9%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6486.7
Simplified86.7%
/-lowering-/.f64N/A
diff-logN/A
+-commutativeN/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6486.7
Applied egg-rr86.7%
if 5.00000000000000019e-26 < (/.f64 #s(literal 1 binary64) n) < 1.0000000000000001e209Initial program 89.5%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6489.4
Simplified89.4%
if 1.0000000000000001e209 < (/.f64 #s(literal 1 binary64) n) Initial program 23.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified92.5%
Taylor expanded in n around inf
Simplified92.5%
Final simplification87.9%
(FPCore (x n)
:precision binary64
(if (<= x 0.85)
(/ (- x (log x)) n)
(if (<= x 1.3e+85)
(/ (fma (/ 1.0 (* x n)) (+ -0.5 (/ 0.3333333333333333 x)) (/ 1.0 n)) x)
0.0)))
double code(double x, double n) {
double tmp;
if (x <= 0.85) {
tmp = (x - log(x)) / n;
} else if (x <= 1.3e+85) {
tmp = fma((1.0 / (x * n)), (-0.5 + (0.3333333333333333 / x)), (1.0 / n)) / x;
} else {
tmp = 0.0;
}
return tmp;
}
function code(x, n) tmp = 0.0 if (x <= 0.85) tmp = Float64(Float64(x - log(x)) / n); elseif (x <= 1.3e+85) tmp = Float64(fma(Float64(1.0 / Float64(x * n)), Float64(-0.5 + Float64(0.3333333333333333 / x)), Float64(1.0 / n)) / x); else tmp = 0.0; end return tmp end
code[x_, n_] := If[LessEqual[x, 0.85], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[x, 1.3e+85], N[(N[(N[(1.0 / N[(x * n), $MachinePrecision]), $MachinePrecision] * N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.85:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{+85}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{1}{x \cdot n}, -0.5 + \frac{0.3333333333333333}{x}, \frac{1}{n}\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 0.849999999999999978Initial program 37.6%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6461.5
Simplified61.5%
Taylor expanded in x around 0
--lowering--.f64N/A
log-lowering-log.f6461.1
Simplified61.1%
if 0.849999999999999978 < x < 1.30000000000000005e85Initial program 45.3%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6437.1
Simplified37.1%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-fracN/A
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
remove-double-negN/A
/-lowering-/.f64N/A
Simplified63.2%
if 1.30000000000000005e85 < x Initial program 79.3%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6444.8
Simplified44.8%
Taylor expanded in n around inf
Simplified79.3%
metadata-eval79.3
Applied egg-rr79.3%
(FPCore (x n)
:precision binary64
(if (<= x 0.6)
(- (/ (log x) n))
(if (<= x 1.3e+84)
(/ (fma (/ 1.0 (* x n)) (+ -0.5 (/ 0.3333333333333333 x)) (/ 1.0 n)) x)
0.0)))
double code(double x, double n) {
double tmp;
if (x <= 0.6) {
tmp = -(log(x) / n);
} else if (x <= 1.3e+84) {
tmp = fma((1.0 / (x * n)), (-0.5 + (0.3333333333333333 / x)), (1.0 / n)) / x;
} else {
tmp = 0.0;
}
return tmp;
}
function code(x, n) tmp = 0.0 if (x <= 0.6) tmp = Float64(-Float64(log(x) / n)); elseif (x <= 1.3e+84) tmp = Float64(fma(Float64(1.0 / Float64(x * n)), Float64(-0.5 + Float64(0.3333333333333333 / x)), Float64(1.0 / n)) / x); else tmp = 0.0; end return tmp end
code[x_, n_] := If[LessEqual[x, 0.6], (-N[(N[Log[x], $MachinePrecision] / n), $MachinePrecision]), If[LessEqual[x, 1.3e+84], N[(N[(N[(1.0 / N[(x * n), $MachinePrecision]), $MachinePrecision] * N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.6:\\
\;\;\;\;-\frac{\log x}{n}\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{+84}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{1}{x \cdot n}, -0.5 + \frac{0.3333333333333333}{x}, \frac{1}{n}\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 0.599999999999999978Initial program 37.6%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6436.4
Simplified36.4%
Taylor expanded in n around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
log-lowering-log.f6461.0
Simplified61.0%
if 0.599999999999999978 < x < 1.3000000000000001e84Initial program 45.3%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6437.1
Simplified37.1%
Taylor expanded in x around -inf
mul-1-negN/A
distribute-neg-fracN/A
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
remove-double-negN/A
/-lowering-/.f64N/A
Simplified63.2%
if 1.3000000000000001e84 < x Initial program 79.3%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6444.8
Simplified44.8%
Taylor expanded in n around inf
Simplified79.3%
metadata-eval79.3
Applied egg-rr79.3%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -5e+147)
(/ (/ (+ 1.0 (/ (+ -0.5 (/ 0.3333333333333333 x)) x)) x) n)
(if (<= (/ 1.0 n) -5000000000.0)
0.0
(if (<= (/ 1.0 n) 5e+154)
(/ 1.0 (* x (fma 0.5 (/ n x) n)))
(+
-1.0
(fma x (fma x (+ (/ 0.5 (* n n)) (/ -0.5 n)) (/ 1.0 n)) 1.0))))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5e+147) {
tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / x) / n;
} else if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else if ((1.0 / n) <= 5e+154) {
tmp = 1.0 / (x * fma(0.5, (n / x), n));
} else {
tmp = -1.0 + fma(x, fma(x, ((0.5 / (n * n)) + (-0.5 / n)), (1.0 / n)), 1.0);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -5e+147) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(-0.5 + Float64(0.3333333333333333 / x)) / x)) / x) / n); elseif (Float64(1.0 / n) <= -5000000000.0) tmp = 0.0; elseif (Float64(1.0 / n) <= 5e+154) tmp = Float64(1.0 / Float64(x * fma(0.5, Float64(n / x), n))); else tmp = Float64(-1.0 + fma(x, fma(x, Float64(Float64(0.5 / Float64(n * n)) + Float64(-0.5 / n)), Float64(1.0 / n)), 1.0)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -5e+147], N[(N[(N[(1.0 + N[(N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000000000.0], 0.0, If[LessEqual[N[(1.0 / n), $MachinePrecision], 5e+154], N[(1.0 / N[(x * N[(0.5 * N[(n / x), $MachinePrecision] + n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 + N[(x * N[(x * N[(N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{+147}:\\
\;\;\;\;\frac{\frac{1 + \frac{-0.5 + \frac{0.3333333333333333}{x}}{x}}{x}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq -5000000000:\\
\;\;\;\;0\\
\mathbf{elif}\;\frac{1}{n} \leq 5 \cdot 10^{+154}:\\
\;\;\;\;\frac{1}{x \cdot \mathsf{fma}\left(0.5, \frac{n}{x}, n\right)}\\
\mathbf{else}:\\
\;\;\;\;-1 + \mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{0.5}{n \cdot n} + \frac{-0.5}{n}, \frac{1}{n}\right), 1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5.0000000000000002e147Initial program 100.0%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6446.4
Simplified46.4%
Taylor expanded in x around inf
/-lowering-/.f64N/A
associate--l+N/A
unpow2N/A
associate-/r*N/A
metadata-evalN/A
associate-*r/N/A
associate-*r/N/A
metadata-evalN/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6456.2
Simplified56.2%
if -5.0000000000000002e147 < (/.f64 #s(literal 1 binary64) n) < -5e9Initial program 100.0%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6431.4
Simplified31.4%
Taylor expanded in n around inf
Simplified71.3%
metadata-eval71.3
Applied egg-rr71.3%
if -5e9 < (/.f64 #s(literal 1 binary64) n) < 5.00000000000000004e154Initial program 32.3%
flip--N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f6432.3
Applied egg-rr32.3%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6475.1
Simplified75.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6442.0
Simplified42.0%
if 5.00000000000000004e154 < (/.f64 #s(literal 1 binary64) n) Initial program 45.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified66.1%
Taylor expanded in n around inf
Simplified66.1%
Final simplification48.9%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -5000000000.0)
0.0
(if (<= (/ 1.0 n) 5e+154)
(/ 1.0 (* x (fma 0.5 (/ n x) n)))
(* (+ (/ 0.5 (* n n)) (/ -0.5 n)) (* x x)))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else if ((1.0 / n) <= 5e+154) {
tmp = 1.0 / (x * fma(0.5, (n / x), n));
} else {
tmp = ((0.5 / (n * n)) + (-0.5 / n)) * (x * x);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -5000000000.0) tmp = 0.0; elseif (Float64(1.0 / n) <= 5e+154) tmp = Float64(1.0 / Float64(x * fma(0.5, Float64(n / x), n))); else tmp = Float64(Float64(Float64(0.5 / Float64(n * n)) + Float64(-0.5 / n)) * Float64(x * x)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000000000.0], 0.0, If[LessEqual[N[(1.0 / n), $MachinePrecision], 5e+154], N[(1.0 / N[(x * N[(0.5 * N[(n / x), $MachinePrecision] + n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / n), $MachinePrecision]), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -5000000000:\\
\;\;\;\;0\\
\mathbf{elif}\;\frac{1}{n} \leq 5 \cdot 10^{+154}:\\
\;\;\;\;\frac{1}{x \cdot \mathsf{fma}\left(0.5, \frac{n}{x}, n\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{0.5}{n \cdot n} + \frac{-0.5}{n}\right) \cdot \left(x \cdot x\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e9Initial program 100.0%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6448.5
Simplified48.5%
Taylor expanded in n around inf
Simplified53.9%
metadata-eval53.9
Applied egg-rr53.9%
if -5e9 < (/.f64 #s(literal 1 binary64) n) < 5.00000000000000004e154Initial program 32.3%
flip--N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f6432.3
Applied egg-rr32.3%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6475.1
Simplified75.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6442.0
Simplified42.0%
if 5.00000000000000004e154 < (/.f64 #s(literal 1 binary64) n) Initial program 45.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified66.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f6450.0
Simplified50.0%
Final simplification45.6%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -5000000000.0)
0.0
(if (<= (/ 1.0 n) 1e+209)
(/ 1.0 (* x (fma 0.5 (/ n x) n)))
(/ (* 0.5 (* x x)) (* n n)))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else if ((1.0 / n) <= 1e+209) {
tmp = 1.0 / (x * fma(0.5, (n / x), n));
} else {
tmp = (0.5 * (x * x)) / (n * n);
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -5000000000.0) tmp = 0.0; elseif (Float64(1.0 / n) <= 1e+209) tmp = Float64(1.0 / Float64(x * fma(0.5, Float64(n / x), n))); else tmp = Float64(Float64(0.5 * Float64(x * x)) / Float64(n * n)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000000000.0], 0.0, If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+209], N[(1.0 / N[(x * N[(0.5 * N[(n / x), $MachinePrecision] + n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.5 * N[(x * x), $MachinePrecision]), $MachinePrecision] / N[(n * n), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -5000000000:\\
\;\;\;\;0\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+209}:\\
\;\;\;\;\frac{1}{x \cdot \mathsf{fma}\left(0.5, \frac{n}{x}, n\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5 \cdot \left(x \cdot x\right)}{n \cdot n}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e9Initial program 100.0%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6448.5
Simplified48.5%
Taylor expanded in n around inf
Simplified53.9%
metadata-eval53.9
Applied egg-rr53.9%
if -5e9 < (/.f64 #s(literal 1 binary64) n) < 1.0000000000000001e209Initial program 34.4%
flip--N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip--N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
/-lowering-/.f6434.4
Applied egg-rr34.4%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6472.3
Simplified72.3%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6440.6
Simplified40.6%
if 1.0000000000000001e209 < (/.f64 #s(literal 1 binary64) n) Initial program 23.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
Simplified92.5%
Taylor expanded in n around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6469.2
Simplified69.2%
(FPCore (x n) :precision binary64 (if (<= x 2.35e+85) (/ (/ (+ 1.0 (/ (+ -0.5 (/ 0.3333333333333333 x)) x)) x) n) 0.0))
double code(double x, double n) {
double tmp;
if (x <= 2.35e+85) {
tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / x) / n;
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if (x <= 2.35d+85) then
tmp = ((1.0d0 + (((-0.5d0) + (0.3333333333333333d0 / x)) / x)) / x) / n
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 2.35e+85) {
tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / x) / n;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 2.35e+85: tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / x) / n else: tmp = 0.0 return tmp
function code(x, n) tmp = 0.0 if (x <= 2.35e+85) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(-0.5 + Float64(0.3333333333333333 / x)) / x)) / x) / n); else tmp = 0.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 2.35e+85) tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / x) / n; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 2.35e+85], N[(N[(N[(1.0 + N[(N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 2.35 \cdot 10^{+85}:\\
\;\;\;\;\frac{\frac{1 + \frac{-0.5 + \frac{0.3333333333333333}{x}}{x}}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 2.3500000000000001e85Initial program 38.6%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6458.3
Simplified58.3%
Taylor expanded in x around inf
/-lowering-/.f64N/A
associate--l+N/A
unpow2N/A
associate-/r*N/A
metadata-evalN/A
associate-*r/N/A
associate-*r/N/A
metadata-evalN/A
div-subN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6431.8
Simplified31.8%
if 2.3500000000000001e85 < x Initial program 79.3%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6444.8
Simplified44.8%
Taylor expanded in n around inf
Simplified79.3%
metadata-eval79.3
Applied egg-rr79.3%
(FPCore (x n) :precision binary64 (if (<= (/ 1.0 n) -5000000000.0) 0.0 (/ (/ 1.0 x) n)))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else {
tmp = (1.0 / x) / n;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if ((1.0d0 / n) <= (-5000000000.0d0)) then
tmp = 0.0d0
else
tmp = (1.0d0 / x) / n
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else {
tmp = (1.0 / x) / n;
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -5000000000.0: tmp = 0.0 else: tmp = (1.0 / x) / n return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -5000000000.0) tmp = 0.0; else tmp = Float64(Float64(1.0 / x) / n); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -5000000000.0) tmp = 0.0; else tmp = (1.0 / x) / n; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000000000.0], 0.0, N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -5000000000:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e9Initial program 100.0%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6448.5
Simplified48.5%
Taylor expanded in n around inf
Simplified53.9%
metadata-eval53.9
Applied egg-rr53.9%
if -5e9 < (/.f64 #s(literal 1 binary64) n) Initial program 33.6%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6468.1
Simplified68.1%
Taylor expanded in x around inf
/-lowering-/.f6438.9
Simplified38.9%
(FPCore (x n) :precision binary64 (if (<= (/ 1.0 n) -5000000000.0) 0.0 (/ 1.0 (* x n))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else {
tmp = 1.0 / (x * n);
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if ((1.0d0 / n) <= (-5000000000.0d0)) then
tmp = 0.0d0
else
tmp = 1.0d0 / (x * n)
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -5000000000.0) {
tmp = 0.0;
} else {
tmp = 1.0 / (x * n);
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -5000000000.0: tmp = 0.0 else: tmp = 1.0 / (x * n) return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -5000000000.0) tmp = 0.0; else tmp = Float64(1.0 / Float64(x * n)); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -5000000000.0) tmp = 0.0; else tmp = 1.0 / (x * n); end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000000000.0], 0.0, N[(1.0 / N[(x * n), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -5000000000:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{x \cdot n}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e9Initial program 100.0%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6448.5
Simplified48.5%
Taylor expanded in n around inf
Simplified53.9%
metadata-eval53.9
Applied egg-rr53.9%
if -5e9 < (/.f64 #s(literal 1 binary64) n) Initial program 33.6%
Taylor expanded in n around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
accelerator-lowering-log1p.f64N/A
log-lowering-log.f6468.1
Simplified68.1%
Taylor expanded in x around inf
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6438.9
Simplified38.9%
(FPCore (x n) :precision binary64 0.0)
double code(double x, double n) {
return 0.0;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
code = 0.0d0
end function
public static double code(double x, double n) {
return 0.0;
}
def code(x, n): return 0.0
function code(x, n) return 0.0 end
function tmp = code(x, n) tmp = 0.0; end
code[x_, n_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 50.2%
Taylor expanded in x around 0
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
--lowering--.f64N/A
log-recN/A
mul-1-negN/A
associate-*r/N/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-/l*N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
/-lowering-/.f6436.2
Simplified36.2%
Taylor expanded in n around inf
Simplified29.3%
metadata-eval29.3
Applied egg-rr29.3%
herbie shell --seed 2024198
(FPCore (x n)
:name "2nthrt (problem 3.4.6)"
:precision binary64
(- (pow (+ x 1.0) (/ 1.0 n)) (pow x (/ 1.0 n))))