
(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 13 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 0.0175) (- (/ x n) (expm1 (/ (log x) n))) (/ (pow n -1.0) (* x (pow x (/ -1.0 n))))))
double code(double x, double n) {
double tmp;
if (x <= 0.0175) {
tmp = (x / n) - expm1((log(x) / n));
} else {
tmp = pow(n, -1.0) / (x * pow(x, (-1.0 / n)));
}
return tmp;
}
public static double code(double x, double n) {
double tmp;
if (x <= 0.0175) {
tmp = (x / n) - Math.expm1((Math.log(x) / n));
} else {
tmp = Math.pow(n, -1.0) / (x * Math.pow(x, (-1.0 / n)));
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 0.0175: tmp = (x / n) - math.expm1((math.log(x) / n)) else: tmp = math.pow(n, -1.0) / (x * math.pow(x, (-1.0 / n))) return tmp
function code(x, n) tmp = 0.0 if (x <= 0.0175) tmp = Float64(Float64(x / n) - expm1(Float64(log(x) / n))); else tmp = Float64((n ^ -1.0) / Float64(x * (x ^ Float64(-1.0 / n)))); end return tmp end
code[x_, n_] := If[LessEqual[x, 0.0175], N[(N[(x / n), $MachinePrecision] - N[(Exp[N[(N[Log[x], $MachinePrecision] / n), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], N[(N[Power[n, -1.0], $MachinePrecision] / N[(x * N[Power[x, N[(-1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.0175:\\
\;\;\;\;\frac{x}{n} - \mathsf{expm1}\left(\frac{\log x}{n}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{n}^{-1}}{x \cdot {x}^{\left(\frac{-1}{n}\right)}}\\
\end{array}
\end{array}
if x < 0.017500000000000002Initial program 47.6%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites92.0%
if 0.017500000000000002 < x Initial program 68.2%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.9
Applied rewrites98.9%
Applied rewrites98.9%
Final simplification95.0%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (pow n -1.0))))
(if (<= (pow n -1.0) -1e-200)
(/ (/ t_0 x) n)
(if (<= (pow n -1.0) 5e-226)
(/ (- x (log x)) n)
(if (<= (pow n -1.0) 2e-17)
(/ (pow n -1.0) (* x (pow x (/ -1.0 n))))
(- (fma (/ (fma x (+ (/ 0.5 n) -0.5) 1.0) n) x 1.0) t_0))))))
double code(double x, double n) {
double t_0 = pow(x, pow(n, -1.0));
double tmp;
if (pow(n, -1.0) <= -1e-200) {
tmp = (t_0 / x) / n;
} else if (pow(n, -1.0) <= 5e-226) {
tmp = (x - log(x)) / n;
} else if (pow(n, -1.0) <= 2e-17) {
tmp = pow(n, -1.0) / (x * pow(x, (-1.0 / n)));
} else {
tmp = fma((fma(x, ((0.5 / n) + -0.5), 1.0) / n), x, 1.0) - t_0;
}
return tmp;
}
function code(x, n) t_0 = x ^ (n ^ -1.0) tmp = 0.0 if ((n ^ -1.0) <= -1e-200) tmp = Float64(Float64(t_0 / x) / n); elseif ((n ^ -1.0) <= 5e-226) tmp = Float64(Float64(x - log(x)) / n); elseif ((n ^ -1.0) <= 2e-17) tmp = Float64((n ^ -1.0) / Float64(x * (x ^ Float64(-1.0 / n)))); else tmp = Float64(fma(Float64(fma(x, Float64(Float64(0.5 / n) + -0.5), 1.0) / n), x, 1.0) - t_0); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[Power[n, -1.0], $MachinePrecision], -1e-200], N[(N[(t$95$0 / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[Power[n, -1.0], $MachinePrecision], 5e-226], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[Power[n, -1.0], $MachinePrecision], 2e-17], N[(N[Power[n, -1.0], $MachinePrecision] / N[(x * N[Power[x, N[(-1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(x * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision] + 1.0), $MachinePrecision] / n), $MachinePrecision] * x + 1.0), $MachinePrecision] - t$95$0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left({n}^{-1}\right)}\\
\mathbf{if}\;{n}^{-1} \leq -1 \cdot 10^{-200}:\\
\;\;\;\;\frac{\frac{t\_0}{x}}{n}\\
\mathbf{elif}\;{n}^{-1} \leq 5 \cdot 10^{-226}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{elif}\;{n}^{-1} \leq 2 \cdot 10^{-17}:\\
\;\;\;\;\frac{{n}^{-1}}{x \cdot {x}^{\left(\frac{-1}{n}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\mathsf{fma}\left(x, \frac{0.5}{n} + -0.5, 1\right)}{n}, x, 1\right) - t\_0\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -9.9999999999999998e-201Initial program 72.9%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6487.5
Applied rewrites87.5%
if -9.9999999999999998e-201 < (/.f64 #s(literal 1 binary64) n) < 4.9999999999999998e-226Initial program 32.2%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites69.1%
Taylor expanded in n around inf
Applied rewrites69.1%
if 4.9999999999999998e-226 < (/.f64 #s(literal 1 binary64) n) < 2.00000000000000014e-17Initial program 33.3%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6459.8
Applied rewrites59.8%
Applied rewrites59.8%
if 2.00000000000000014e-17 < (/.f64 #s(literal 1 binary64) n) Initial program 69.4%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6480.2
Applied rewrites80.2%
Taylor expanded in x around 0
Applied rewrites67.8%
Taylor expanded in n around inf
Applied rewrites86.2%
Final simplification78.2%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (pow n -1.0))))
(if (<= (pow n -1.0) -1e-200)
(/ (/ t_0 x) n)
(if (<= (pow n -1.0) 5e-15)
(/ (- (log1p x) (log x)) n)
(- (fma (/ (fma x (+ (/ 0.5 n) -0.5) 1.0) n) x 1.0) t_0)))))
double code(double x, double n) {
double t_0 = pow(x, pow(n, -1.0));
double tmp;
if (pow(n, -1.0) <= -1e-200) {
tmp = (t_0 / x) / n;
} else if (pow(n, -1.0) <= 5e-15) {
tmp = (log1p(x) - log(x)) / n;
} else {
tmp = fma((fma(x, ((0.5 / n) + -0.5), 1.0) / n), x, 1.0) - t_0;
}
return tmp;
}
function code(x, n) t_0 = x ^ (n ^ -1.0) tmp = 0.0 if ((n ^ -1.0) <= -1e-200) tmp = Float64(Float64(t_0 / x) / n); elseif ((n ^ -1.0) <= 5e-15) tmp = Float64(Float64(log1p(x) - log(x)) / n); else tmp = Float64(fma(Float64(fma(x, Float64(Float64(0.5 / n) + -0.5), 1.0) / n), x, 1.0) - t_0); end return tmp end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[Power[n, -1.0], $MachinePrecision], -1e-200], N[(N[(t$95$0 / x), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[N[Power[n, -1.0], $MachinePrecision], 5e-15], N[(N[(N[Log[1 + x], $MachinePrecision] - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[(N[(N[(x * N[(N[(0.5 / n), $MachinePrecision] + -0.5), $MachinePrecision] + 1.0), $MachinePrecision] / n), $MachinePrecision] * x + 1.0), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left({n}^{-1}\right)}\\
\mathbf{if}\;{n}^{-1} \leq -1 \cdot 10^{-200}:\\
\;\;\;\;\frac{\frac{t\_0}{x}}{n}\\
\mathbf{elif}\;{n}^{-1} \leq 5 \cdot 10^{-15}:\\
\;\;\;\;\frac{\mathsf{log1p}\left(x\right) - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\mathsf{fma}\left(x, \frac{0.5}{n} + -0.5, 1\right)}{n}, x, 1\right) - t\_0\\
\end{array}
\end{array}
if (/.f64 #s(literal 1 binary64) n) < -9.9999999999999998e-201Initial program 72.9%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6487.5
Applied rewrites87.5%
if -9.9999999999999998e-201 < (/.f64 #s(literal 1 binary64) n) < 4.99999999999999999e-15Initial program 32.8%
Taylor expanded in n around inf
lower-/.f64N/A
lower--.f64N/A
lower-log1p.f64N/A
lower-log.f6484.6
Applied rewrites84.6%
if 4.99999999999999999e-15 < (/.f64 #s(literal 1 binary64) n) Initial program 70.2%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6481.3
Applied rewrites81.3%
Taylor expanded in x around 0
Applied rewrites68.5%
Taylor expanded in n around inf
Applied rewrites87.4%
Final simplification86.3%
(FPCore (x n)
:precision binary64
(if (<= x 3.9e-147)
(- (+ (/ x n) 1.0) (pow x (pow n -1.0)))
(if (<= x 9e-5)
(/ (- x (log x)) n)
(/ (pow n -1.0) (* x (pow x (/ -1.0 n)))))))
double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - pow(x, pow(n, -1.0));
} else if (x <= 9e-5) {
tmp = (x - log(x)) / n;
} else {
tmp = pow(n, -1.0) / (x * pow(x, (-1.0 / n)));
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if (x <= 3.9d-147) then
tmp = ((x / n) + 1.0d0) - (x ** (n ** (-1.0d0)))
else if (x <= 9d-5) then
tmp = (x - log(x)) / n
else
tmp = (n ** (-1.0d0)) / (x * (x ** ((-1.0d0) / n)))
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - Math.pow(x, Math.pow(n, -1.0));
} else if (x <= 9e-5) {
tmp = (x - Math.log(x)) / n;
} else {
tmp = Math.pow(n, -1.0) / (x * Math.pow(x, (-1.0 / n)));
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 3.9e-147: tmp = ((x / n) + 1.0) - math.pow(x, math.pow(n, -1.0)) elif x <= 9e-5: tmp = (x - math.log(x)) / n else: tmp = math.pow(n, -1.0) / (x * math.pow(x, (-1.0 / n))) return tmp
function code(x, n) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(Float64(Float64(x / n) + 1.0) - (x ^ (n ^ -1.0))); elseif (x <= 9e-5) tmp = Float64(Float64(x - log(x)) / n); else tmp = Float64((n ^ -1.0) / Float64(x * (x ^ Float64(-1.0 / n)))); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 3.9e-147) tmp = ((x / n) + 1.0) - (x ^ (n ^ -1.0)); elseif (x <= 9e-5) tmp = (x - log(x)) / n; else tmp = (n ^ -1.0) / (x * (x ^ (-1.0 / n))); end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 3.9e-147], N[(N[(N[(x / n), $MachinePrecision] + 1.0), $MachinePrecision] - N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Power[n, -1.0], $MachinePrecision] / N[(x * N[Power[x, N[(-1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;\left(\frac{x}{n} + 1\right) - {x}^{\left({n}^{-1}\right)}\\
\mathbf{elif}\;x \leq 9 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{{n}^{-1}}{x \cdot {x}^{\left(\frac{-1}{n}\right)}}\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6458.0
Applied rewrites58.0%
if 3.8999999999999998e-147 < x < 9.00000000000000057e-5Initial program 36.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites88.2%
Taylor expanded in n around inf
Applied rewrites60.4%
if 9.00000000000000057e-5 < x Initial program 68.2%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.9
Applied rewrites98.9%
Applied rewrites98.9%
Final simplification76.0%
(FPCore (x n)
:precision binary64
(let* ((t_0 (pow x (pow n -1.0))))
(if (<= x 3.9e-147)
(- (+ (/ x n) 1.0) t_0)
(if (<= x 9e-5) (/ (- x (log x)) n) (/ (/ t_0 x) n)))))
double code(double x, double n) {
double t_0 = pow(x, pow(n, -1.0));
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - t_0;
} else if (x <= 9e-5) {
tmp = (x - log(x)) / n;
} else {
tmp = (t_0 / x) / n;
}
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 ** (n ** (-1.0d0))
if (x <= 3.9d-147) then
tmp = ((x / n) + 1.0d0) - t_0
else if (x <= 9d-5) then
tmp = (x - log(x)) / n
else
tmp = (t_0 / x) / n
end if
code = tmp
end function
public static double code(double x, double n) {
double t_0 = Math.pow(x, Math.pow(n, -1.0));
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - t_0;
} else if (x <= 9e-5) {
tmp = (x - Math.log(x)) / n;
} else {
tmp = (t_0 / x) / n;
}
return tmp;
}
def code(x, n): t_0 = math.pow(x, math.pow(n, -1.0)) tmp = 0 if x <= 3.9e-147: tmp = ((x / n) + 1.0) - t_0 elif x <= 9e-5: tmp = (x - math.log(x)) / n else: tmp = (t_0 / x) / n return tmp
function code(x, n) t_0 = x ^ (n ^ -1.0) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(Float64(Float64(x / n) + 1.0) - t_0); elseif (x <= 9e-5) tmp = Float64(Float64(x - log(x)) / n); else tmp = Float64(Float64(t_0 / x) / n); end return tmp end
function tmp_2 = code(x, n) t_0 = x ^ (n ^ -1.0); tmp = 0.0; if (x <= 3.9e-147) tmp = ((x / n) + 1.0) - t_0; elseif (x <= 9e-5) tmp = (x - log(x)) / n; else tmp = (t_0 / x) / n; end tmp_2 = tmp; end
code[x_, n_] := Block[{t$95$0 = N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x, 3.9e-147], N[(N[(N[(x / n), $MachinePrecision] + 1.0), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[x, 9e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[(t$95$0 / x), $MachinePrecision] / n), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {x}^{\left({n}^{-1}\right)}\\
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;\left(\frac{x}{n} + 1\right) - t\_0\\
\mathbf{elif}\;x \leq 9 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{t\_0}{x}}{n}\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6458.0
Applied rewrites58.0%
if 3.8999999999999998e-147 < x < 9.00000000000000057e-5Initial program 36.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites88.2%
Taylor expanded in n around inf
Applied rewrites60.4%
if 9.00000000000000057e-5 < x Initial program 68.2%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.9
Applied rewrites98.9%
Final simplification76.0%
(FPCore (x n)
:precision binary64
(if (<= x 3.9e-147)
(- (+ (/ x n) 1.0) (pow x (pow n -1.0)))
(if (<= x 9e-5)
(/ (- x (log x)) n)
(pow (* (* x (pow x (/ -1.0 n))) n) -1.0))))
double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - pow(x, pow(n, -1.0));
} else if (x <= 9e-5) {
tmp = (x - log(x)) / n;
} else {
tmp = pow(((x * pow(x, (-1.0 / n))) * n), -1.0);
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if (x <= 3.9d-147) then
tmp = ((x / n) + 1.0d0) - (x ** (n ** (-1.0d0)))
else if (x <= 9d-5) then
tmp = (x - log(x)) / n
else
tmp = ((x * (x ** ((-1.0d0) / n))) * n) ** (-1.0d0)
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - Math.pow(x, Math.pow(n, -1.0));
} else if (x <= 9e-5) {
tmp = (x - Math.log(x)) / n;
} else {
tmp = Math.pow(((x * Math.pow(x, (-1.0 / n))) * n), -1.0);
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 3.9e-147: tmp = ((x / n) + 1.0) - math.pow(x, math.pow(n, -1.0)) elif x <= 9e-5: tmp = (x - math.log(x)) / n else: tmp = math.pow(((x * math.pow(x, (-1.0 / n))) * n), -1.0) return tmp
function code(x, n) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(Float64(Float64(x / n) + 1.0) - (x ^ (n ^ -1.0))); elseif (x <= 9e-5) tmp = Float64(Float64(x - log(x)) / n); else tmp = Float64(Float64(x * (x ^ Float64(-1.0 / n))) * n) ^ -1.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 3.9e-147) tmp = ((x / n) + 1.0) - (x ^ (n ^ -1.0)); elseif (x <= 9e-5) tmp = (x - log(x)) / n; else tmp = ((x * (x ^ (-1.0 / n))) * n) ^ -1.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 3.9e-147], N[(N[(N[(x / n), $MachinePrecision] + 1.0), $MachinePrecision] - N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[Power[N[(N[(x * N[Power[x, N[(-1.0 / n), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * n), $MachinePrecision], -1.0], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;\left(\frac{x}{n} + 1\right) - {x}^{\left({n}^{-1}\right)}\\
\mathbf{elif}\;x \leq 9 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;{\left(\left(x \cdot {x}^{\left(\frac{-1}{n}\right)}\right) \cdot n\right)}^{-1}\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6458.0
Applied rewrites58.0%
if 3.8999999999999998e-147 < x < 9.00000000000000057e-5Initial program 36.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites88.2%
Taylor expanded in n around inf
Applied rewrites60.4%
if 9.00000000000000057e-5 < x Initial program 68.2%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.9
Applied rewrites98.9%
Applied rewrites97.8%
Final simplification75.6%
(FPCore (x n) :precision binary64 (if (<= x 3.9e-147) (- (+ (/ x n) 1.0) (pow x (pow n -1.0))) (if (<= x 2e-5) (/ (- x (log x)) n) (/ (pow (* x x) -0.5) n))))
double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - pow(x, pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - log(x)) / n;
} else {
tmp = pow((x * x), -0.5) / n;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if (x <= 3.9d-147) then
tmp = ((x / n) + 1.0d0) - (x ** (n ** (-1.0d0)))
else if (x <= 2d-5) then
tmp = (x - log(x)) / n
else
tmp = ((x * x) ** (-0.5d0)) / n
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = ((x / n) + 1.0) - Math.pow(x, Math.pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - Math.log(x)) / n;
} else {
tmp = Math.pow((x * x), -0.5) / n;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 3.9e-147: tmp = ((x / n) + 1.0) - math.pow(x, math.pow(n, -1.0)) elif x <= 2e-5: tmp = (x - math.log(x)) / n else: tmp = math.pow((x * x), -0.5) / n return tmp
function code(x, n) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(Float64(Float64(x / n) + 1.0) - (x ^ (n ^ -1.0))); elseif (x <= 2e-5) tmp = Float64(Float64(x - log(x)) / n); else tmp = Float64((Float64(x * x) ^ -0.5) / n); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 3.9e-147) tmp = ((x / n) + 1.0) - (x ^ (n ^ -1.0)); elseif (x <= 2e-5) tmp = (x - log(x)) / n; else tmp = ((x * x) ^ -0.5) / n; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 3.9e-147], N[(N[(N[(x / n), $MachinePrecision] + 1.0), $MachinePrecision] - N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Power[N[(x * x), $MachinePrecision], -0.5], $MachinePrecision] / n), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;\left(\frac{x}{n} + 1\right) - {x}^{\left({n}^{-1}\right)}\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(x \cdot x\right)}^{-0.5}}{n}\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
lower-+.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f6458.0
Applied rewrites58.0%
if 3.8999999999999998e-147 < x < 2.00000000000000016e-5Initial program 35.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites89.4%
Taylor expanded in n around inf
Applied rewrites61.3%
if 2.00000000000000016e-5 < x Initial program 68.5%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.0
Applied rewrites98.0%
Taylor expanded in n around inf
Applied rewrites63.8%
Applied rewrites81.2%
Final simplification68.8%
(FPCore (x n) :precision binary64 (if (<= x 3.9e-147) (- 1.0 (pow x (pow n -1.0))) (if (<= x 2e-5) (/ (- x (log x)) n) (/ (pow (* x x) -0.5) n))))
double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = 1.0 - pow(x, pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - log(x)) / n;
} else {
tmp = pow((x * x), -0.5) / n;
}
return tmp;
}
real(8) function code(x, n)
real(8), intent (in) :: x
real(8), intent (in) :: n
real(8) :: tmp
if (x <= 3.9d-147) then
tmp = 1.0d0 - (x ** (n ** (-1.0d0)))
else if (x <= 2d-5) then
tmp = (x - log(x)) / n
else
tmp = ((x * x) ** (-0.5d0)) / n
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = 1.0 - Math.pow(x, Math.pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - Math.log(x)) / n;
} else {
tmp = Math.pow((x * x), -0.5) / n;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 3.9e-147: tmp = 1.0 - math.pow(x, math.pow(n, -1.0)) elif x <= 2e-5: tmp = (x - math.log(x)) / n else: tmp = math.pow((x * x), -0.5) / n return tmp
function code(x, n) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(1.0 - (x ^ (n ^ -1.0))); elseif (x <= 2e-5) tmp = Float64(Float64(x - log(x)) / n); else tmp = Float64((Float64(x * x) ^ -0.5) / n); end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 3.9e-147) tmp = 1.0 - (x ^ (n ^ -1.0)); elseif (x <= 2e-5) tmp = (x - log(x)) / n; else tmp = ((x * x) ^ -0.5) / n; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 3.9e-147], N[(1.0 - N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], N[(N[Power[N[(x * x), $MachinePrecision], -0.5], $MachinePrecision] / n), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;1 - {x}^{\left({n}^{-1}\right)}\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(x \cdot x\right)}^{-0.5}}{n}\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
Applied rewrites57.0%
if 3.8999999999999998e-147 < x < 2.00000000000000016e-5Initial program 35.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites89.4%
Taylor expanded in n around inf
Applied rewrites61.3%
if 2.00000000000000016e-5 < x Initial program 68.5%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6498.0
Applied rewrites98.0%
Taylor expanded in n around inf
Applied rewrites63.8%
Applied rewrites81.2%
Final simplification68.5%
(FPCore (x n)
:precision binary64
(if (<= x 3.9e-147)
(- 1.0 (pow x (pow n -1.0)))
(if (<= x 2e-5)
(/ (- x (log x)) n)
(if (<= x 7.2e+81) (/ (/ -1.0 n) (- x)) 0.0))))
double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = 1.0 - pow(x, pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - log(x)) / n;
} else if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} 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 <= 3.9d-147) then
tmp = 1.0d0 - (x ** (n ** (-1.0d0)))
else if (x <= 2d-5) then
tmp = (x - log(x)) / n
else if (x <= 7.2d+81) then
tmp = ((-1.0d0) / n) / -x
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 3.9e-147) {
tmp = 1.0 - Math.pow(x, Math.pow(n, -1.0));
} else if (x <= 2e-5) {
tmp = (x - Math.log(x)) / n;
} else if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 3.9e-147: tmp = 1.0 - math.pow(x, math.pow(n, -1.0)) elif x <= 2e-5: tmp = (x - math.log(x)) / n elif x <= 7.2e+81: tmp = (-1.0 / n) / -x else: tmp = 0.0 return tmp
function code(x, n) tmp = 0.0 if (x <= 3.9e-147) tmp = Float64(1.0 - (x ^ (n ^ -1.0))); elseif (x <= 2e-5) tmp = Float64(Float64(x - log(x)) / n); elseif (x <= 7.2e+81) tmp = Float64(Float64(-1.0 / n) / Float64(-x)); else tmp = 0.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 3.9e-147) tmp = 1.0 - (x ^ (n ^ -1.0)); elseif (x <= 2e-5) tmp = (x - log(x)) / n; elseif (x <= 7.2e+81) tmp = (-1.0 / n) / -x; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 3.9e-147], N[(1.0 - N[Power[x, N[Power[n, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[x, 7.2e+81], N[(N[(-1.0 / n), $MachinePrecision] / (-x)), $MachinePrecision], 0.0]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3.9 \cdot 10^{-147}:\\
\;\;\;\;1 - {x}^{\left({n}^{-1}\right)}\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{elif}\;x \leq 7.2 \cdot 10^{+81}:\\
\;\;\;\;\frac{\frac{-1}{n}}{-x}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 3.8999999999999998e-147Initial program 57.0%
Taylor expanded in x around 0
Applied rewrites57.0%
if 3.8999999999999998e-147 < x < 2.00000000000000016e-5Initial program 35.5%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites89.4%
Taylor expanded in n around inf
Applied rewrites61.3%
if 2.00000000000000016e-5 < x < 7.20000000000000011e81Initial program 29.8%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6493.4
Applied rewrites93.4%
Applied rewrites93.5%
Taylor expanded in n around inf
Applied rewrites78.4%
if 7.20000000000000011e81 < x Initial program 84.3%
lift-pow.f64N/A
lift-/.f64N/A
metadata-evalN/A
distribute-neg-fracN/A
pow-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f6484.3
Applied rewrites84.3%
Taylor expanded in x around inf
rec-expN/A
mul-1-negN/A
+-inverses84.3
Applied rewrites84.3%
Final simplification69.1%
(FPCore (x n) :precision binary64 (if (<= x 2e-5) (/ (- x (log x)) n) (if (<= x 7.2e+81) (/ (/ -1.0 n) (- x)) 0.0)))
double code(double x, double n) {
double tmp;
if (x <= 2e-5) {
tmp = (x - log(x)) / n;
} else if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} 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 <= 2d-5) then
tmp = (x - log(x)) / n
else if (x <= 7.2d+81) then
tmp = ((-1.0d0) / n) / -x
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 2e-5) {
tmp = (x - Math.log(x)) / n;
} else if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 2e-5: tmp = (x - math.log(x)) / n elif x <= 7.2e+81: tmp = (-1.0 / n) / -x else: tmp = 0.0 return tmp
function code(x, n) tmp = 0.0 if (x <= 2e-5) tmp = Float64(Float64(x - log(x)) / n); elseif (x <= 7.2e+81) tmp = Float64(Float64(-1.0 / n) / Float64(-x)); else tmp = 0.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 2e-5) tmp = (x - log(x)) / n; elseif (x <= 7.2e+81) tmp = (-1.0 / n) / -x; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 2e-5], N[(N[(x - N[Log[x], $MachinePrecision]), $MachinePrecision] / n), $MachinePrecision], If[LessEqual[x, 7.2e+81], N[(N[(-1.0 / n), $MachinePrecision] / (-x)), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{x - \log x}{n}\\
\mathbf{elif}\;x \leq 7.2 \cdot 10^{+81}:\\
\;\;\;\;\frac{\frac{-1}{n}}{-x}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 2.00000000000000016e-5Initial program 47.3%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
*-rgt-identityN/A
associate-*r/N/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-fracN/A
mul-1-negN/A
log-recN/A
mul-1-negN/A
associate-+l-N/A
lower--.f64N/A
associate-*r/N/A
*-rgt-identityN/A
lower-/.f64N/A
Applied rewrites92.6%
Taylor expanded in n around inf
Applied rewrites51.4%
if 2.00000000000000016e-5 < x < 7.20000000000000011e81Initial program 29.8%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6493.4
Applied rewrites93.4%
Applied rewrites93.5%
Taylor expanded in n around inf
Applied rewrites78.4%
if 7.20000000000000011e81 < x Initial program 84.3%
lift-pow.f64N/A
lift-/.f64N/A
metadata-evalN/A
distribute-neg-fracN/A
pow-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f6484.3
Applied rewrites84.3%
Taylor expanded in x around inf
rec-expN/A
mul-1-negN/A
+-inverses84.3
Applied rewrites84.3%
Final simplification64.8%
(FPCore (x n) :precision binary64 (if (<= x 7.2e+81) (/ (pow x -1.0) n) 0.0))
double code(double x, double n) {
double tmp;
if (x <= 7.2e+81) {
tmp = pow(x, -1.0) / 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 <= 7.2d+81) then
tmp = (x ** (-1.0d0)) / n
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 7.2e+81) {
tmp = Math.pow(x, -1.0) / n;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 7.2e+81: tmp = math.pow(x, -1.0) / n else: tmp = 0.0 return tmp
function code(x, n) tmp = 0.0 if (x <= 7.2e+81) tmp = Float64((x ^ -1.0) / n); else tmp = 0.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 7.2e+81) tmp = (x ^ -1.0) / n; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 7.2e+81], N[(N[Power[x, -1.0], $MachinePrecision] / n), $MachinePrecision], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 7.2 \cdot 10^{+81}:\\
\;\;\;\;\frac{{x}^{-1}}{n}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 7.20000000000000011e81Initial program 44.1%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6441.4
Applied rewrites41.4%
Taylor expanded in n around inf
Applied rewrites30.7%
if 7.20000000000000011e81 < x Initial program 84.3%
lift-pow.f64N/A
lift-/.f64N/A
metadata-evalN/A
distribute-neg-fracN/A
pow-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f6484.3
Applied rewrites84.3%
Taylor expanded in x around inf
rec-expN/A
mul-1-negN/A
+-inverses84.3
Applied rewrites84.3%
Final simplification47.0%
(FPCore (x n) :precision binary64 (if (<= x 7.2e+81) (/ (/ -1.0 n) (- x)) 0.0))
double code(double x, double n) {
double tmp;
if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} 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 <= 7.2d+81) then
tmp = ((-1.0d0) / n) / -x
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double x, double n) {
double tmp;
if (x <= 7.2e+81) {
tmp = (-1.0 / n) / -x;
} else {
tmp = 0.0;
}
return tmp;
}
def code(x, n): tmp = 0 if x <= 7.2e+81: tmp = (-1.0 / n) / -x else: tmp = 0.0 return tmp
function code(x, n) tmp = 0.0 if (x <= 7.2e+81) tmp = Float64(Float64(-1.0 / n) / Float64(-x)); else tmp = 0.0; end return tmp end
function tmp_2 = code(x, n) tmp = 0.0; if (x <= 7.2e+81) tmp = (-1.0 / n) / -x; else tmp = 0.0; end tmp_2 = tmp; end
code[x_, n_] := If[LessEqual[x, 7.2e+81], N[(N[(-1.0 / n), $MachinePrecision] / (-x)), $MachinePrecision], 0.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 7.2 \cdot 10^{+81}:\\
\;\;\;\;\frac{\frac{-1}{n}}{-x}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if x < 7.20000000000000011e81Initial program 44.1%
Taylor expanded in x around inf
associate-/l/N/A
lower-/.f64N/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-/.f6441.4
Applied rewrites41.4%
Applied rewrites41.4%
Taylor expanded in n around inf
Applied rewrites30.7%
if 7.20000000000000011e81 < x Initial program 84.3%
lift-pow.f64N/A
lift-/.f64N/A
metadata-evalN/A
distribute-neg-fracN/A
pow-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f6484.3
Applied rewrites84.3%
Taylor expanded in x around inf
rec-expN/A
mul-1-negN/A
+-inverses84.3
Applied rewrites84.3%
Final simplification47.1%
(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 56.4%
lift-pow.f64N/A
lift-/.f64N/A
metadata-evalN/A
distribute-neg-fracN/A
pow-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f6456.4
Applied rewrites56.4%
Taylor expanded in x around inf
rec-expN/A
mul-1-negN/A
+-inverses30.9
Applied rewrites30.9%
Final simplification30.9%
herbie shell --seed 2024296
(FPCore (x n)
:name "2nthrt (problem 3.4.6)"
:precision binary64
(- (pow (+ x 1.0) (/ 1.0 n)) (pow x (/ 1.0 n))))