
(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)) 5e-8) (+ (/ 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)) <= 5e-8) {
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)) <= 5d-8) 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)) <= 5e-8) {
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)) <= 5e-8: 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)) <= 5e-8) 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)) <= 5e-8) 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], 5e-8], 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 5 \cdot 10^{-8}:\\
\;\;\;\;\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)) < 4.9999999999999998e-8Initial program 6.3%
+-commutative6.3%
log1p-def6.3%
Simplified6.3%
Taylor expanded in N around inf 100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
if 4.9999999999999998e-8 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.9%
+-commutative99.9%
log1p-def99.9%
Simplified99.9%
add-log-exp99.9%
exp-diff99.9%
log1p-udef99.9%
add-exp-log99.9%
+-commutative99.9%
add-exp-log99.9%
Applied egg-rr99.9%
clear-num99.9%
log-div100.0%
metadata-eval100.0%
Applied egg-rr100.0%
sub0-neg100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (N) :precision binary64 (if (<= (- (log (+ N 1.0)) (log N)) 5e-8) (/ (- 1.0 (/ 0.5 N)) N) (- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 5e-8) {
tmp = (1.0 - (0.5 / N)) / N;
} 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)) <= 5d-8) then
tmp = (1.0d0 - (0.5d0 / n)) / n
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)) <= 5e-8) {
tmp = (1.0 - (0.5 / N)) / N;
} else {
tmp = -Math.log((N / (N + 1.0)));
}
return tmp;
}
def code(N): tmp = 0 if (math.log((N + 1.0)) - math.log(N)) <= 5e-8: tmp = (1.0 - (0.5 / N)) / N 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)) <= 5e-8) tmp = Float64(Float64(1.0 - Float64(0.5 / N)) / N); 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)) <= 5e-8) tmp = (1.0 - (0.5 / N)) / N; 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], 5e-8], N[(N[(1.0 - N[(0.5 / N), $MachinePrecision]), $MachinePrecision] / N), $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 5 \cdot 10^{-8}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\mathbf{else}:\\
\;\;\;\;-\log \left(\frac{N}{N + 1}\right)\\
\end{array}
\end{array}
if (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) < 4.9999999999999998e-8Initial program 6.3%
+-commutative6.3%
log1p-def6.3%
Simplified6.3%
Taylor expanded in N around inf 100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
frac-sub38.6%
unpow238.6%
cube-mult38.5%
div-inv38.5%
*-un-lft-identity38.5%
unpow238.5%
distribute-lft-out--38.5%
pow-flip39.2%
metadata-eval39.2%
Applied egg-rr39.2%
*-commutative39.2%
sub-neg39.2%
metadata-eval39.2%
Simplified39.2%
+-commutative39.2%
fma-def39.2%
div-inv39.2%
*-commutative39.2%
pow-flip39.2%
metadata-eval39.2%
Applied egg-rr39.2%
fma-udef39.2%
distribute-lft-out39.2%
Simplified39.2%
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%
if 4.9999999999999998e-8 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.9%
+-commutative99.9%
log1p-def99.9%
Simplified99.9%
add-log-exp99.9%
exp-diff99.9%
log1p-udef99.9%
add-exp-log99.9%
+-commutative99.9%
add-exp-log99.9%
Applied egg-rr99.9%
clear-num99.9%
log-div100.0%
metadata-eval100.0%
Applied egg-rr100.0%
sub0-neg100.0%
Simplified100.0%
Final simplification100.0%
(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.9%
+-commutative99.9%
log1p-def99.9%
Simplified99.9%
add-log-exp99.9%
exp-diff99.9%
log1p-udef99.9%
add-exp-log99.9%
+-commutative99.9%
add-exp-log99.9%
Applied egg-rr99.9%
if 1.9e5 < N Initial program 6.3%
+-commutative6.3%
log1p-def6.3%
Simplified6.3%
Taylor expanded in N around inf 100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
frac-sub38.6%
unpow238.6%
cube-mult38.5%
div-inv38.5%
*-un-lft-identity38.5%
unpow238.5%
distribute-lft-out--38.5%
pow-flip39.2%
metadata-eval39.2%
Applied egg-rr39.2%
*-commutative39.2%
sub-neg39.2%
metadata-eval39.2%
Simplified39.2%
+-commutative39.2%
fma-def39.2%
div-inv39.2%
*-commutative39.2%
pow-flip39.2%
metadata-eval39.2%
Applied egg-rr39.2%
fma-udef39.2%
distribute-lft-out39.2%
Simplified39.2%
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 simplification100.0%
(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 99.5%
mul-1-neg99.5%
unsub-neg99.5%
Simplified99.5%
if 0.900000000000000022 < N Initial program 7.7%
+-commutative7.7%
log1p-def7.7%
Simplified7.7%
Taylor expanded in N around inf 99.1%
associate--l+99.1%
associate-*r/99.1%
metadata-eval99.1%
associate-*r/99.1%
metadata-eval99.1%
Simplified99.1%
frac-sub38.7%
unpow238.7%
cube-mult38.6%
div-inv38.6%
*-un-lft-identity38.6%
unpow238.6%
distribute-lft-out--38.6%
pow-flip39.3%
metadata-eval39.3%
Applied egg-rr39.3%
*-commutative39.3%
sub-neg39.3%
metadata-eval39.3%
Simplified39.3%
+-commutative39.3%
fma-def39.3%
div-inv39.3%
*-commutative39.3%
pow-flip39.3%
metadata-eval39.3%
Applied egg-rr39.3%
fma-udef39.3%
distribute-lft-out39.3%
Simplified39.3%
Taylor expanded in N around inf 98.9%
associate-*r/98.9%
metadata-eval98.9%
unpow298.9%
associate-/r*98.9%
div-sub98.9%
Simplified98.9%
Final simplification99.2%
(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.8%
mul-1-neg98.8%
Simplified98.8%
if 0.680000000000000049 < N Initial program 7.7%
+-commutative7.7%
log1p-def7.7%
Simplified7.7%
Taylor expanded in N around inf 99.1%
associate--l+99.1%
associate-*r/99.1%
metadata-eval99.1%
associate-*r/99.1%
metadata-eval99.1%
Simplified99.1%
frac-sub38.7%
unpow238.7%
cube-mult38.6%
div-inv38.6%
*-un-lft-identity38.6%
unpow238.6%
distribute-lft-out--38.6%
pow-flip39.3%
metadata-eval39.3%
Applied egg-rr39.3%
*-commutative39.3%
sub-neg39.3%
metadata-eval39.3%
Simplified39.3%
+-commutative39.3%
fma-def39.3%
div-inv39.3%
*-commutative39.3%
pow-flip39.3%
metadata-eval39.3%
Applied egg-rr39.3%
fma-udef39.3%
distribute-lft-out39.3%
Simplified39.3%
Taylor expanded in N around inf 98.9%
associate-*r/98.9%
metadata-eval98.9%
unpow298.9%
associate-/r*98.9%
div-sub98.9%
Simplified98.9%
Final simplification98.9%
(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 53.8%
+-commutative53.8%
log1p-def53.8%
Simplified53.8%
Taylor expanded in N around inf 51.8%
Final simplification51.8%
(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 53.8%
+-commutative53.8%
log1p-def53.8%
Simplified53.8%
Taylor expanded in N around 0 51.7%
mul-1-neg51.7%
unsub-neg51.7%
Simplified51.7%
Taylor expanded in N around inf 4.6%
Final simplification4.6%
herbie shell --seed 2023301
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
(- (log (+ N 1.0)) (log N)))