
(FPCore (N) :precision binary64 (- (log (+ N 1.0)) (log N)))
double code(double N) {
return log((N + 1.0)) - log(N);
}
real(8) function code(n)
real(8), intent (in) :: n
code = log((n + 1.0d0)) - log(n)
end function
public static double code(double N) {
return Math.log((N + 1.0)) - Math.log(N);
}
def code(N): return math.log((N + 1.0)) - math.log(N)
function code(N) return Float64(log(Float64(N + 1.0)) - log(N)) end
function tmp = code(N) tmp = log((N + 1.0)) - log(N); end
code[N_] := N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log \left(N + 1\right) - \log N
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (N) :precision binary64 (- (log (+ N 1.0)) (log N)))
double code(double N) {
return log((N + 1.0)) - log(N);
}
real(8) function code(n)
real(8), intent (in) :: n
code = log((n + 1.0d0)) - log(n)
end function
public static double code(double N) {
return Math.log((N + 1.0)) - Math.log(N);
}
def code(N): return math.log((N + 1.0)) - math.log(N)
function code(N) return Float64(log(Float64(N + 1.0)) - log(N)) end
function tmp = code(N) tmp = log((N + 1.0)) - log(N); end
code[N_] := N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log \left(N + 1\right) - \log N
\end{array}
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0006)
(+
(/ 0.3333333333333333 (pow N 3.0))
(-
(/ 1.0 (+ 0.5 (+ N (+ (/ 0.25 N) (/ 0.125 (pow N 2.0))))))
(/ 0.25 (pow N 4.0))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0006) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((1.0 / (0.5 + (N + ((0.25 / N) + (0.125 / pow(N, 2.0)))))) - (0.25 / pow(N, 4.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0006d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 / (0.5d0 + (n + ((0.25d0 / n) + (0.125d0 / (n ** 2.0d0)))))) - (0.25d0 / (n ** 4.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0006) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 / (0.5 + (N + ((0.25 / N) + (0.125 / Math.pow(N, 2.0)))))) - (0.25 / Math.pow(N, 4.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0006: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 / (0.5 + (N + ((0.25 / N) + (0.125 / math.pow(N, 2.0)))))) - (0.25 / math.pow(N, 4.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0006) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 / Float64(0.5 + Float64(N + Float64(Float64(0.25 / N) + Float64(0.125 / (N ^ 2.0)))))) - Float64(0.25 / (N ^ 4.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0006) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((1.0 / (0.5 + (N + ((0.25 / N) + (0.125 / (N ^ 2.0)))))) - (0.25 / (N ^ 4.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0006], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / N[(0.5 + N[(N + N[(N[(0.25 / N), $MachinePrecision] + N[(0.125 / N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0006:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\frac{1}{0.5 + \left(N + \left(\frac{0.25}{N} + \frac{0.125}{{N}^{2}}\right)\right)} - \frac{0.25}{{N}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.99999999999999947e-4Initial program 19.9%
+-commutative19.9%
log1p-def20.0%
Simplified20.0%
Taylor expanded in N around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
metadata-eval99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in N around 0 99.7%
associate--r+99.6%
associate-*r/99.6%
metadata-eval99.6%
associate-*r/99.6%
metadata-eval99.6%
Simplified99.6%
frac-sub99.4%
unpow299.4%
cube-mult99.3%
clear-num99.4%
*-un-lft-identity99.4%
unpow299.4%
distribute-lft-out--99.4%
Applied egg-rr99.4%
Taylor expanded in N around inf 99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
if 5.99999999999999947e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 93.3%
+-commutative93.3%
log1p-def93.3%
Simplified93.3%
add-log-exp92.6%
add-cube-cbrt91.7%
log-prod91.5%
pow291.5%
exp-diff91.2%
log1p-udef91.2%
rem-exp-log91.2%
add-exp-log91.5%
+-commutative91.5%
exp-diff91.7%
log1p-udef91.7%
rem-exp-log91.3%
add-exp-log91.5%
Applied egg-rr91.5%
log-pow91.1%
distribute-lft1-in91.1%
metadata-eval91.1%
Simplified91.1%
add-log-exp91.2%
*-commutative91.2%
exp-to-pow91.5%
pow391.7%
add-cube-cbrt94.2%
clear-num94.1%
log-div96.3%
metadata-eval96.3%
Applied egg-rr96.3%
neg-sub096.3%
Simplified96.3%
Final simplification99.5%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0005)
(+
(/ 0.3333333333333333 (pow N 3.0))
(- (* N (* (pow N -3.0) (+ N -0.5))) (/ 0.25 (pow N 4.0))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((N * (pow(N, -3.0) * (N + -0.5))) - (0.25 / pow(N, 4.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0005d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((n * ((n ** (-3.0d0)) * (n + (-0.5d0)))) - (0.25d0 / (n ** 4.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((N * (Math.pow(N, -3.0) * (N + -0.5))) - (0.25 / Math.pow(N, 4.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0005: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((N * (math.pow(N, -3.0) * (N + -0.5))) - (0.25 / math.pow(N, 4.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(N * Float64((N ^ -3.0) * Float64(N + -0.5))) - Float64(0.25 / (N ^ 4.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0005) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((N * ((N ^ -3.0) * (N + -0.5))) - (0.25 / (N ^ 4.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0005], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(N * N[(N[Power[N, -3.0], $MachinePrecision] * N[(N + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(N \cdot \left({N}^{-3} \cdot \left(N + -0.5\right)\right) - \frac{0.25}{{N}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 19.7%
+-commutative19.7%
log1p-def19.7%
Simplified19.7%
Taylor expanded in N around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
metadata-eval99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in N around 0 99.7%
associate--r+99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
frac-sub99.4%
unpow299.4%
cube-mult99.3%
div-inv99.2%
*-un-lft-identity99.2%
unpow299.2%
distribute-lft-out--99.3%
pow-flip99.4%
metadata-eval99.4%
Applied egg-rr99.4%
associate-*l*99.3%
sub-neg99.3%
metadata-eval99.3%
Simplified99.3%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 92.4%
+-commutative92.4%
log1p-def92.4%
Simplified92.4%
add-log-exp91.8%
add-cube-cbrt90.9%
log-prod90.7%
pow290.7%
exp-diff90.4%
log1p-udef90.4%
rem-exp-log90.4%
add-exp-log91.0%
+-commutative91.0%
exp-diff91.2%
log1p-udef91.2%
rem-exp-log90.8%
add-exp-log91.0%
Applied egg-rr91.0%
log-pow90.8%
distribute-lft1-in90.8%
metadata-eval90.8%
Simplified90.8%
add-log-exp90.7%
*-commutative90.7%
exp-to-pow90.9%
pow391.1%
add-cube-cbrt93.5%
clear-num93.4%
log-div95.8%
metadata-eval95.8%
Applied egg-rr95.8%
neg-sub095.8%
Simplified95.8%
Final simplification99.1%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0005)
(+
(/ 0.3333333333333333 (pow N 3.0))
(- (* (* N (- N 0.5)) (pow N -3.0)) (/ 0.25 (pow N 4.0))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + (((N * (N - 0.5)) * pow(N, -3.0)) - (0.25 / pow(N, 4.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0005d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + (((n * (n - 0.5d0)) * (n ** (-3.0d0))) - (0.25d0 / (n ** 4.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + (((N * (N - 0.5)) * Math.pow(N, -3.0)) - (0.25 / Math.pow(N, 4.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0005: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + (((N * (N - 0.5)) * math.pow(N, -3.0)) - (0.25 / math.pow(N, 4.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(Float64(N * Float64(N - 0.5)) * (N ^ -3.0)) - Float64(0.25 / (N ^ 4.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0005) tmp = (0.3333333333333333 / (N ^ 3.0)) + (((N * (N - 0.5)) * (N ^ -3.0)) - (0.25 / (N ^ 4.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0005], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N * N[(N - 0.5), $MachinePrecision]), $MachinePrecision] * N[Power[N, -3.0], $MachinePrecision]), $MachinePrecision] - N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\left(N \cdot \left(N - 0.5\right)\right) \cdot {N}^{-3} - \frac{0.25}{{N}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 19.7%
+-commutative19.7%
log1p-def19.7%
Simplified19.7%
Taylor expanded in N around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
metadata-eval99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in N around 0 99.7%
associate--r+99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
frac-sub99.4%
unpow299.4%
cube-mult99.3%
div-inv99.2%
*-un-lft-identity99.2%
unpow299.2%
distribute-lft-out--99.3%
pow-flip99.4%
metadata-eval99.4%
Applied egg-rr99.4%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 92.4%
+-commutative92.4%
log1p-def92.4%
Simplified92.4%
add-log-exp91.8%
add-cube-cbrt90.9%
log-prod90.7%
pow290.7%
exp-diff90.4%
log1p-udef90.4%
rem-exp-log90.4%
add-exp-log91.0%
+-commutative91.0%
exp-diff91.2%
log1p-udef91.2%
rem-exp-log90.8%
add-exp-log91.0%
Applied egg-rr91.0%
log-pow90.8%
distribute-lft1-in90.8%
metadata-eval90.8%
Simplified90.8%
add-log-exp90.7%
*-commutative90.7%
exp-to-pow90.9%
pow391.1%
add-cube-cbrt93.5%
clear-num93.4%
log-div95.8%
metadata-eval95.8%
Applied egg-rr95.8%
neg-sub095.8%
Simplified95.8%
Final simplification99.2%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0005)
(+
(/ 0.3333333333333333 (pow N 3.0))
(- (- (/ 1.0 N) (/ 0.5 (pow N 2.0))) (/ 0.25 (pow N 4.0))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + (((1.0 / N) - (0.5 / pow(N, 2.0))) - (0.25 / pow(N, 4.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0005d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + (((1.0d0 / n) - (0.5d0 / (n ** 2.0d0))) - (0.25d0 / (n ** 4.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + (((1.0 / N) - (0.5 / Math.pow(N, 2.0))) - (0.25 / Math.pow(N, 4.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0005: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + (((1.0 / N) - (0.5 / math.pow(N, 2.0))) - (0.25 / math.pow(N, 4.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(Float64(1.0 / N) - Float64(0.5 / (N ^ 2.0))) - Float64(0.25 / (N ^ 4.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0005) tmp = (0.3333333333333333 / (N ^ 3.0)) + (((1.0 / N) - (0.5 / (N ^ 2.0))) - (0.25 / (N ^ 4.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0005], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(N[(1.0 / N), $MachinePrecision] - N[(0.5 / N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\left(\frac{1}{N} - \frac{0.5}{{N}^{2}}\right) - \frac{0.25}{{N}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 19.7%
+-commutative19.7%
log1p-def19.7%
Simplified19.7%
Taylor expanded in N around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
metadata-eval99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in N around 0 99.7%
associate--r+99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 92.4%
+-commutative92.4%
log1p-def92.4%
Simplified92.4%
add-log-exp91.8%
add-cube-cbrt90.9%
log-prod90.7%
pow290.7%
exp-diff90.4%
log1p-udef90.4%
rem-exp-log90.4%
add-exp-log91.0%
+-commutative91.0%
exp-diff91.2%
log1p-udef91.2%
rem-exp-log90.8%
add-exp-log91.0%
Applied egg-rr91.0%
log-pow90.8%
distribute-lft1-in90.8%
metadata-eval90.8%
Simplified90.8%
add-log-exp90.7%
*-commutative90.7%
exp-to-pow90.9%
pow391.1%
add-cube-cbrt93.5%
clear-num93.4%
log-div95.8%
metadata-eval95.8%
Applied egg-rr95.8%
neg-sub095.8%
Simplified95.8%
Final simplification99.5%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0005)
(+
(/ 0.3333333333333333 (pow N 3.0))
(- (/ 1.0 N) (+ (/ 0.25 (pow N 4.0)) (/ 0.5 (pow N 2.0)))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((1.0 / N) - ((0.25 / pow(N, 4.0)) + (0.5 / pow(N, 2.0))));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0005d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 / n) - ((0.25d0 / (n ** 4.0d0)) + (0.5d0 / (n ** 2.0d0))))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0005) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 / N) - ((0.25 / Math.pow(N, 4.0)) + (0.5 / Math.pow(N, 2.0))));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0005: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 / N) - ((0.25 / math.pow(N, 4.0)) + (0.5 / math.pow(N, 2.0)))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 / N) - Float64(Float64(0.25 / (N ^ 4.0)) + Float64(0.5 / (N ^ 2.0))))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0005) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((1.0 / N) - ((0.25 / (N ^ 4.0)) + (0.5 / (N ^ 2.0)))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0005], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / N), $MachinePrecision] - N[(N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision] + N[(0.5 / N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\frac{1}{N} - \left(\frac{0.25}{{N}^{4}} + \frac{0.5}{{N}^{2}}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 19.7%
+-commutative19.7%
log1p-def19.7%
Simplified19.7%
Taylor expanded in N around inf 99.7%
associate--l+99.7%
associate-*r/99.7%
metadata-eval99.7%
+-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 92.4%
+-commutative92.4%
log1p-def92.4%
Simplified92.4%
add-log-exp91.8%
add-cube-cbrt90.9%
log-prod90.7%
pow290.7%
exp-diff90.4%
log1p-udef90.4%
rem-exp-log90.4%
add-exp-log91.0%
+-commutative91.0%
exp-diff91.2%
log1p-udef91.2%
rem-exp-log90.8%
add-exp-log91.0%
Applied egg-rr91.0%
log-pow90.8%
distribute-lft1-in90.8%
metadata-eval90.8%
Simplified90.8%
add-log-exp90.7%
*-commutative90.7%
exp-to-pow90.9%
pow391.1%
add-cube-cbrt93.5%
clear-num93.4%
log-div95.8%
metadata-eval95.8%
Applied egg-rr95.8%
neg-sub095.8%
Simplified95.8%
Final simplification99.5%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.00015)
(+
(/ 0.3333333333333333 (pow N 3.0))
(- (/ 1.0 (+ N (+ 0.5 (/ 0.25 N)))) (/ 0.25 (pow N 4.0))))
(- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.00015) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((1.0 / (N + (0.5 + (0.25 / N)))) - (0.25 / pow(N, 4.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.00015d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 / (n + (0.5d0 + (0.25d0 / n)))) - (0.25d0 / (n ** 4.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.00015) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 / (N + (0.5 + (0.25 / N)))) - (0.25 / Math.pow(N, 4.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.00015: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 / (N + (0.5 + (0.25 / N)))) - (0.25 / math.pow(N, 4.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.00015) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 / Float64(N + Float64(0.5 + Float64(0.25 / N)))) - Float64(0.25 / (N ^ 4.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.00015) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((1.0 / (N + (0.5 + (0.25 / N)))) - (0.25 / (N ^ 4.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.00015], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / N[(N + N[(0.5 + N[(0.25 / N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.25 / N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.00015:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\frac{1}{N + \left(0.5 + \frac{0.25}{N}\right)} - \frac{0.25}{{N}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 1.49999999999999987e-4Initial program 18.4%
+-commutative18.4%
log1p-def18.4%
Simplified18.4%
Taylor expanded in N around inf 99.8%
associate--l+99.8%
associate-*r/99.8%
metadata-eval99.8%
+-commutative99.8%
associate-*r/99.8%
metadata-eval99.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in N around 0 99.8%
associate--r+99.8%
associate-*r/99.8%
metadata-eval99.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
frac-sub99.5%
unpow299.5%
cube-mult99.5%
clear-num99.6%
*-un-lft-identity99.6%
unpow299.6%
distribute-lft-out--99.6%
Applied egg-rr99.6%
Taylor expanded in N around inf 99.5%
associate-+r+99.5%
+-commutative99.5%
associate-+l+99.5%
associate-*r/99.5%
metadata-eval99.5%
Simplified99.5%
if 1.49999999999999987e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 89.1%
+-commutative89.1%
log1p-def89.1%
Simplified89.1%
add-log-exp88.5%
add-cube-cbrt87.9%
log-prod87.6%
pow287.6%
exp-diff87.4%
log1p-udef87.4%
rem-exp-log87.8%
add-exp-log87.8%
+-commutative87.8%
exp-diff87.8%
log1p-udef87.8%
rem-exp-log87.9%
add-exp-log87.6%
Applied egg-rr87.6%
log-pow87.5%
distribute-lft1-in87.5%
metadata-eval87.5%
Simplified87.5%
add-log-exp87.4%
*-commutative87.4%
exp-to-pow87.6%
pow387.7%
add-cube-cbrt90.7%
clear-num90.7%
log-div93.0%
metadata-eval93.0%
Applied egg-rr93.0%
neg-sub093.0%
Simplified93.0%
Final simplification99.0%
(FPCore (N) :precision binary64 (if (<= (- (log (+ N 1.0)) (log N)) 0.0001) (+ (/ 0.3333333333333333 (pow N 3.0)) (- (/ 1.0 N) (/ 0.5 (pow N 2.0)))) (- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0001) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((1.0 / N) - (0.5 / pow(N, 2.0)));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 0.0001d0) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 / n) - (0.5d0 / (n ** 2.0d0)))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0001) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 / N) - (0.5 / Math.pow(N, 2.0)));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0001: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 / N) - (0.5 / math.pow(N, 2.0))) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0001) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 / N) - Float64(0.5 / (N ^ 2.0)))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 0.0001) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((1.0 / N) - (0.5 / (N ^ 2.0))); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0001], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / N), $MachinePrecision] - N[(0.5 / N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0001:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \left(\frac{1}{N} - \frac{0.5}{{N}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 1.00000000000000005e-4Initial program 18.2%
+-commutative18.2%
log1p-def18.2%
Simplified18.2%
Taylor expanded in N around inf 99.4%
associate--l+99.4%
associate-*r/99.4%
metadata-eval99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
if 1.00000000000000005e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 88.5%
+-commutative88.5%
log1p-def88.5%
Simplified88.5%
add-log-exp87.9%
add-cube-cbrt87.3%
log-prod87.0%
pow287.0%
exp-diff86.9%
log1p-udef86.9%
rem-exp-log87.6%
add-exp-log87.2%
+-commutative87.2%
exp-diff87.3%
log1p-udef87.3%
rem-exp-log87.6%
add-exp-log87.2%
Applied egg-rr87.2%
log-pow87.1%
distribute-lft1-in87.1%
metadata-eval87.1%
Simplified87.1%
add-log-exp87.0%
*-commutative87.0%
exp-to-pow87.2%
pow387.2%
add-cube-cbrt90.3%
clear-num90.3%
log-div92.5%
metadata-eval92.5%
Applied egg-rr92.5%
neg-sub092.5%
Simplified92.5%
Final simplification98.9%
(FPCore (N) :precision binary64 (if (<= (- (log (+ N 1.0)) (log N)) 2e-6) (- (/ 1.0 N) (/ 0.5 (pow N 2.0))) (- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 2e-6) {
tmp = (1.0 / N) - (0.5 / pow(N, 2.0));
} else {
tmp = -log((N / (N + 1.0)));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 2d-6) then
tmp = (1.0d0 / n) - (0.5d0 / (n ** 2.0d0))
else
tmp = -log((n / (n + 1.0d0)))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 2e-6) {
tmp = (1.0 / N) - (0.5 / Math.pow(N, 2.0));
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 2e-6: tmp = (1.0 / N) - (0.5 / math.pow(N, 2.0)) else: tmp = -math.log((N / (N + 1.0))) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 2e-6) tmp = Float64(Float64(1.0 / N) - Float64(0.5 / (N ^ 2.0))); else tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 2e-6) tmp = (1.0 / N) - (0.5 / (N ^ 2.0)); else tmp = -log((N / (N + 1.0))); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 2e-6], N[(N[(1.0 / N), $MachinePrecision] - N[(0.5 / N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\frac{1}{N} - \frac{0.5}{{N}^{2}}\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 1.99999999999999991e-6Initial program 14.9%
+-commutative14.9%
log1p-def14.9%
Simplified14.9%
Taylor expanded in N around inf 99.1%
associate-*r/99.1%
metadata-eval99.1%
Simplified99.1%
if 1.99999999999999991e-6 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 83.0%
+-commutative83.0%
log1p-def83.0%
Simplified83.0%
add-log-exp82.7%
add-cube-cbrt82.1%
log-prod82.5%
pow282.5%
exp-diff82.3%
log1p-udef82.3%
rem-exp-log82.5%
add-exp-log82.8%
+-commutative82.8%
exp-diff82.8%
log1p-udef82.8%
rem-exp-log83.1%
add-exp-log82.3%
Applied egg-rr82.3%
log-pow82.7%
distribute-lft1-in82.7%
metadata-eval82.7%
Simplified82.7%
add-log-exp82.4%
*-commutative82.4%
exp-to-pow82.5%
pow382.3%
add-cube-cbrt86.1%
clear-num86.0%
log-div87.2%
metadata-eval87.2%
Applied egg-rr87.2%
neg-sub087.2%
Simplified87.2%
Final simplification97.6%
(FPCore (N) :precision binary64 (if (<= N 130000000.0) (- (log (/ N (+ N 1.0)))) (/ 1.0 N)))
double code(double N) {
double tmp;
if (N <= 130000000.0) {
tmp = -log((N / (N + 1.0)));
} else {
tmp = 1.0 / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 130000000.0d0) then
tmp = -log((n / (n + 1.0d0)))
else
tmp = 1.0d0 / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 130000000.0) {
tmp = -Math.log((N / (N + 1.0)));
} else {
tmp = 1.0 / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 130000000.0: tmp = -math.log((N / (N + 1.0))) else: tmp = 1.0 / N return tmp
function code(N) tmp = 0.0 if (N <= 130000000.0) tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); else tmp = Float64(1.0 / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 130000000.0) tmp = -log((N / (N + 1.0))); else tmp = 1.0 / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 130000000.0], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), N[(1.0 / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 130000000:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{N}\\
\end{array}
\end{array}
if N < 1.3e8Initial program 75.6%
+-commutative75.6%
log1p-def75.6%
Simplified75.6%
add-log-exp75.5%
add-cube-cbrt75.1%
log-prod75.4%
pow275.4%
exp-diff75.2%
log1p-udef75.2%
rem-exp-log75.2%
add-exp-log75.9%
+-commutative75.9%
exp-diff75.9%
log1p-udef75.9%
rem-exp-log75.9%
add-exp-log75.9%
Applied egg-rr75.9%
log-pow76.1%
distribute-lft1-in76.1%
metadata-eval76.1%
Simplified76.1%
add-log-exp75.9%
*-commutative75.9%
exp-to-pow75.9%
pow375.8%
add-cube-cbrt79.1%
clear-num79.0%
log-div80.2%
metadata-eval80.2%
Applied egg-rr80.2%
neg-sub080.2%
Simplified80.2%
if 1.3e8 < N Initial program 10.4%
+-commutative10.4%
log1p-def10.4%
Simplified10.4%
Taylor expanded in N around inf 95.6%
Final simplification92.5%
(FPCore (N) :precision binary64 (if (<= N 200000.0) (- (log (/ N (+ N 1.0)))) (* (+ N -0.5) (pow N -2.0))))
double code(double N) {
double tmp;
if (N <= 200000.0) {
tmp = -log((N / (N + 1.0)));
} else {
tmp = (N + -0.5) * pow(N, -2.0);
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 200000.0d0) then
tmp = -log((n / (n + 1.0d0)))
else
tmp = (n + (-0.5d0)) * (n ** (-2.0d0))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 200000.0) {
tmp = -Math.log((N / (N + 1.0)));
} else {
tmp = (N + -0.5) * Math.pow(N, -2.0);
}
return tmp;
}
def code(N): tmp = 0 if N <= 200000.0: tmp = -math.log((N / (N + 1.0))) else: tmp = (N + -0.5) * math.pow(N, -2.0) return tmp
function code(N) tmp = 0.0 if (N <= 200000.0) tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); else tmp = Float64(Float64(N + -0.5) * (N ^ -2.0)); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 200000.0) tmp = -log((N / (N + 1.0))); else tmp = (N + -0.5) * (N ^ -2.0); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 200000.0], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), N[(N[(N + -0.5), $MachinePrecision] * N[Power[N, -2.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 200000:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(N + -0.5\right) \cdot {N}^{-2}\\
\end{array}
\end{array}
if N < 2e5Initial program 83.0%
+-commutative83.0%
log1p-def83.0%
Simplified83.0%
add-log-exp82.7%
add-cube-cbrt82.1%
log-prod82.5%
pow282.5%
exp-diff82.3%
log1p-udef82.3%
rem-exp-log82.5%
add-exp-log82.8%
+-commutative82.8%
exp-diff82.8%
log1p-udef82.8%
rem-exp-log83.1%
add-exp-log82.3%
Applied egg-rr82.3%
log-pow82.7%
distribute-lft1-in82.7%
metadata-eval82.7%
Simplified82.7%
add-log-exp82.4%
*-commutative82.4%
exp-to-pow82.5%
pow382.3%
add-cube-cbrt86.1%
clear-num86.0%
log-div87.2%
metadata-eval87.2%
Applied egg-rr87.2%
neg-sub087.2%
Simplified87.2%
if 2e5 < N Initial program 14.9%
+-commutative14.9%
log1p-def14.9%
Simplified14.9%
add-log-exp14.9%
add-cube-cbrt14.9%
log-prod14.9%
pow214.9%
exp-diff14.9%
log1p-udef14.9%
rem-exp-log16.2%
add-exp-log15.5%
+-commutative15.5%
exp-diff15.5%
log1p-udef15.4%
rem-exp-log16.8%
add-exp-log15.7%
Applied egg-rr15.7%
log-pow15.7%
distribute-lft1-in15.7%
metadata-eval15.7%
Simplified15.7%
Taylor expanded in N around inf 98.7%
associate-*r/98.6%
metadata-eval98.6%
associate-*r/98.6%
metadata-eval98.6%
Simplified98.6%
clear-num98.5%
frac-sub98.5%
*-un-lft-identity98.5%
div-inv98.5%
metadata-eval98.5%
div-inv98.6%
metadata-eval98.6%
Applied egg-rr98.6%
unpow298.6%
associate-*l*98.6%
metadata-eval98.6%
distribute-lft-out--98.6%
sub-neg98.6%
metadata-eval98.6%
*-commutative98.6%
associate-*r*98.5%
unpow298.5%
cube-mult98.5%
Simplified98.5%
expm1-log1p-u98.5%
expm1-udef17.1%
associate-*r/17.1%
times-frac17.1%
metadata-eval17.1%
metadata-eval17.1%
times-frac17.1%
*-un-lft-identity17.1%
*-un-lft-identity17.1%
Applied egg-rr17.1%
expm1-def98.7%
expm1-log1p98.7%
*-commutative98.7%
associate-*r/98.7%
cube-mult98.6%
unpow298.6%
associate-/r*98.7%
*-inverses98.7%
unpow298.7%
associate-/r*99.0%
*-rgt-identity99.0%
associate-*r/98.7%
unpow-198.7%
metadata-eval98.7%
unpow-198.7%
metadata-eval98.7%
sqr-pow98.9%
Simplified98.9%
Final simplification97.4%
(FPCore (N) :precision binary64 (if (<= N 98000000.0) (log (/ (+ N 1.0) N)) (/ 1.0 N)))
double code(double N) {
double tmp;
if (N <= 98000000.0) {
tmp = log(((N + 1.0) / N));
} else {
tmp = 1.0 / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 98000000.0d0) then
tmp = log(((n + 1.0d0) / n))
else
tmp = 1.0d0 / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 98000000.0) {
tmp = Math.log(((N + 1.0) / N));
} else {
tmp = 1.0 / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 98000000.0: tmp = math.log(((N + 1.0) / N)) else: tmp = 1.0 / N return tmp
function code(N) tmp = 0.0 if (N <= 98000000.0) tmp = log(Float64(Float64(N + 1.0) / N)); else tmp = Float64(1.0 / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 98000000.0) tmp = log(((N + 1.0) / N)); else tmp = 1.0 / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 98000000.0], N[Log[N[(N[(N + 1.0), $MachinePrecision] / N), $MachinePrecision]], $MachinePrecision], N[(1.0 / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 98000000:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{N}\\
\end{array}
\end{array}
if N < 9.8e7Initial program 76.0%
+-commutative76.0%
log1p-def76.0%
Simplified76.0%
add-log-exp76.0%
log1p-expm1-u76.0%
log1p-udef75.9%
diff-log75.8%
log1p-udef75.8%
rem-exp-log75.2%
+-commutative75.2%
add-exp-log75.3%
log1p-udef75.4%
log1p-expm1-u75.4%
add-exp-log79.5%
Applied egg-rr79.5%
if 9.8e7 < N Initial program 10.6%
+-commutative10.6%
log1p-def10.7%
Simplified10.7%
Taylor expanded in N around inf 95.4%
Final simplification92.3%
(FPCore (N) :precision binary64 (/ 1.0 N))
double code(double N) {
return 1.0 / N;
}
real(8) function code(n)
real(8), intent (in) :: n
code = 1.0d0 / n
end function
public static double code(double N) {
return 1.0 / N;
}
def code(N): return 1.0 / N
function code(N) return Float64(1.0 / N) end
function tmp = code(N) tmp = 1.0 / N; end
code[N_] := N[(1.0 / N), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{N}
\end{array}
Initial program 23.4%
+-commutative23.4%
log1p-def23.4%
Simplified23.4%
Taylor expanded in N around inf 85.1%
Final simplification85.1%
(FPCore (N) :precision binary64 (log1p (/ 1.0 N)))
double code(double N) {
return log1p((1.0 / N));
}
public static double code(double N) {
return Math.log1p((1.0 / N));
}
def code(N): return math.log1p((1.0 / N))
function code(N) return log1p(Float64(1.0 / N)) end
code[N_] := N[Log[1 + N[(1.0 / N), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{log1p}\left(\frac{1}{N}\right)
\end{array}
herbie shell --seed 2024024
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
:pre (and (> N 1.0) (< N 1e+40))
:herbie-target
(log1p (/ 1.0 N))
(- (log (+ N 1.0)) (log N)))