
(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 22 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
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 2e-11)
(/
(-
(fma 0.5 (/ (- (pow (log1p x) 2.0) (pow (log x) 2.0)) n) (log1p x))
(log x))
n)
(- (exp (/ (log1p x) n)) t_0)))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 2e-11) {
tmp = (fma(0.5, ((pow(log1p(x), 2.0) - pow(log(x), 2.0)) / n), log1p(x)) - log(x)) / n;
} else {
tmp = exp((log1p(x) / n)) - t_0;
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 2e-11) tmp = Float64(Float64(fma(0.5, Float64(Float64((log1p(x) ^ 2.0) - (log(x) ^ 2.0)) / n), log1p(x)) - log(x)) / n); else tmp = Float64(exp(Float64(log1p(x) / n)) - t_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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e-11], N[(N[(N[(0.5 * N[(N[(N[Power[N[Log[1 + x], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Log[x], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision] + N[Log[1 + x], $MachinePrecision]), $MachinePrecision] - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Exp[N[(N[Log[1 + x], $MachinePrecision] / n), $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{-11}:\\
\;\;\;\;\frac{\mathsf{fma}\left(0.5, \frac{{\left(\mathsf{log1p}\left(x\right)\right)}^{2} - {\log x}^{2}}{n}, \mathsf{log1p}\left(x\right)\right) - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;e^{\frac{\mathsf{log1p}\left(x\right)}{n}} - t\_0\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 1.99999999999999988e-11Initial program 23.7%
Taylor expanded in n around inf
lower-/.f64N/A
Applied rewrites84.3%
if 1.99999999999999988e-11 < (/.f64 #s(literal 1 binary64) n) Initial program 52.5%
lift-+.f64N/A
lift-/.f64N/A
pow-to-expN/A
lower-exp.f64N/A
lift-/.f64N/A
un-div-invN/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-log1p.f6495.2
Applied rewrites95.2%
Final simplification89.6%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n)))
(t_1 (- (pow (+ 1.0 x) (/ 1.0 n)) t_0))
(t_2 (- 1.0 t_0)))
(if (<= t_1 -0.005)
t_2
(if (<= t_1 5e-9) (/ (log (/ (+ 1.0 x) x)) n) t_2))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double t_1 = pow((1.0 + x), (1.0 / n)) - t_0;
double t_2 = 1.0 - t_0;
double tmp;
if (t_1 <= -0.005) {
tmp = t_2;
} else if (t_1 <= 5e-9) {
tmp = log(((1.0 + x) / 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 = ((1.0d0 + x) ** (1.0d0 / n)) - t_0
t_2 = 1.0d0 - t_0
if (t_1 <= (-0.005d0)) then
tmp = t_2
else if (t_1 <= 5d-9) then
tmp = log(((1.0d0 + x) / 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((1.0 + x), (1.0 / n)) - t_0;
double t_2 = 1.0 - t_0;
double tmp;
if (t_1 <= -0.005) {
tmp = t_2;
} else if (t_1 <= 5e-9) {
tmp = Math.log(((1.0 + x) / x)) / n;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, (1.0 / n)) t_1 = math.pow((1.0 + x), (1.0 / n)) - t_0 t_2 = 1.0 - t_0 tmp = 0 if t_1 <= -0.005: tmp = t_2 elif t_1 <= 5e-9: tmp = math.log(((1.0 + x) / x)) / n else: tmp = t_2 return tmp
function code(x, n) t_0 = x ^ Float64(1.0 / n) t_1 = Float64((Float64(1.0 + x) ^ Float64(1.0 / n)) - t_0) t_2 = Float64(1.0 - t_0) tmp = 0.0 if (t_1 <= -0.005) tmp = t_2; elseif (t_1 <= 5e-9) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); else tmp = t_2; end return tmp end
function tmp_2 = code(x, n) t_0 = x ^ (1.0 / n); t_1 = ((1.0 + x) ^ (1.0 / n)) - t_0; t_2 = 1.0 - t_0; tmp = 0.0; if (t_1 <= -0.005) tmp = t_2; elseif (t_1 <= 5e-9) tmp = log(((1.0 + x) / 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[(1.0 + x), $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, -0.005], t$95$2, If[LessEqual[t$95$1, 5e-9], N[(N[Log[N[(N[(1.0 + x), $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(1 + x\right)}^{\left(\frac{1}{n}\right)} - t\_0\\
t_2 := 1 - t\_0\\
\mathbf{if}\;t\_1 \leq -0.005:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{-9}:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{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))) < -0.0050000000000000001 or 5.0000000000000001e-9 < (-.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 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
lower--.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
lower-pow.f64N/A
lower-/.f6477.0
Applied rewrites77.0%
if -0.0050000000000000001 < (-.f64 (pow.f64 (+.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) n)) (pow.f64 x (/.f64 #s(literal 1 binary64) n))) < 5.0000000000000001e-9Initial program 39.1%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6482.7
Applied rewrites82.7%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6482.7
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6482.3
Applied rewrites82.3%
Final simplification80.6%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 2e-11)
(/ (log (/ (+ 1.0 x) x)) n)
(- (exp (/ (log1p x) n)) t_0)))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 2e-11) {
tmp = log(((1.0 + x) / x)) / n;
} else {
tmp = exp((log1p(x) / n)) - t_0;
}
return tmp;
}
public static double code(double x, double n) {
double t_0 = Math.pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 2e-11) {
tmp = Math.log(((1.0 + x) / x)) / n;
} else {
tmp = Math.exp((Math.log1p(x) / n)) - t_0;
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, (1.0 / n)) tmp = 0 if (1.0 / n) <= -5e-71: tmp = t_0 / (n * x) elif (1.0 / n) <= 2e-11: tmp = math.log(((1.0 + x) / x)) / n else: tmp = math.exp((math.log1p(x) / n)) - t_0 return tmp
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 2e-11) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); else tmp = Float64(exp(Float64(log1p(x) / n)) - t_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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e-11], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], N[(N[Exp[N[(N[Log[1 + x], $MachinePrecision] / n), $MachinePrecision]], $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{-11}:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;e^{\frac{\mathsf{log1p}\left(x\right)}{n}} - t\_0\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 1.99999999999999988e-11Initial program 23.7%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6484.0
Applied rewrites84.0%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6484.0
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6484.2
Applied rewrites84.2%
if 1.99999999999999988e-11 < (/.f64 #s(literal 1 binary64) n) Initial program 52.5%
lift-+.f64N/A
lift-/.f64N/A
pow-to-expN/A
lower-exp.f64N/A
lift-/.f64N/A
un-div-invN/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-log1p.f6495.2
Applied rewrites95.2%
Final simplification89.6%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 0.05)
(/ (log (/ (+ 1.0 x) x)) n)
(fma
x
(/
(-
(/ (fma x (fma -0.5 x 0.5) (* (/ (* x x) n) 0.16666666666666666)) n)
(fma x (fma x -0.3333333333333333 0.5) -1.0))
n)
(- 1.0 t_0))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 0.05) {
tmp = log(((1.0 + x) / x)) / n;
} else {
tmp = fma(x, (((fma(x, fma(-0.5, x, 0.5), (((x * x) / n) * 0.16666666666666666)) / n) - fma(x, fma(x, -0.3333333333333333, 0.5), -1.0)) / n), (1.0 - t_0));
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 0.05) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); else tmp = fma(x, Float64(Float64(Float64(fma(x, fma(-0.5, x, 0.5), Float64(Float64(Float64(x * x) / n) * 0.16666666666666666)) / n) - fma(x, fma(x, -0.3333333333333333, 0.5), -1.0)) / n), Float64(1.0 - t_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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 0.05], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], N[(x * N[(N[(N[(N[(x * N[(-0.5 * x + 0.5), $MachinePrecision] + N[(N[(N[(x * x), $MachinePrecision] / n), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision] - N[(x * N[(x * -0.3333333333333333 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 0.05:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{\frac{\mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, x, 0.5\right), \frac{x \cdot x}{n} \cdot 0.16666666666666666\right)}{n} - \mathsf{fma}\left(x, \mathsf{fma}\left(x, -0.3333333333333333, 0.5\right), -1\right)}{n}, 1 - t\_0\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 0.050000000000000003Initial program 23.4%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6482.7
Applied rewrites82.7%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6482.7
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6482.9
Applied rewrites82.9%
if 0.050000000000000003 < (/.f64 #s(literal 1 binary64) n) Initial program 55.1%
Taylor expanded in x around 0
Applied rewrites29.6%
Taylor expanded in n around -inf
mul-1-negN/A
distribute-neg-frac2N/A
lower-/.f64N/A
Applied rewrites79.8%
Final simplification86.6%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 0.05)
(/ (log (/ (+ 1.0 x) x)) n)
(fma
x
(/
(fma x (+ (fma x 0.3333333333333333 -0.5) (/ (fma -0.5 x 0.5) n)) 1.0)
n)
(- 1.0 t_0))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 0.05) {
tmp = log(((1.0 + x) / x)) / n;
} else {
tmp = fma(x, (fma(x, (fma(x, 0.3333333333333333, -0.5) + (fma(-0.5, x, 0.5) / n)), 1.0) / n), (1.0 - t_0));
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 0.05) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); else tmp = fma(x, Float64(fma(x, Float64(fma(x, 0.3333333333333333, -0.5) + Float64(fma(-0.5, x, 0.5) / n)), 1.0) / n), Float64(1.0 - t_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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 0.05], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], N[(x * N[(N[(x * N[(N[(x * 0.3333333333333333 + -0.5), $MachinePrecision] + N[(N[(-0.5 * x + 0.5), $MachinePrecision] / n), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / n), $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 0.05:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.3333333333333333, -0.5\right) + \frac{\mathsf{fma}\left(-0.5, x, 0.5\right)}{n}, 1\right)}{n}, 1 - t\_0\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 0.050000000000000003Initial program 23.4%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6482.7
Applied rewrites82.7%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6482.7
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6482.9
Applied rewrites82.9%
if 0.050000000000000003 < (/.f64 #s(literal 1 binary64) n) Initial program 55.1%
Taylor expanded in x around 0
Applied rewrites29.6%
Taylor expanded in n around inf
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
distribute-lft-outN/A
lower-fma.f64N/A
lower-+.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-fma.f6474.6
Applied rewrites74.6%
Final simplification85.8%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 0.05)
(/ (log (/ (+ 1.0 x) x)) n)
(fma x (fma x (/ 0.5 (* n n)) (/ 1.0 n)) (- 1.0 t_0))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 0.05) {
tmp = log(((1.0 + x) / x)) / n;
} else {
tmp = fma(x, fma(x, (0.5 / (n * n)), (1.0 / n)), (1.0 - t_0));
}
return tmp;
}
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 0.05) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); else tmp = fma(x, fma(x, Float64(0.5 / Float64(n * n)), Float64(1.0 / n)), Float64(1.0 - t_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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 0.05], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], N[(x * N[(x * N[(0.5 / N[(n * n), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 0.05:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{0.5}{n \cdot n}, \frac{1}{n}\right), 1 - t\_0\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 0.050000000000000003Initial program 23.4%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6482.7
Applied rewrites82.7%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6482.7
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6482.9
Applied rewrites82.9%
if 0.050000000000000003 < (/.f64 #s(literal 1 binary64) n) Initial program 55.1%
Taylor expanded in x around 0
Applied rewrites29.6%
Taylor expanded in n around 0
lower-/.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6464.3
Applied rewrites64.3%
Taylor expanded in x around 0
*-commutativeN/A
associate-*l/N/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
lower-fma.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
lower-/.f6464.3
Applied rewrites64.3%
Final simplification84.3%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 2e-11)
(/ (log (/ (+ 1.0 x) x)) n)
(if (<= (/ 1.0 n) 2e+237)
(- (+ 1.0 (/ x n)) t_0)
(/ 0.3333333333333333 (* x (* x (* n x)))))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 2e-11) {
tmp = log(((1.0 + x) / x)) / n;
} else if ((1.0 / n) <= 2e+237) {
tmp = (1.0 + (x / n)) - t_0;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = x ** (1.0d0 / n)
if ((1.0d0 / n) <= (-5d-71)) then
tmp = t_0 / (n * x)
else if ((1.0d0 / n) <= 2d-11) then
tmp = log(((1.0d0 + x) / x)) / n
else if ((1.0d0 / n) <= 2d+237) then
tmp = (1.0d0 + (x / n)) - t_0
else
tmp = 0.3333333333333333d0 / (x * (x * (n * x)))
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = Math.pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 2e-11) {
tmp = Math.log(((1.0 + x) / x)) / n;
} else if ((1.0 / n) <= 2e+237) {
tmp = (1.0 + (x / n)) - t_0;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, (1.0 / n)) tmp = 0 if (1.0 / n) <= -5e-71: tmp = t_0 / (n * x) elif (1.0 / n) <= 2e-11: tmp = math.log(((1.0 + x) / x)) / n elif (1.0 / n) <= 2e+237: tmp = (1.0 + (x / n)) - t_0 else: tmp = 0.3333333333333333 / (x * (x * (n * x))) return tmp
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 2e-11) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); elseif (Float64(1.0 / n) <= 2e+237) tmp = Float64(Float64(1.0 + Float64(x / n)) - t_0); else tmp = Float64(0.3333333333333333 / Float64(x * Float64(x * Float64(n * x)))); end return tmp end
function tmp_2 = code(x, n) t_0 = x ^ (1.0 / n); tmp = 0.0; if ((1.0 / n) <= -5e-71) tmp = t_0 / (n * x); elseif ((1.0 / n) <= 2e-11) tmp = log(((1.0 + x) / x)) / n; elseif ((1.0 / n) <= 2e+237) tmp = (1.0 + (x / n)) - t_0; else tmp = 0.3333333333333333 / (x * (x * (n * x))); end tmp_2 = 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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e-11], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e+237], N[(N[(1.0 + N[(x / n), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(0.3333333333333333 / N[(x * N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{-11}:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{+237}:\\
\;\;\;\;\left(1 + \frac{x}{n}\right) - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333}{x \cdot \left(x \cdot \left(n \cdot x\right)\right)}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 1.99999999999999988e-11Initial program 23.7%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6484.0
Applied rewrites84.0%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6484.0
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6484.2
Applied rewrites84.2%
if 1.99999999999999988e-11 < (/.f64 #s(literal 1 binary64) n) < 1.99999999999999988e237Initial program 64.9%
Taylor expanded in x around 0
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6460.0
Applied rewrites60.0%
if 1.99999999999999988e237 < (/.f64 #s(literal 1 binary64) n) Initial program 3.1%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f647.8
Applied rewrites7.8%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites100.0%
Taylor expanded in x around 0
lower-/.f64N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64100.0
Applied rewrites100.0%
Final simplification85.3%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (/ 1.0 n))))
(if (<= (/ 1.0 n) -5e-71)
(/ t_0 (* n x))
(if (<= (/ 1.0 n) 0.05)
(/ (log (/ (+ 1.0 x) x)) n)
(if (<= (/ 1.0 n) 2e+237)
(- 1.0 t_0)
(/ 0.3333333333333333 (* x (* x (* n x)))))))))
double code(double x, double n) {
double t_0 = pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 0.05) {
tmp = log(((1.0 + x) / x)) / n;
} else if ((1.0 / n) <= 2e+237) {
tmp = 1.0 - t_0;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = x ** (1.0d0 / n)
if ((1.0d0 / n) <= (-5d-71)) then
tmp = t_0 / (n * x)
else if ((1.0d0 / n) <= 0.05d0) then
tmp = log(((1.0d0 + x) / x)) / n
else if ((1.0d0 / n) <= 2d+237) then
tmp = 1.0d0 - t_0
else
tmp = 0.3333333333333333d0 / (x * (x * (n * x)))
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = Math.pow(x, (1.0 / n));
double tmp;
if ((1.0 / n) <= -5e-71) {
tmp = t_0 / (n * x);
} else if ((1.0 / n) <= 0.05) {
tmp = Math.log(((1.0 + x) / x)) / n;
} else if ((1.0 / n) <= 2e+237) {
tmp = 1.0 - t_0;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, (1.0 / n)) tmp = 0 if (1.0 / n) <= -5e-71: tmp = t_0 / (n * x) elif (1.0 / n) <= 0.05: tmp = math.log(((1.0 + x) / x)) / n elif (1.0 / n) <= 2e+237: tmp = 1.0 - t_0 else: tmp = 0.3333333333333333 / (x * (x * (n * x))) return tmp
function code(x, n) t_0 = x ^ Float64(1.0 / n) tmp = 0.0 if (Float64(1.0 / n) <= -5e-71) tmp = Float64(t_0 / Float64(n * x)); elseif (Float64(1.0 / n) <= 0.05) tmp = Float64(log(Float64(Float64(1.0 + x) / x)) / n); elseif (Float64(1.0 / n) <= 2e+237) tmp = Float64(1.0 - t_0); else tmp = Float64(0.3333333333333333 / Float64(x * Float64(x * Float64(n * x)))); end return tmp end
function tmp_2 = code(x, n) t_0 = x ^ (1.0 / n); tmp = 0.0; if ((1.0 / n) <= -5e-71) tmp = t_0 / (n * x); elseif ((1.0 / n) <= 0.05) tmp = log(((1.0 + x) / x)) / n; elseif ((1.0 / n) <= 2e+237) tmp = 1.0 - t_0; else tmp = 0.3333333333333333 / (x * (x * (n * x))); end tmp_2 = 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], -5e-71], N[(t$95$0 / N[(n * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 0.05], N[(N[Log[N[(N[(1.0 + x), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e+237], N[(1.0 - t$95$0), $MachinePrecision], N[(0.3333333333333333 / N[(x * N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{t\_0}{n \cdot x}\\
\mathbf{elif}\;\frac{1}{n} \leq 0.05:\\
\;\;\;\;\frac{\log \left(\frac{1 + x}{x}\right)}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{+237}:\\
\;\;\;\;1 - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333}{x \cdot \left(x \cdot \left(n \cdot x\right)\right)}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 88.2%
Taylor expanded in x around inf
lower-/.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
lower-pow.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6494.1
Applied rewrites94.1%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 0.050000000000000003Initial program 23.4%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6482.7
Applied rewrites82.7%
lift-log1p.f64N/A
lift-log.f64N/A
lift--.f64N/A
lift-/.f6482.7
lift--.f64N/A
lift-log1p.f64N/A
lift-log.f64N/A
diff-logN/A
lower-log.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6482.9
Applied rewrites82.9%
if 0.050000000000000003 < (/.f64 #s(literal 1 binary64) n) < 1.99999999999999988e237Initial program 68.9%
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
lower--.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
lower-pow.f64N/A
lower-/.f6462.5
Applied rewrites62.5%
if 1.99999999999999988e237 < (/.f64 #s(literal 1 binary64) n) Initial program 3.1%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f647.8
Applied rewrites7.8%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites100.0%
Taylor expanded in x around 0
lower-/.f64N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64100.0
Applied rewrites100.0%
Final simplification85.2%
(FPCore (x n)
:precision binary64
(let* ((t_0 (* x (* x x))))
(if (<= (/ 1.0 n) -5000.0)
(/ (/ 0.3333333333333333 t_0) n)
(if (<= (/ 1.0 n) -5e-71)
(/
(/
(+
1.0
(/
(* (+ -0.125 (/ 0.037037037037037035 t_0)) (/ 1.0 x))
(fma
(/ 0.3333333333333333 x)
(- (/ 0.3333333333333333 x) -0.5)
0.25)))
x)
n)
(if (<= (/ 1.0 n) 2e+63)
(/ (- x (log x)) n)
(fma
x
(fma
x
(/ (fma x (fma n -0.5 0.16666666666666666) (* n 0.5)) (* n (* n n)))
(/ 1.0 n))
(+ 1.0 -1.0)))))))
double code(double x, double n) {
double t_0 = x * (x * x);
double tmp;
if ((1.0 / n) <= -5000.0) {
tmp = (0.3333333333333333 / t_0) / n;
} else if ((1.0 / n) <= -5e-71) {
tmp = ((1.0 + (((-0.125 + (0.037037037037037035 / t_0)) * (1.0 / x)) / fma((0.3333333333333333 / x), ((0.3333333333333333 / x) - -0.5), 0.25))) / x) / n;
} else if ((1.0 / n) <= 2e+63) {
tmp = (x - log(x)) / n;
} else {
tmp = fma(x, fma(x, (fma(x, fma(n, -0.5, 0.16666666666666666), (n * 0.5)) / (n * (n * n))), (1.0 / n)), (1.0 + -1.0));
}
return tmp;
}
function code(x, n) t_0 = Float64(x * Float64(x * x)) tmp = 0.0 if (Float64(1.0 / n) <= -5000.0) tmp = Float64(Float64(0.3333333333333333 / t_0) / n); elseif (Float64(1.0 / n) <= -5e-71) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(Float64(-0.125 + Float64(0.037037037037037035 / t_0)) * Float64(1.0 / x)) / fma(Float64(0.3333333333333333 / x), Float64(Float64(0.3333333333333333 / x) - -0.5), 0.25))) / x) / n); elseif (Float64(1.0 / n) <= 2e+63) tmp = Float64(Float64(x - log(x)) / n); else tmp = fma(x, fma(x, Float64(fma(x, fma(n, -0.5, 0.16666666666666666), Float64(n * 0.5)) / Float64(n * Float64(n * n))), Float64(1.0 / n)), Float64(1.0 + -1.0)); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000.0], N[(N[(0.3333333333333333 / t$95$0), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], -5e-71], N[(N[(N[(1.0 + N[(N[(N[(-0.125 + N[(0.037037037037037035 / t$95$0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3333333333333333 / x), $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] - -0.5), $MachinePrecision] + 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e+63], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(x * N[(x * N[(N[(x * N[(n * -0.5 + 0.16666666666666666), $MachinePrecision] + N[(n * 0.5), $MachinePrecision]), $MachinePrecision] / N[(n * N[(n * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 + -1.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot x\right)\\
\mathbf{if}\;\frac{1}{n} \leq -5000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{t\_0}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq -5 \cdot 10^{-71}:\\
\;\;\;\;\frac{\frac{1 + \frac{\left(-0.125 + \frac{0.037037037037037035}{t\_0}\right) \cdot \frac{1}{x}}{\mathsf{fma}\left(\frac{0.3333333333333333}{x}, \frac{0.3333333333333333}{x} - -0.5, 0.25\right)}}{x}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{+63}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{\mathsf{fma}\left(x, \mathsf{fma}\left(n, -0.5, 0.16666666666666666\right), n \cdot 0.5\right)}{n \cdot \left(n \cdot n\right)}, \frac{1}{n}\right), 1 + -1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.9
Applied rewrites50.9%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites42.1%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6476.2
Applied rewrites76.2%
if -5e3 < (/.f64 #s(literal 1 binary64) n) < -4.99999999999999998e-71Initial program 29.7%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6426.3
Applied rewrites26.3%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites50.2%
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lift-+.f64N/A
flip3-+N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lift-/.f64N/A
cube-divN/A
lower-/.f64N/A
metadata-evalN/A
cube-multN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites54.7%
if -4.99999999999999998e-71 < (/.f64 #s(literal 1 binary64) n) < 2.00000000000000012e63Initial program 25.8%
Taylor expanded in x around 0
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6418.2
Applied rewrites18.2%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log.f6460.9
Applied rewrites60.9%
if 2.00000000000000012e63 < (/.f64 #s(literal 1 binary64) n) Initial program 51.5%
Taylor expanded in x around 0
Applied rewrites19.5%
Taylor expanded in n around inf
Applied rewrites16.5%
Taylor expanded in n around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-inN/A
+-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6454.8
Applied rewrites54.8%
Final simplification64.5%
(FPCore (x n)
:precision binary64
(let* ((t_0 (* x (* x x))))
(if (<= (/ 1.0 n) -5000.0)
(/ (/ 0.3333333333333333 t_0) n)
(if (<= (/ 1.0 n) -1e-77)
(/
(/
(+
1.0
(/
(* (+ -0.125 (/ 0.037037037037037035 t_0)) (/ 1.0 x))
(fma
(/ 0.3333333333333333 x)
(- (/ 0.3333333333333333 x) -0.5)
0.25)))
x)
n)
(if (<= (/ 1.0 n) 2e+63)
(- (/ (log x) n))
(fma
x
(fma
x
(/ (fma x (fma n -0.5 0.16666666666666666) (* n 0.5)) (* n (* n n)))
(/ 1.0 n))
(+ 1.0 -1.0)))))))
double code(double x, double n) {
double t_0 = x * (x * x);
double tmp;
if ((1.0 / n) <= -5000.0) {
tmp = (0.3333333333333333 / t_0) / n;
} else if ((1.0 / n) <= -1e-77) {
tmp = ((1.0 + (((-0.125 + (0.037037037037037035 / t_0)) * (1.0 / x)) / fma((0.3333333333333333 / x), ((0.3333333333333333 / x) - -0.5), 0.25))) / x) / n;
} else if ((1.0 / n) <= 2e+63) {
tmp = -(log(x) / n);
} else {
tmp = fma(x, fma(x, (fma(x, fma(n, -0.5, 0.16666666666666666), (n * 0.5)) / (n * (n * n))), (1.0 / n)), (1.0 + -1.0));
}
return tmp;
}
function code(x, n) t_0 = Float64(x * Float64(x * x)) tmp = 0.0 if (Float64(1.0 / n) <= -5000.0) tmp = Float64(Float64(0.3333333333333333 / t_0) / n); elseif (Float64(1.0 / n) <= -1e-77) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(Float64(-0.125 + Float64(0.037037037037037035 / t_0)) * Float64(1.0 / x)) / fma(Float64(0.3333333333333333 / x), Float64(Float64(0.3333333333333333 / x) - -0.5), 0.25))) / x) / n); elseif (Float64(1.0 / n) <= 2e+63) tmp = Float64(-Float64(log(x) / n)); else tmp = fma(x, fma(x, Float64(fma(x, fma(n, -0.5, 0.16666666666666666), Float64(n * 0.5)) / Float64(n * Float64(n * n))), Float64(1.0 / n)), Float64(1.0 + -1.0)); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(1.0 / n), $MachinePrecision], -5000.0], N[(N[(0.3333333333333333 / t$95$0), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], -1e-77], N[(N[(N[(1.0 + N[(N[(N[(-0.125 + N[(0.037037037037037035 / t$95$0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3333333333333333 / x), $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] - -0.5), $MachinePrecision] + 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2e+63], (-N[(N[Log[x], $MachinePrecision] / n), $MachinePrecision]), N[(x * N[(x * N[(N[(x * N[(n * -0.5 + 0.16666666666666666), $MachinePrecision] + N[(n * 0.5), $MachinePrecision]), $MachinePrecision] / N[(n * N[(n * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 + -1.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(x \cdot x\right)\\
\mathbf{if}\;\frac{1}{n} \leq -5000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{t\_0}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq -1 \cdot 10^{-77}:\\
\;\;\;\;\frac{\frac{1 + \frac{\left(-0.125 + \frac{0.037037037037037035}{t\_0}\right) \cdot \frac{1}{x}}{\mathsf{fma}\left(\frac{0.3333333333333333}{x}, \frac{0.3333333333333333}{x} - -0.5, 0.25\right)}}{x}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2 \cdot 10^{+63}:\\
\;\;\;\;-\frac{\log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{\mathsf{fma}\left(x, \mathsf{fma}\left(n, -0.5, 0.16666666666666666\right), n \cdot 0.5\right)}{n \cdot \left(n \cdot n\right)}, \frac{1}{n}\right), 1 + -1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.9
Applied rewrites50.9%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites42.1%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6476.2
Applied rewrites76.2%
if -5e3 < (/.f64 #s(literal 1 binary64) n) < -9.9999999999999993e-78Initial program 26.9%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6431.9
Applied rewrites31.9%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites50.3%
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lift-+.f64N/A
flip3-+N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lift-/.f64N/A
cube-divN/A
lower-/.f64N/A
metadata-evalN/A
cube-multN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites54.4%
if -9.9999999999999993e-78 < (/.f64 #s(literal 1 binary64) n) < 2.00000000000000012e63Initial program 26.1%
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
lower--.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
lower-pow.f64N/A
lower-/.f6426.1
Applied rewrites26.1%
Taylor expanded in n around inf
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
lower-log.f6460.7
Applied rewrites60.7%
if 2.00000000000000012e63 < (/.f64 #s(literal 1 binary64) n) Initial program 51.5%
Taylor expanded in x around 0
Applied rewrites19.5%
Taylor expanded in n around inf
Applied rewrites16.5%
Taylor expanded in n around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-inN/A
+-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6454.8
Applied rewrites54.8%
Final simplification64.3%
(FPCore (x n)
:precision binary64
(let* ((t_0 (- x (log x))) (t_1 (* x (* x x))))
(if (<= n -2.8e+70)
(/ t_0 n)
(if (<= n -0.000118)
(/
(/
(+
1.0
(/
(* (+ -0.125 (/ 0.037037037037037035 t_1)) (/ 1.0 x))
(fma
(/ 0.3333333333333333 x)
(- (/ 0.3333333333333333 x) -0.5)
0.25)))
x)
n)
(if (<= n 5e-238)
(/ (/ 0.3333333333333333 t_1) n)
(if (<= n 36.0)
(- 1.0 (pow x (/ 1.0 n)))
(if (<= n 9.5e+175)
(* (/ 1.0 n) t_0)
(/
(+
(/ 1.0 n)
(+ (/ 0.3333333333333333 (* x (* n x))) (/ -0.5 (* n x))))
x))))))))
double code(double x, double n) {
double t_0 = x - log(x);
double t_1 = x * (x * x);
double tmp;
if (n <= -2.8e+70) {
tmp = t_0 / n;
} else if (n <= -0.000118) {
tmp = ((1.0 + (((-0.125 + (0.037037037037037035 / t_1)) * (1.0 / x)) / fma((0.3333333333333333 / x), ((0.3333333333333333 / x) - -0.5), 0.25))) / x) / n;
} else if (n <= 5e-238) {
tmp = (0.3333333333333333 / t_1) / n;
} else if (n <= 36.0) {
tmp = 1.0 - pow(x, (1.0 / n));
} else if (n <= 9.5e+175) {
tmp = (1.0 / n) * t_0;
} else {
tmp = ((1.0 / n) + ((0.3333333333333333 / (x * (n * x))) + (-0.5 / (n * x)))) / x;
}
return tmp;
}
function code(x, n) t_0 = Float64(x - log(x)) t_1 = Float64(x * Float64(x * x)) tmp = 0.0 if (n <= -2.8e+70) tmp = Float64(t_0 / n); elseif (n <= -0.000118) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(Float64(-0.125 + Float64(0.037037037037037035 / t_1)) * Float64(1.0 / x)) / fma(Float64(0.3333333333333333 / x), Float64(Float64(0.3333333333333333 / x) - -0.5), 0.25))) / x) / n); elseif (n <= 5e-238) tmp = Float64(Float64(0.3333333333333333 / t_1) / n); elseif (n <= 36.0) tmp = Float64(1.0 - (x ^ Float64(1.0 / n))); elseif (n <= 9.5e+175) tmp = Float64(Float64(1.0 / n) * t_0); else tmp = Float64(Float64(Float64(1.0 / n) + Float64(Float64(0.3333333333333333 / Float64(x * Float64(n * x))) + Float64(-0.5 / Float64(n * x)))) / x); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -2.8e+70], N[(t$95$0 / n), $MachinePrecision], If[LessEqual[n, -0.000118], N[(N[(N[(1.0 + N[(N[(N[(-0.125 + N[(0.037037037037037035 / t$95$1), $MachinePrecision]), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3333333333333333 / x), $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] - -0.5), $MachinePrecision] + 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[n, 5e-238], N[(N[(0.3333333333333333 / t$95$1), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[n, 36.0], N[(1.0 - N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 9.5e+175], N[(N[(1.0 / n), $MachinePrecision] * t$95$0), $MachinePrecision], N[(N[(N[(1.0 / n), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x - \log x\\
t_1 := x \cdot \left(x \cdot x\right)\\
\mathbf{if}\;n \leq -2.8 \cdot 10^{+70}:\\
\;\;\;\;\frac{t\_0}{n}\\
\mathbf{elif}\;n \leq -0.000118:\\
\;\;\;\;\frac{\frac{1 + \frac{\left(-0.125 + \frac{0.037037037037037035}{t\_1}\right) \cdot \frac{1}{x}}{\mathsf{fma}\left(\frac{0.3333333333333333}{x}, \frac{0.3333333333333333}{x} - -0.5, 0.25\right)}}{x}}{n}\\
\mathbf{elif}\;n \leq 5 \cdot 10^{-238}:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{t\_1}}{n}\\
\mathbf{elif}\;n \leq 36:\\
\;\;\;\;1 - {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{elif}\;n \leq 9.5 \cdot 10^{+175}:\\
\;\;\;\;\frac{1}{n} \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{n} + \left(\frac{0.3333333333333333}{x \cdot \left(n \cdot x\right)} + \frac{-0.5}{n \cdot x}\right)}{x}\\
\end{array}
\end{array}
if n < -2.7999999999999999e70Initial program 17.9%
Taylor expanded in x around 0
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6413.2
Applied rewrites13.2%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log.f6472.8
Applied rewrites72.8%
if -2.7999999999999999e70 < n < -1.18e-4Initial program 33.9%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6424.9
Applied rewrites24.9%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites47.5%
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lift-+.f64N/A
flip3-+N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lift-/.f64N/A
cube-divN/A
lower-/.f64N/A
metadata-evalN/A
cube-multN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites51.8%
if -1.18e-4 < n < 5e-238Initial program 91.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6447.5
Applied rewrites47.5%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites47.9%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6479.3
Applied rewrites79.3%
if 5e-238 < n < 36Initial program 68.9%
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
lower--.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
lower-pow.f64N/A
lower-/.f6462.5
Applied rewrites62.5%
if 36 < n < 9.5000000000000006e175Initial program 18.8%
Taylor expanded in x around 0
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f645.6
Applied rewrites5.6%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log.f6461.3
Applied rewrites61.3%
lift-log.f64N/A
lift--.f64N/A
clear-numN/A
associate-/r/N/A
lower-*.f64N/A
lower-/.f6461.3
Applied rewrites61.3%
if 9.5000000000000006e175 < n Initial program 42.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6481.4
Applied rewrites81.4%
Taylor expanded in x around inf
Applied rewrites60.7%
Final simplification69.7%
(FPCore (x n)
:precision binary64
(let* ((t_0 (/ (- x (log x)) n)) (t_1 (* x (* x x))))
(if (<= n -2.8e+70)
t_0
(if (<= n -0.000118)
(/
(/
(+
1.0
(/
(* (+ -0.125 (/ 0.037037037037037035 t_1)) (/ 1.0 x))
(fma
(/ 0.3333333333333333 x)
(- (/ 0.3333333333333333 x) -0.5)
0.25)))
x)
n)
(if (<= n 5e-238)
(/ (/ 0.3333333333333333 t_1) n)
(if (<= n 36.0)
(- 1.0 (pow x (/ 1.0 n)))
(if (<= n 9.5e+175)
t_0
(/
(+
(/ 1.0 n)
(+ (/ 0.3333333333333333 (* x (* n x))) (/ -0.5 (* n x))))
x))))))))
double code(double x, double n) {
double t_0 = (x - log(x)) / n;
double t_1 = x * (x * x);
double tmp;
if (n <= -2.8e+70) {
tmp = t_0;
} else if (n <= -0.000118) {
tmp = ((1.0 + (((-0.125 + (0.037037037037037035 / t_1)) * (1.0 / x)) / fma((0.3333333333333333 / x), ((0.3333333333333333 / x) - -0.5), 0.25))) / x) / n;
} else if (n <= 5e-238) {
tmp = (0.3333333333333333 / t_1) / n;
} else if (n <= 36.0) {
tmp = 1.0 - pow(x, (1.0 / n));
} else if (n <= 9.5e+175) {
tmp = t_0;
} else {
tmp = ((1.0 / n) + ((0.3333333333333333 / (x * (n * x))) + (-0.5 / (n * x)))) / x;
}
return tmp;
}
function code(x, n) t_0 = Float64(Float64(x - log(x)) / n) t_1 = Float64(x * Float64(x * x)) tmp = 0.0 if (n <= -2.8e+70) tmp = t_0; elseif (n <= -0.000118) tmp = Float64(Float64(Float64(1.0 + Float64(Float64(Float64(-0.125 + Float64(0.037037037037037035 / t_1)) * Float64(1.0 / x)) / fma(Float64(0.3333333333333333 / x), Float64(Float64(0.3333333333333333 / x) - -0.5), 0.25))) / x) / n); elseif (n <= 5e-238) tmp = Float64(Float64(0.3333333333333333 / t_1) / n); elseif (n <= 36.0) tmp = Float64(1.0 - (x ^ Float64(1.0 / n))); elseif (n <= 9.5e+175) tmp = t_0; else tmp = Float64(Float64(Float64(1.0 / n) + Float64(Float64(0.3333333333333333 / Float64(x * Float64(n * x))) + Float64(-0.5 / Float64(n * x)))) / x); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision]}, Block[{t$95$1 = N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -2.8e+70], t$95$0, If[LessEqual[n, -0.000118], N[(N[(N[(1.0 + N[(N[(N[(-0.125 + N[(0.037037037037037035 / t$95$1), $MachinePrecision]), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision] / N[(N[(0.3333333333333333 / x), $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] - -0.5), $MachinePrecision] + 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[n, 5e-238], N[(N[(0.3333333333333333 / t$95$1), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[n, 36.0], N[(1.0 - N[Power[x, N[(1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[n, 9.5e+175], t$95$0, N[(N[(N[(1.0 / n), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x - \log x}{n}\\
t_1 := x \cdot \left(x \cdot x\right)\\
\mathbf{if}\;n \leq -2.8 \cdot 10^{+70}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq -0.000118:\\
\;\;\;\;\frac{\frac{1 + \frac{\left(-0.125 + \frac{0.037037037037037035}{t\_1}\right) \cdot \frac{1}{x}}{\mathsf{fma}\left(\frac{0.3333333333333333}{x}, \frac{0.3333333333333333}{x} - -0.5, 0.25\right)}}{x}}{n}\\
\mathbf{elif}\;n \leq 5 \cdot 10^{-238}:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{t\_1}}{n}\\
\mathbf{elif}\;n \leq 36:\\
\;\;\;\;1 - {x}^{\left(\frac{1}{n}\right)}\\
\mathbf{elif}\;n \leq 9.5 \cdot 10^{+175}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{n} + \left(\frac{0.3333333333333333}{x \cdot \left(n \cdot x\right)} + \frac{-0.5}{n \cdot x}\right)}{x}\\
\end{array}
\end{array}
if n < -2.7999999999999999e70 or 36 < n < 9.5000000000000006e175Initial program 18.2%
Taylor expanded in x around 0
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6410.8
Applied rewrites10.8%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log.f6469.1
Applied rewrites69.1%
if -2.7999999999999999e70 < n < -1.18e-4Initial program 33.9%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6424.9
Applied rewrites24.9%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites47.5%
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lift-+.f64N/A
flip3-+N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lift-/.f64N/A
cube-divN/A
lower-/.f64N/A
metadata-evalN/A
cube-multN/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites51.8%
if -1.18e-4 < n < 5e-238Initial program 91.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6447.5
Applied rewrites47.5%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites47.9%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6479.3
Applied rewrites79.3%
if 5e-238 < n < 36Initial program 68.9%
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
lower--.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
lower-pow.f64N/A
lower-/.f6462.5
Applied rewrites62.5%
if 9.5000000000000006e175 < n Initial program 42.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6481.4
Applied rewrites81.4%
Taylor expanded in x around inf
Applied rewrites60.7%
Final simplification69.7%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -2000.0)
(/ (/ 0.3333333333333333 (* x (* x x))) n)
(if (<= (/ 1.0 n) 0.05)
(/ (/ 1.0 x) n)
(fma
x
(fma
x
(/ (fma x (fma n -0.5 0.16666666666666666) (* n 0.5)) (* n (* n n)))
(/ 1.0 n))
(+ 1.0 -1.0)))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 0.05) {
tmp = (1.0 / x) / n;
} else {
tmp = fma(x, fma(x, (fma(x, fma(n, -0.5, 0.16666666666666666), (n * 0.5)) / (n * (n * n))), (1.0 / n)), (1.0 + -1.0));
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -2000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); elseif (Float64(1.0 / n) <= 0.05) tmp = Float64(Float64(1.0 / x) / n); else tmp = fma(x, fma(x, Float64(fma(x, fma(n, -0.5, 0.16666666666666666), Float64(n * 0.5)) / Float64(n * Float64(n * n))), Float64(1.0 / n)), Float64(1.0 + -1.0)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -2000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 0.05], N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision], N[(x * N[(x * N[(N[(x * N[(n * -0.5 + 0.16666666666666666), $MachinePrecision] + N[(n * 0.5), $MachinePrecision]), $MachinePrecision] / N[(n * N[(n * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / n), $MachinePrecision]), $MachinePrecision] + N[(1.0 + -1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -2000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 0.05:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \frac{\mathsf{fma}\left(x, \mathsf{fma}\left(n, -0.5, 0.16666666666666666\right), n \cdot 0.5\right)}{n \cdot \left(n \cdot n\right)}, \frac{1}{n}\right), 1 + -1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -2e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.3
Applied rewrites50.3%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites41.8%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6475.5
Applied rewrites75.5%
if -2e3 < (/.f64 #s(literal 1 binary64) n) < 0.050000000000000003Initial program 23.6%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6476.7
Applied rewrites76.7%
Taylor expanded in x around inf
lower-/.f6440.0
Applied rewrites40.0%
if 0.050000000000000003 < (/.f64 #s(literal 1 binary64) n) Initial program 55.1%
Taylor expanded in x around 0
Applied rewrites29.6%
Taylor expanded in n around inf
Applied rewrites14.9%
Taylor expanded in n around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-inN/A
+-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6447.1
Applied rewrites47.1%
Final simplification52.1%
(FPCore (x n)
:precision binary64
(let* ((t_0 (/ 0.3333333333333333 (* x (* x (* n x))))))
(if (<= (/ 1.0 n) -5e+93)
t_0
(if (<= (/ 1.0 n) -1000000000.0)
0.0
(if (<= (/ 1.0 n) 1e+26) (/ (/ 1.0 x) n) t_0)))))
double code(double x, double n) {
double t_0 = 0.3333333333333333 / (x * (x * (n * x)));
double tmp;
if ((1.0 / n) <= -5e+93) {
tmp = t_0;
} else if ((1.0 / n) <= -1000000000.0) {
tmp = 0.0;
} else if ((1.0 / n) <= 1e+26) {
tmp = (1.0 / x) / n;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 0.3333333333333333d0 / (x * (x * (n * x)))
if ((1.0d0 / n) <= (-5d+93)) then
tmp = t_0
else if ((1.0d0 / n) <= (-1000000000.0d0)) then
tmp = 0.0d0
else if ((1.0d0 / n) <= 1d+26) then
tmp = (1.0d0 / x) / n
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = 0.3333333333333333 / (x * (x * (n * x)));
double tmp;
if ((1.0 / n) <= -5e+93) {
tmp = t_0;
} else if ((1.0 / n) <= -1000000000.0) {
tmp = 0.0;
} else if ((1.0 / n) <= 1e+26) {
tmp = (1.0 / x) / n;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, n): t_0 = 0.3333333333333333 / (x * (x * (n * x))) tmp = 0 if (1.0 / n) <= -5e+93: tmp = t_0 elif (1.0 / n) <= -1000000000.0: tmp = 0.0 elif (1.0 / n) <= 1e+26: tmp = (1.0 / x) / n else: tmp = t_0 return tmp
function code(x, n) t_0 = Float64(0.3333333333333333 / Float64(x * Float64(x * Float64(n * x)))) tmp = 0.0 if (Float64(1.0 / n) <= -5e+93) tmp = t_0; elseif (Float64(1.0 / n) <= -1000000000.0) tmp = 0.0; elseif (Float64(1.0 / n) <= 1e+26) tmp = Float64(Float64(1.0 / x) / n); else tmp = t_0; end return tmp end
function tmp_2 = code(x, n) t_0 = 0.3333333333333333 / (x * (x * (n * x))); tmp = 0.0; if ((1.0 / n) <= -5e+93) tmp = t_0; elseif ((1.0 / n) <= -1000000000.0) tmp = 0.0; elseif ((1.0 / n) <= 1e+26) tmp = (1.0 / x) / n; else tmp = t_0; end tmp_2 = tmp; end
code[x_, n_] := Block[{t$95$0 = N[(0.3333333333333333 / N[(x * N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(1.0 / n), $MachinePrecision], -5e+93], t$95$0, If[LessEqual[N[(1.0 / n), $MachinePrecision], -1000000000.0], 0.0, If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+26], N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{0.3333333333333333}{x \cdot \left(x \cdot \left(n \cdot x\right)\right)}\\
\mathbf{if}\;\frac{1}{n} \leq -5 \cdot 10^{+93}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\frac{1}{n} \leq -1000000000:\\
\;\;\;\;0\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+26}:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -5.0000000000000001e93 or 1.00000000000000005e26 < (/.f64 #s(literal 1 binary64) n) Initial program 81.5%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6425.8
Applied rewrites25.8%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites49.4%
Taylor expanded in x around 0
lower-/.f64N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6459.4
Applied rewrites59.4%
if -5.0000000000000001e93 < (/.f64 #s(literal 1 binary64) n) < -1e9Initial 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
lower--.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
lower-pow.f64N/A
lower-/.f6423.3
Applied rewrites23.3%
Taylor expanded in n around inf
Applied rewrites79.5%
metadata-eval79.5
Applied rewrites79.5%
if -1e9 < (/.f64 #s(literal 1 binary64) n) < 1.00000000000000005e26Initial program 25.8%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6474.3
Applied rewrites74.3%
Taylor expanded in x around inf
lower-/.f6438.8
Applied rewrites38.8%
Final simplification49.8%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -2000.0)
(/ (/ 0.3333333333333333 (* x (* x x))) n)
(if (<= (/ 1.0 n) 2000000000.0)
(/ (/ 1.0 x) n)
(fma x (/ (* (* x x) 0.16666666666666666) (* n (* n n))) (+ 1.0 -1.0)))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 2000000000.0) {
tmp = (1.0 / x) / n;
} else {
tmp = fma(x, (((x * x) * 0.16666666666666666) / (n * (n * n))), (1.0 + -1.0));
}
return tmp;
}
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -2000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); elseif (Float64(1.0 / n) <= 2000000000.0) tmp = Float64(Float64(1.0 / x) / n); else tmp = fma(x, Float64(Float64(Float64(x * x) * 0.16666666666666666) / Float64(n * Float64(n * n))), Float64(1.0 + -1.0)); end return tmp end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -2000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2000000000.0], N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision], N[(x * N[(N[(N[(x * x), $MachinePrecision] * 0.16666666666666666), $MachinePrecision] / N[(n * N[(n * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 + -1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -2000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2000000000:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{\left(x \cdot x\right) \cdot 0.16666666666666666}{n \cdot \left(n \cdot n\right)}, 1 + -1\right)\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -2e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.3
Applied rewrites50.3%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites41.8%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6475.5
Applied rewrites75.5%
if -2e3 < (/.f64 #s(literal 1 binary64) n) < 2e9Initial program 24.1%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6476.2
Applied rewrites76.2%
Taylor expanded in x around inf
lower-/.f6439.8
Applied rewrites39.8%
if 2e9 < (/.f64 #s(literal 1 binary64) n) Initial program 53.9%
Taylor expanded in x around 0
Applied rewrites27.7%
Taylor expanded in n around inf
Applied rewrites15.1%
Taylor expanded in n around 0
associate-*r/N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6441.4
Applied rewrites41.4%
Final simplification51.2%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -2000.0)
(/ (/ 0.3333333333333333 (* x (* x x))) n)
(if (<= (/ 1.0 n) 2000000000.0)
(/ (/ 1.0 x) n)
(/ (* x (* (* x x) 0.16666666666666666)) (* n (* n n))))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 2000000000.0) {
tmp = (1.0 / x) / n;
} else {
tmp = (x * ((x * x) * 0.16666666666666666)) / (n * (n * 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) <= (-2000.0d0)) then
tmp = (0.3333333333333333d0 / (x * (x * x))) / n
else if ((1.0d0 / n) <= 2000000000.0d0) then
tmp = (1.0d0 / x) / n
else
tmp = (x * ((x * x) * 0.16666666666666666d0)) / (n * (n * n))
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 2000000000.0) {
tmp = (1.0 / x) / n;
} else {
tmp = (x * ((x * x) * 0.16666666666666666)) / (n * (n * n));
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -2000.0: tmp = (0.3333333333333333 / (x * (x * x))) / n elif (1.0 / n) <= 2000000000.0: tmp = (1.0 / x) / n else: tmp = (x * ((x * x) * 0.16666666666666666)) / (n * (n * n)) return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -2000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); elseif (Float64(1.0 / n) <= 2000000000.0) tmp = Float64(Float64(1.0 / x) / n); else tmp = Float64(Float64(x * Float64(Float64(x * x) * 0.16666666666666666)) / Float64(n * Float64(n * n))); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -2000.0) tmp = (0.3333333333333333 / (x * (x * x))) / n; elseif ((1.0 / n) <= 2000000000.0) tmp = (1.0 / x) / n; else tmp = (x * ((x * x) * 0.16666666666666666)) / (n * (n * n)); end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -2000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 2000000000.0], N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision], N[(N[(x * N[(N[(x * x), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision] / N[(n * N[(n * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -2000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 2000000000:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \left(\left(x \cdot x\right) \cdot 0.16666666666666666\right)}{n \cdot \left(n \cdot n\right)}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -2e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.3
Applied rewrites50.3%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites41.8%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6475.5
Applied rewrites75.5%
if -2e3 < (/.f64 #s(literal 1 binary64) n) < 2e9Initial program 24.1%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6476.2
Applied rewrites76.2%
Taylor expanded in x around inf
lower-/.f6439.8
Applied rewrites39.8%
if 2e9 < (/.f64 #s(literal 1 binary64) n) Initial program 53.9%
Taylor expanded in x around 0
Applied rewrites27.7%
Taylor expanded in n around inf
Applied rewrites15.1%
Taylor expanded in n around 0
associate-*r/N/A
lower-/.f64N/A
*-commutativeN/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6438.7
Applied rewrites38.7%
(FPCore (x n) :precision binary64 (if (<= (/ 1.0 n) -1000000000.0) (/ (/ 0.3333333333333333 (* x (* x x))) n) (/ (/ (+ 1.0 (/ (+ -0.5 (/ 0.3333333333333333 x)) x)) n) x)))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -1000000000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else {
tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / n) / x;
}
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) <= (-1000000000.0d0)) then
tmp = (0.3333333333333333d0 / (x * (x * x))) / n
else
tmp = ((1.0d0 + (((-0.5d0) + (0.3333333333333333d0 / x)) / x)) / n) / x
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -1000000000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else {
tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / n) / x;
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -1000000000.0: tmp = (0.3333333333333333 / (x * (x * x))) / n else: tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / n) / x return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -1000000000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); else tmp = Float64(Float64(Float64(1.0 + Float64(Float64(-0.5 + Float64(0.3333333333333333 / x)) / x)) / n) / x); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -1000000000.0) tmp = (0.3333333333333333 / (x * (x * x))) / n; else tmp = ((1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / n) / x; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -1000000000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[(N[(1.0 + N[(N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision] / x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -1000000000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \frac{-0.5 + \frac{0.3333333333333333}{x}}{x}}{n}}{x}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -1e9Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6451.5
Applied rewrites51.5%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites42.6%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6477.1
Applied rewrites77.1%
if -1e9 < (/.f64 #s(literal 1 binary64) n) Initial program 31.2%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6460.8
Applied rewrites60.8%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites38.7%
lift-/.f64N/A
lift-+.f64N/A
lift-/.f64N/A
lift-+.f64N/A
associate-/l/N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6438.8
Applied rewrites38.8%
(FPCore (x n) :precision binary64 (if (<= (/ 1.0 n) -1000000000.0) (/ (/ 0.3333333333333333 (* x (* x x))) n) (/ (+ 1.0 (/ (+ -0.5 (/ 0.3333333333333333 x)) x)) (* n x))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -1000000000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else {
tmp = (1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / (n * x);
}
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) <= (-1000000000.0d0)) then
tmp = (0.3333333333333333d0 / (x * (x * x))) / n
else
tmp = (1.0d0 + (((-0.5d0) + (0.3333333333333333d0 / x)) / x)) / (n * x)
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -1000000000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else {
tmp = (1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / (n * x);
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -1000000000.0: tmp = (0.3333333333333333 / (x * (x * x))) / n else: tmp = (1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / (n * x) return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -1000000000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); else tmp = Float64(Float64(1.0 + Float64(Float64(-0.5 + Float64(0.3333333333333333 / x)) / x)) / Float64(n * x)); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -1000000000.0) tmp = (0.3333333333333333 / (x * (x * x))) / n; else tmp = (1.0 + ((-0.5 + (0.3333333333333333 / x)) / x)) / (n * x); end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -1000000000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[(1.0 + N[(N[(-0.5 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / N[(n * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -1000000000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \frac{-0.5 + \frac{0.3333333333333333}{x}}{x}}{n \cdot x}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -1e9Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6451.5
Applied rewrites51.5%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites42.6%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6477.1
Applied rewrites77.1%
if -1e9 < (/.f64 #s(literal 1 binary64) n) Initial program 31.2%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6460.8
Applied rewrites60.8%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites38.7%
lift-/.f64N/A
lift-+.f64N/A
lift-/.f64N/A
lift-+.f64N/A
associate-/l/N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6438.6
Applied rewrites38.6%
Final simplification50.4%
(FPCore (x n)
:precision binary64
(if (<= (/ 1.0 n) -2000.0)
(/ (/ 0.3333333333333333 (* x (* x x))) n)
(if (<= (/ 1.0 n) 1e+26)
(/ (/ 1.0 x) n)
(/ 0.3333333333333333 (* x (* x (* n x)))))))
double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 1e+26) {
tmp = (1.0 / x) / n;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
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) <= (-2000.0d0)) then
tmp = (0.3333333333333333d0 / (x * (x * x))) / n
else if ((1.0d0 / n) <= 1d+26) then
tmp = (1.0d0 / x) / n
else
tmp = 0.3333333333333333d0 / (x * (x * (n * x)))
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if ((1.0 / n) <= -2000.0) {
tmp = (0.3333333333333333 / (x * (x * x))) / n;
} else if ((1.0 / n) <= 1e+26) {
tmp = (1.0 / x) / n;
} else {
tmp = 0.3333333333333333 / (x * (x * (n * x)));
}
return tmp;
}
def code(x, n): tmp = 0 if (1.0 / n) <= -2000.0: tmp = (0.3333333333333333 / (x * (x * x))) / n elif (1.0 / n) <= 1e+26: tmp = (1.0 / x) / n else: tmp = 0.3333333333333333 / (x * (x * (n * x))) return tmp
function code(x, n) tmp = 0.0 if (Float64(1.0 / n) <= -2000.0) tmp = Float64(Float64(0.3333333333333333 / Float64(x * Float64(x * x))) / n); elseif (Float64(1.0 / n) <= 1e+26) tmp = Float64(Float64(1.0 / x) / n); else tmp = Float64(0.3333333333333333 / Float64(x * Float64(x * Float64(n * x)))); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if ((1.0 / n) <= -2000.0) tmp = (0.3333333333333333 / (x * (x * x))) / n; elseif ((1.0 / n) <= 1e+26) tmp = (1.0 / x) / n; else tmp = 0.3333333333333333 / (x * (x * (n * x))); end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[N[(1.0 / n), $MachinePrecision], -2000.0], N[(N[(0.3333333333333333 / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[(1.0 / n), $MachinePrecision], 1e+26], N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision], N[(0.3333333333333333 / N[(x * N[(x * N[(n * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{1}{n} \leq -2000:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{x \cdot \left(x \cdot x\right)}}{n}\\
\mathbf{elif}\;\frac{1}{n} \leq 10^{+26}:\\
\;\;\;\;\frac{\frac{1}{x}}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333}{x \cdot \left(x \cdot \left(n \cdot x\right)\right)}\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -2e3Initial program 100.0%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6450.3
Applied rewrites50.3%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites41.8%
Taylor expanded in x around 0
lower-/.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6475.5
Applied rewrites75.5%
if -2e3 < (/.f64 #s(literal 1 binary64) n) < 1.00000000000000005e26Initial program 24.8%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6475.3
Applied rewrites75.3%
Taylor expanded in x around inf
lower-/.f6439.3
Applied rewrites39.3%
if 1.00000000000000005e26 < (/.f64 #s(literal 1 binary64) n) Initial program 52.9%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f645.5
Applied rewrites5.5%
Taylor expanded in x around inf
lower-/.f64N/A
Applied rewrites39.8%
Taylor expanded in x around 0
lower-/.f64N/A
unpow3N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6439.8
Applied rewrites39.8%
Final simplification50.7%
(FPCore (x n) :precision binary64 (let* ((t_0 (/ (/ 1.0 x) n))) (if (<= n -0.000118) t_0 (if (<= n -2.75e-129) 0.0 t_0))))
double code(double x, double n) {
double t_0 = (1.0 / x) / n;
double tmp;
if (n <= -0.000118) {
tmp = t_0;
} else if (n <= -2.75e-129) {
tmp = 0.0;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = (1.0d0 / x) / n
if (n <= (-0.000118d0)) then
tmp = t_0
else if (n <= (-2.75d-129)) then
tmp = 0.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = (1.0 / x) / n;
double tmp;
if (n <= -0.000118) {
tmp = t_0;
} else if (n <= -2.75e-129) {
tmp = 0.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, n): t_0 = (1.0 / x) / n tmp = 0 if n <= -0.000118: tmp = t_0 elif n <= -2.75e-129: tmp = 0.0 else: tmp = t_0 return tmp
function code(x, n) t_0 = Float64(Float64(1.0 / x) / n) tmp = 0.0 if (n <= -0.000118) tmp = t_0; elseif (n <= -2.75e-129) tmp = 0.0; else tmp = t_0; end return tmp end
function tmp_2 = code(x, n) t_0 = (1.0 / x) / n; tmp = 0.0; if (n <= -0.000118) tmp = t_0; elseif (n <= -2.75e-129) tmp = 0.0; else tmp = t_0; end tmp_2 = tmp; end
code[x_, n_] := Block[{t$95$0 = N[(N[(1.0 / x), $MachinePrecision] / n), $MachinePrecision]}, If[LessEqual[n, -0.000118], t$95$0, If[LessEqual[n, -2.75e-129], 0.0, t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{1}{x}}{n}\\
\mathbf{if}\;n \leq -0.000118:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq -2.75 \cdot 10^{-129}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if n < -1.18e-4 or -2.75000000000000012e-129 < n Initial program 44.3%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6455.9
Applied rewrites55.9%
Taylor expanded in x around inf
lower-/.f6438.5
Applied rewrites38.5%
if -1.18e-4 < n < -2.75000000000000012e-129Initial 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
lower--.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
lower-pow.f64N/A
lower-/.f6432.7
Applied rewrites32.7%
Taylor expanded in n around inf
Applied rewrites69.9%
metadata-eval69.9
Applied rewrites69.9%
(FPCore (x n) :precision binary64 (let* ((t_0 (/ 1.0 (* n x)))) (if (<= n -0.000118) t_0 (if (<= n -2.75e-129) 0.0 t_0))))
double code(double x, double n) {
double t_0 = 1.0 / (n * x);
double tmp;
if (n <= -0.000118) {
tmp = t_0;
} else if (n <= -2.75e-129) {
tmp = 0.0;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 / (n * x)
if (n <= (-0.000118d0)) then
tmp = t_0
else if (n <= (-2.75d-129)) then
tmp = 0.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = 1.0 / (n * x);
double tmp;
if (n <= -0.000118) {
tmp = t_0;
} else if (n <= -2.75e-129) {
tmp = 0.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, n): t_0 = 1.0 / (n * x) tmp = 0 if n <= -0.000118: tmp = t_0 elif n <= -2.75e-129: tmp = 0.0 else: tmp = t_0 return tmp
function code(x, n) t_0 = Float64(1.0 / Float64(n * x)) tmp = 0.0 if (n <= -0.000118) tmp = t_0; elseif (n <= -2.75e-129) tmp = 0.0; else tmp = t_0; end return tmp end
function tmp_2 = code(x, n) t_0 = 1.0 / (n * x); tmp = 0.0; if (n <= -0.000118) tmp = t_0; elseif (n <= -2.75e-129) tmp = 0.0; else tmp = t_0; end tmp_2 = tmp; end
code[x_, n_] := Block[{t$95$0 = N[(1.0 / N[(n * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -0.000118], t$95$0, If[LessEqual[n, -2.75e-129], 0.0, t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{n \cdot x}\\
\mathbf{if}\;n \leq -0.000118:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;n \leq -2.75 \cdot 10^{-129}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if n < -1.18e-4 or -2.75000000000000012e-129 < n Initial program 44.3%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6455.9
Applied rewrites55.9%
Taylor expanded in x around inf
lower-/.f64N/A
*-commutativeN/A
lower-*.f6438.4
Applied rewrites38.4%
if -1.18e-4 < n < -2.75000000000000012e-129Initial 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
lower--.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
lower-pow.f64N/A
lower-/.f6432.7
Applied rewrites32.7%
Taylor expanded in n around inf
Applied rewrites69.9%
metadata-eval69.9
Applied rewrites69.9%
Final simplification42.8%
(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 52.1%
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
lower--.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
lower-pow.f64N/A
lower-/.f6436.9
Applied rewrites36.9%
Taylor expanded in n around inf
Applied rewrites26.7%
metadata-eval26.7
Applied rewrites26.7%
herbie shell --seed 2024214
(FPCore (x n)
:name "2nthrt (problem 3.4.6)"
:precision binary64
(- (pow (+ x 1.0) (/ 1.0 n)) (pow x (/ 1.0 n))))