
(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 8 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)
(+
(+ (/ 0.3333333333333333 (pow N 3.0)) (/ (+ 1.0 (/ -0.5 N)) 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.0005) {
tmp = ((0.3333333333333333 / pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / 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.0005d0) then
tmp = ((0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 + ((-0.5d0) / n)) / 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.0005) {
tmp = ((0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / 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.0005: tmp = ((0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / 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.0005) tmp = Float64(Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 + Float64(-0.5 / N)) / 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.0005) tmp = ((0.3333333333333333 / (N ^ 3.0)) + ((1.0 + (-0.5 / N)) / 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.0005], N[(N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 + N[(-0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision] + N[(-0.25 / N[Power[N, 4.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 0.0005:\\
\;\;\;\;\left(\frac{0.3333333333333333}{{N}^{3}} + \frac{1 + \frac{-0.5}{N}}{N}\right) + \frac{-0.25}{{N}^{4}}\\
\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 9.5%
+-commutative9.5%
log1p-def9.5%
Simplified9.5%
Taylor expanded in N around inf 99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
unpow299.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in N around 0 99.9%
sub-neg99.9%
associate-*r/99.9%
metadata-eval99.9%
+-commutative99.9%
associate-*r/99.9%
metadata-eval99.9%
unpow299.9%
distribute-neg-in99.9%
metadata-eval99.9%
associate-*r/99.9%
associate-+r+99.9%
Simplified99.9%
if 5.0000000000000001e-4 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.9%
+-commutative99.9%
log1p-def99.9%
Simplified99.9%
log1p-udef99.9%
diff-log99.9%
+-commutative99.9%
Applied egg-rr99.9%
clear-num99.9%
log-div99.9%
metadata-eval99.9%
Applied egg-rr99.9%
neg-sub099.9%
Simplified99.9%
Final simplification99.9%
(FPCore (N) :precision binary64 (if (<= (- (log (+ N 1.0)) (log N)) 5e-6) (+ (/ 0.3333333333333333 (pow N 3.0)) (/ (+ 1.0 (/ -0.5 N)) N)) (log (/ (+ N 1.0) N))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 5e-6) {
tmp = (0.3333333333333333 / pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / N);
} else {
tmp = log(((N + 1.0) / N));
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if ((log((n + 1.0d0)) - log(n)) <= 5d-6) then
tmp = (0.3333333333333333d0 / (n ** 3.0d0)) + ((1.0d0 + ((-0.5d0) / n)) / n)
else
tmp = log(((n + 1.0d0) / n))
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if ((Math.log((N + 1.0)) - Math.log(N)) <= 5e-6) {
tmp = (0.3333333333333333 / Math.pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / N);
} else {
tmp = Math.log(((N + 1.0) / N));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 5e-6: tmp = (0.3333333333333333 / math.pow(N, 3.0)) + ((1.0 + (-0.5 / N)) / N) else: tmp = math.log(((N + 1.0) / N)) return tmp
function code(N) tmp = 0.0 if (Float64(log(Float64(N + 1.0)) - log(N)) <= 5e-6) tmp = Float64(Float64(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(1.0 + Float64(-0.5 / N)) / N)); else tmp = log(Float64(Float64(N + 1.0) / N)); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if ((log((N + 1.0)) - log(N)) <= 5e-6) tmp = (0.3333333333333333 / (N ^ 3.0)) + ((1.0 + (-0.5 / N)) / N); else tmp = log(((N + 1.0) / N)); end tmp_2 = tmp; end
code[N_] := If[LessEqual[N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision], 5e-6], N[(N[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 + N[(-0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision], N[Log[N[(N[(N + 1.0), $MachinePrecision] / N), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\log \left(N + 1\right) - \log N \leq 5 \cdot 10^{-6}:\\
\;\;\;\;\frac{0.3333333333333333}{{N}^{3}} + \frac{1 + \frac{-0.5}{N}}{N}\\
\mathbf{else}:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 5.00000000000000041e-6Initial program 8.9%
+-commutative8.9%
log1p-def8.9%
Simplified8.9%
Taylor expanded in N around inf 100.0%
associate-*r/100.0%
metadata-eval100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in N around inf 100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-/r*100.0%
div-sub100.0%
sub-neg100.0%
distribute-neg-frac100.0%
metadata-eval100.0%
Simplified100.0%
if 5.00000000000000041e-6 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.7%
+-commutative99.7%
log1p-def99.7%
Simplified99.7%
log1p-udef99.7%
diff-log99.8%
+-commutative99.8%
Applied egg-rr99.8%
Final simplification99.9%
(FPCore (N) :precision binary64 (if (<= N 330000.0) (- (log (/ N (+ N 1.0)))) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 330000.0) {
tmp = -log((N / (N + 1.0)));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 330000.0d0) then
tmp = -log((n / (n + 1.0d0)))
else
tmp = (1.0d0 - (0.5d0 / n)) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 330000.0) {
tmp = -Math.log((N / (N + 1.0)));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 330000.0: tmp = -math.log((N / (N + 1.0))) else: tmp = (1.0 - (0.5 / N)) / N return tmp
function code(N) tmp = 0.0 if (N <= 330000.0) tmp = Float64(-log(Float64(N / Float64(N + 1.0)))); else tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 330000.0) tmp = -log((N / (N + 1.0))); else tmp = (1.0 - (0.5 / N)) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 330000.0], (-N[Log[N[(N / N[(N + 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 330000:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 3.3e5Initial program 99.0%
+-commutative99.0%
log1p-def99.0%
Simplified99.0%
log1p-udef99.0%
diff-log99.1%
+-commutative99.1%
Applied egg-rr99.1%
clear-num99.1%
log-div99.2%
metadata-eval99.2%
Applied egg-rr99.2%
neg-sub099.2%
Simplified99.2%
if 3.3e5 < N Initial program 7.6%
+-commutative7.6%
log1p-def7.6%
Simplified7.6%
Taylor expanded in N around inf 100.0%
associate-*r/100.0%
metadata-eval100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in N around inf 99.8%
associate-*r/99.8%
metadata-eval99.8%
unpow299.8%
associate-/r*99.8%
div-sub99.9%
Simplified99.9%
Final simplification99.6%
(FPCore (N) :precision binary64 (if (<= N 190000.0) (log (/ (+ N 1.0) N)) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 190000.0) {
tmp = log(((N + 1.0) / N));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 190000.0d0) then
tmp = log(((n + 1.0d0) / n))
else
tmp = (1.0d0 - (0.5d0 / n)) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 190000.0) {
tmp = Math.log(((N + 1.0) / N));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 190000.0: tmp = math.log(((N + 1.0) / N)) else: tmp = (1.0 - (0.5 / N)) / N return tmp
function code(N) tmp = 0.0 if (N <= 190000.0) tmp = log(Float64(Float64(N + 1.0) / N)); else tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 190000.0) tmp = log(((N + 1.0) / N)); else tmp = (1.0 - (0.5 / N)) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 190000.0], N[Log[N[(N[(N + 1.0), $MachinePrecision] / N), $MachinePrecision]], $MachinePrecision], N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 190000:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 1.9e5Initial program 99.7%
+-commutative99.7%
log1p-def99.7%
Simplified99.7%
log1p-udef99.7%
diff-log99.8%
+-commutative99.8%
Applied egg-rr99.8%
if 1.9e5 < N Initial program 8.9%
+-commutative8.9%
log1p-def8.9%
Simplified8.9%
Taylor expanded in N around inf 100.0%
associate-*r/100.0%
metadata-eval100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in N around inf 99.4%
associate-*r/99.4%
metadata-eval99.4%
unpow299.4%
associate-/r*99.4%
div-sub99.4%
Simplified99.4%
Final simplification99.6%
(FPCore (N) :precision binary64 (if (<= N 0.9) (- N (log N)) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 0.9) {
tmp = N - log(N);
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 0.9d0) then
tmp = n - log(n)
else
tmp = (1.0d0 - (0.5d0 / n)) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 0.9) {
tmp = N - Math.log(N);
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.9: tmp = N - math.log(N) else: tmp = (1.0 - (0.5 / N)) / N return tmp
function code(N) tmp = 0.0 if (N <= 0.9) tmp = Float64(N - log(N)); else tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 0.9) tmp = N - log(N); else tmp = (1.0 - (0.5 / N)) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 0.9], N[(N - N[Log[N], $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.9:\\
\;\;\;\;N - \log N\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 0.900000000000000022Initial program 100.0%
+-commutative100.0%
log1p-def100.0%
Simplified100.0%
Taylor expanded in N around 0 98.9%
neg-mul-198.9%
unsub-neg98.9%
Simplified98.9%
if 0.900000000000000022 < N Initial program 10.0%
+-commutative10.0%
log1p-def10.0%
Simplified10.0%
Taylor expanded in N around inf 99.8%
associate-*r/99.8%
metadata-eval99.8%
+-commutative99.8%
associate-*r/99.8%
metadata-eval99.8%
unpow299.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in N around inf 98.7%
associate-*r/98.7%
metadata-eval98.7%
unpow298.7%
associate-/r*98.7%
div-sub98.7%
Simplified98.7%
Final simplification98.8%
(FPCore (N) :precision binary64 (if (<= N 0.68) (- (log N)) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 0.68) {
tmp = -log(N);
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 0.68d0) then
tmp = -log(n)
else
tmp = (1.0d0 - (0.5d0 / n)) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 0.68) {
tmp = -Math.log(N);
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.68: tmp = -math.log(N) else: tmp = (1.0 - (0.5 / N)) / N return tmp
function code(N) tmp = 0.0 if (N <= 0.68) tmp = Float64(-log(N)); else tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 0.68) tmp = -log(N); else tmp = (1.0 - (0.5 / N)) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 0.68], (-N[Log[N], $MachinePrecision]), N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.68:\\
\;\;\;\;-\log N\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 0.680000000000000049Initial program 100.0%
+-commutative100.0%
log1p-def100.0%
Simplified100.0%
Taylor expanded in N around 0 98.0%
neg-mul-198.0%
Simplified98.0%
if 0.680000000000000049 < N Initial program 10.0%
+-commutative10.0%
log1p-def10.0%
Simplified10.0%
Taylor expanded in N around inf 99.8%
associate-*r/99.8%
metadata-eval99.8%
+-commutative99.8%
associate-*r/99.8%
metadata-eval99.8%
unpow299.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in N around inf 98.7%
associate-*r/98.7%
metadata-eval98.7%
unpow298.7%
associate-/r*98.7%
div-sub98.7%
Simplified98.7%
Final simplification98.4%
(FPCore (N) :precision binary64 (if (<= N 60000000.0) (/ (/ (/ 1.0 N) N) (+ (/ 1.0 N) (/ 0.5 (* N N)))) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 60000000.0) {
tmp = ((1.0 / N) / N) / ((1.0 / N) + (0.5 / (N * N)));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 60000000.0d0) then
tmp = ((1.0d0 / n) / n) / ((1.0d0 / n) + (0.5d0 / (n * n)))
else
tmp = (1.0d0 - (0.5d0 / n)) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 60000000.0) {
tmp = ((1.0 / N) / N) / ((1.0 / N) + (0.5 / (N * N)));
} else {
tmp = (1.0 - (0.5 / N)) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 60000000.0: tmp = ((1.0 / N) / N) / ((1.0 / N) + (0.5 / (N * N))) else: tmp = (1.0 - (0.5 / N)) / N return tmp
function code(N) tmp = 0.0 if (N <= 60000000.0) tmp = Float64(Float64(Float64(1.0 / N) / N) / Float64(Float64(1.0 / N) + Float64(0.5 / Float64(N * N)))); else tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 60000000.0) tmp = ((1.0 / N) / N) / ((1.0 / N) + (0.5 / (N * N))); else tmp = (1.0 - (0.5 / N)) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 60000000.0], N[(N[(N[(1.0 / N), $MachinePrecision] / N), $MachinePrecision] / N[(N[(1.0 / N), $MachinePrecision] + N[(0.5 / N[(N * N), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 60000000:\\
\;\;\;\;\frac{\frac{\frac{1}{N}}{N}}{\frac{1}{N} + \frac{0.5}{N \cdot N}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 6e7Initial program 98.7%
+-commutative98.7%
log1p-def98.7%
Simplified98.7%
Taylor expanded in N around inf 4.3%
associate-*r/4.3%
metadata-eval4.3%
unpow24.3%
associate-/r*4.3%
Simplified4.3%
flip--4.0%
associate-/r*4.0%
associate-/r*4.0%
associate-/r*4.0%
Applied egg-rr4.0%
difference-of-squares4.0%
associate-/r*4.0%
div-sub4.0%
Simplified4.0%
Taylor expanded in N around inf 10.5%
unpow210.5%
associate-/r*10.5%
Simplified10.5%
if 6e7 < N Initial program 7.2%
+-commutative7.2%
log1p-def7.2%
Simplified7.2%
Taylor expanded in N around inf 100.0%
associate-*r/100.0%
metadata-eval100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in N around inf 100.0%
associate-*r/100.0%
metadata-eval100.0%
unpow2100.0%
associate-/r*100.0%
div-sub100.0%
Simplified100.0%
Final simplification58.7%
(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 49.4%
+-commutative49.4%
log1p-def49.4%
Simplified49.4%
Taylor expanded in N around inf 56.7%
Final simplification56.7%
herbie shell --seed 2023187
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
(- (log (+ N 1.0)) (log N)))