
(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 7 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.0005)
(+
(/ (- 1.0 (/ 0.5 N)) N)
(+
(cast (! :precision binary32 (* 0.3333333333333333 (pow N -3.0))))
(/ (/ -0.25 (* N N)) (* N N))))
(- (log1p N) (log N))))
double code(double N) {
double tmp_1;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
float tmp_2 = 0.3333333333333333f * powf(N, -3.0f);
tmp_1 = ((1.0 - (0.5 / N)) / N) + (((double) ((double) tmp_2)) + ((-0.25 / (N * N)) / (N * N)));
} else {
tmp_1 = log1p(N) - log(N);
}
return tmp_1;
}
function code(N) tmp_1 = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp_2 = Float32(Float32(0.3333333333333333) * (N ^ Float32(-3.0))) tmp_1 = Float64(Float64(Float64(1.0 - Float64(0.5 / N)) / N) + Float64(Float64(Float64(tmp_2)) + Float64(Float64(-0.25 / Float64(N * N)) / Float64(N * N)))); else tmp_1 = Float64(log1p(N) - log(N)); end return tmp_1 end
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N} + \left(\langle \left( 0.3333333333333333 \cdot {N}^{-3} \right)_{\text{binary32}} \rangle_{\text{binary64}} + \frac{\frac{-0.25}{N \cdot N}}{N \cdot N}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(N\right) - \log N\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 8.8%
Taylor expanded in N around inf 99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
metadata-eval99.9%
pow-prod-up99.9%
pow-prod-down99.9%
pow299.9%
frac-times99.9%
Applied egg-rr99.9%
associate--r+99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
associate-/r*99.9%
sub-div99.9%
div-inv99.9%
pow-flip99.9%
metadata-eval99.9%
*-commutative99.9%
distribute-neg-frac99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-+l+99.9%
associate-*r/99.9%
associate-*l/99.9%
metadata-eval99.9%
Simplified99.9%
rewrite-binary64/binary32100.0%
Applied rewrite-once100.0%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 100.0%
+-commutative100.0%
log1p-def100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (N)
:precision binary64
(if (<= (- (log (+ N 1.0)) (log N)) 0.0005)
(+
(/ (- 1.0 (/ 0.5 N)) N)
(+ (/ (/ -0.25 (* N N)) (* N N)) (/ (/ 0.3333333333333333 (* N N)) N)))
(- (log1p N) (log N))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0005) {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
} else {
tmp = log1p(N) - log(N);
}
return tmp;
}
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 0.0005) {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
} else {
tmp = Math.log1p(N) - Math.log(N);
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 0.0005: tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)) else: tmp = math.log1p(N) - math.log(N) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 0.0005) tmp = Float64(Float64(Float64(1.0 - Float64(0.5 / N)) / N) + Float64(Float64(Float64(-0.25 / Float64(N * N)) / Float64(N * N)) + Float64(Float64(0.3333333333333333 / Float64(N * N)) / N))); else tmp = Float64(log1p(N) - log(N)); end return tmp end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 0.0005], N[(N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision] + N[(N[(N[(-0.25 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N[(N * N), $MachinePrecision]), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Log[1 + N], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 0.0005:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N} + \left(\frac{\frac{-0.25}{N \cdot N}}{N \cdot N} + \frac{\frac{0.3333333333333333}{N \cdot N}}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(N\right) - \log N\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.0000000000000001e-4Initial program 8.8%
Taylor expanded in N around inf 99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
metadata-eval99.9%
pow-prod-up99.9%
pow-prod-down99.9%
pow299.9%
frac-times99.9%
Applied egg-rr99.9%
associate--r+99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
associate-/r*99.9%
sub-div99.9%
div-inv99.9%
pow-flip99.9%
metadata-eval99.9%
*-commutative99.9%
distribute-neg-frac99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-+l+99.9%
associate-*r/99.9%
associate-*l/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
pow-flip99.9%
div-inv99.9%
unpow399.9%
associate-/r*99.9%
Applied egg-rr99.9%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 100.0%
+-commutative100.0%
log1p-def100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (N)
:precision binary64
(if (<= N 1400.0)
(log (/ (+ N 1.0) N))
(+
(/ (- 1.0 (/ 0.5 N)) N)
(+ (/ (/ -0.25 (* N N)) (* N N)) (/ (/ 0.3333333333333333 (* N N)) N)))))
double code(double N) {
double tmp;
if (N <= 1400.0) {
tmp = log(((N + 1.0) / N));
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 1400.0d0) then
tmp = log(((n + 1.0d0) / n))
else
tmp = ((1.0d0 - (0.5d0 / n)) / n) + ((((-0.25d0) / (n * n)) / (n * n)) + ((0.3333333333333333d0 / (n * n)) / n))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 1400.0) {
tmp = Math.log(((N + 1.0) / N));
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
def code(N): tmp = 0 if N <= 1400.0: tmp = math.log(((N + 1.0) / N)) else: tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)) return tmp
function code(N) tmp = 0.0 if (N <= 1400.0) tmp = log(Float64(Float64(N + 1.0) / N)); else tmp = Float64(Float64(Float64(1.0 - Float64(0.5 / N)) / N) + Float64(Float64(Float64(-0.25 / Float64(N * N)) / Float64(N * N)) + Float64(Float64(0.3333333333333333 / Float64(N * N)) / N))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 1400.0) tmp = log(((N + 1.0) / N)); else tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 1400.0], N[Log[N[(N[(N + 1.0), $MachinePrecision] / N), $MachinePrecision]], $MachinePrecision], N[(N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision] + N[(N[(N[(-0.25 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N[(N * N), $MachinePrecision]), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 1400:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N} + \left(\frac{\frac{-0.25}{N \cdot N}}{N \cdot N} + \frac{\frac{0.3333333333333333}{N \cdot N}}{N}\right)\\
\end{array}
\end{array}
if N < 1400Initial program 100.0%
diff-log99.2%
Applied egg-rr99.2%
if 1400 < N Initial program 8.8%
Taylor expanded in N around inf 99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
metadata-eval99.9%
pow-prod-up99.9%
pow-prod-down99.9%
pow299.9%
frac-times99.9%
Applied egg-rr99.9%
associate--r+99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
associate-/r*99.9%
sub-div99.9%
div-inv99.9%
pow-flip99.9%
metadata-eval99.9%
*-commutative99.9%
distribute-neg-frac99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-+l+99.9%
associate-*r/99.9%
associate-*l/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
pow-flip99.9%
div-inv99.9%
unpow399.9%
associate-/r*99.9%
Applied egg-rr99.9%
Final simplification99.6%
(FPCore (N)
:precision binary64
(if (<= N 0.85)
(- N (log N))
(+
(/ (- 1.0 (/ 0.5 N)) N)
(+ (/ (/ -0.25 (* N N)) (* N N)) (/ (/ 0.3333333333333333 (* N N)) N)))))
double code(double N) {
double tmp;
if (N <= 0.85) {
tmp = N - log(N);
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 0.85d0) then
tmp = n - log(n)
else
tmp = ((1.0d0 - (0.5d0 / n)) / n) + ((((-0.25d0) / (n * n)) / (n * n)) + ((0.3333333333333333d0 / (n * n)) / n))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 0.85) {
tmp = N - Math.log(N);
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.85: tmp = N - math.log(N) else: tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)) return tmp
function code(N) tmp = 0.0 if (N <= 0.85) tmp = Float64(N - log(N)); else tmp = Float64(Float64(Float64(1.0 - Float64(0.5 / N)) / N) + Float64(Float64(Float64(-0.25 / Float64(N * N)) / Float64(N * N)) + Float64(Float64(0.3333333333333333 / Float64(N * N)) / N))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 0.85) tmp = N - log(N); else tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 0.85], N[(N - N[Log[N], $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision] + N[(N[(N[(-0.25 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N[(N * N), $MachinePrecision]), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.85:\\
\;\;\;\;N - \log N\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N} + \left(\frac{\frac{-0.25}{N \cdot N}}{N \cdot N} + \frac{\frac{0.3333333333333333}{N \cdot N}}{N}\right)\\
\end{array}
\end{array}
if N < 0.849999999999999978Initial program 100.0%
Taylor expanded in N around 0 98.1%
neg-mul-198.1%
unsub-neg98.1%
Simplified98.1%
if 0.849999999999999978 < N Initial program 8.8%
Taylor expanded in N around inf 99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
metadata-eval99.9%
pow-prod-up99.9%
pow-prod-down99.9%
pow299.9%
frac-times99.9%
Applied egg-rr99.9%
associate--r+99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
associate-/r*99.9%
sub-div99.9%
div-inv99.9%
pow-flip99.9%
metadata-eval99.9%
*-commutative99.9%
distribute-neg-frac99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-+l+99.9%
associate-*r/99.9%
associate-*l/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
pow-flip99.9%
div-inv99.9%
unpow399.9%
associate-/r*99.9%
Applied egg-rr99.9%
Final simplification99.0%
(FPCore (N)
:precision binary64
(if (<= N 0.72)
(- (log N))
(+
(/ (- 1.0 (/ 0.5 N)) N)
(+ (/ (/ -0.25 (* N N)) (* N N)) (/ (/ 0.3333333333333333 (* N N)) N)))))
double code(double N) {
double tmp;
if (N <= 0.72) {
tmp = -log(N);
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 0.72d0) then
tmp = -log(n)
else
tmp = ((1.0d0 - (0.5d0 / n)) / n) + ((((-0.25d0) / (n * n)) / (n * n)) + ((0.3333333333333333d0 / (n * n)) / n))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 0.72) {
tmp = -Math.log(N);
} else {
tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N));
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.72: tmp = -math.log(N) else: tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)) return tmp
function code(N) tmp = 0.0 if (N <= 0.72) tmp = Float64(-log(N)); else tmp = Float64(Float64(Float64(1.0 - Float64(0.5 / N)) / N) + Float64(Float64(Float64(-0.25 / Float64(N * N)) / Float64(N * N)) + Float64(Float64(0.3333333333333333 / Float64(N * N)) / N))); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 0.72) tmp = -log(N); else tmp = ((1.0 - (0.5 / N)) / N) + (((-0.25 / (N * N)) / (N * N)) + ((0.3333333333333333 / (N * N)) / N)); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 0.72], (-N[Log[N], $MachinePrecision]), N[(N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision] + N[(N[(N[(-0.25 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N[(N * N), $MachinePrecision]), $MachinePrecision] + N[(N[(0.3333333333333333 / N[(N * N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.72:\\
\;\;\;\;-\log N\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N} + \left(\frac{\frac{-0.25}{N \cdot N}}{N \cdot N} + \frac{\frac{0.3333333333333333}{N \cdot N}}{N}\right)\\
\end{array}
\end{array}
if N < 0.71999999999999997Initial program 100.0%
Taylor expanded in N around 0 96.7%
neg-mul-196.7%
Simplified96.7%
if 0.71999999999999997 < N Initial program 8.8%
Taylor expanded in N around inf 99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
metadata-eval99.9%
pow-prod-up99.9%
pow-prod-down99.9%
pow299.9%
frac-times99.9%
Applied egg-rr99.9%
associate--r+99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
associate-/r*99.9%
sub-div99.9%
div-inv99.9%
pow-flip99.9%
metadata-eval99.9%
*-commutative99.9%
distribute-neg-frac99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-+l+99.9%
associate-*r/99.9%
associate-*l/99.9%
metadata-eval99.9%
Simplified99.9%
metadata-eval99.9%
pow-flip99.9%
div-inv99.9%
unpow399.9%
associate-/r*99.9%
Applied egg-rr99.9%
Final simplification98.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 54.7%
Taylor expanded in N around inf 51.3%
Final simplification51.3%
(FPCore (N) :precision binary64 N)
double code(double N) {
return N;
}
real(8) function code(n)
real(8), intent (in) :: n
code = n
end function
public static double code(double N) {
return N;
}
def code(N): return N
function code(N) return N end
function tmp = code(N) tmp = N; end
code[N_] := N
\begin{array}{l}
\\
N
\end{array}
Initial program 54.7%
Taylor expanded in N around 0 51.3%
neg-mul-151.3%
unsub-neg51.3%
Simplified51.3%
Taylor expanded in N around inf 4.7%
Final simplification4.7%
herbie shell --seed 2023297
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
(- (log (+ N 1.0)) (log N)))