
(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 6 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)) 1e-5) (+ (/ 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)) <= 1e-5) {
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)) <= 1d-5) 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)) <= 1e-5) {
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)) <= 1e-5: 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)) <= 1e-5) 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)) <= 1e-5) 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], 1e-5], 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 10^{-5}:\\
\;\;\;\;\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)) < 1.00000000000000008e-5Initial program 7.3%
+-commutative7.3%
log1p-def7.3%
Simplified7.3%
add-log-exp7.3%
log1p-expm1-u7.3%
log1p-udef7.3%
diff-log7.2%
log1p-udef7.2%
rem-exp-log5.3%
+-commutative5.3%
add-exp-log5.3%
log1p-udef5.3%
log1p-expm1-u5.3%
add-exp-log7.7%
Applied egg-rr7.7%
Taylor expanded in N around inf 100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
*-lft-identity100.0%
*-lft-identity100.0%
*-inverses46.2%
associate-/r*28.8%
*-commutative28.8%
*-lft-identity28.8%
*-inverses28.8%
associate-*r/28.8%
metadata-eval28.8%
times-frac28.9%
*-commutative28.9%
*-commutative28.9%
distribute-lft-neg-out28.9%
distribute-rgt-neg-in28.9%
metadata-eval28.9%
distribute-lft-neg-out28.9%
distribute-rgt-neg-out28.9%
Simplified50.0%
Taylor expanded in N around 0 100.0%
+-commutative100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
sub-neg100.0%
*-rgt-identity100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
unpow2100.0%
associate-/r*100.0%
*-rgt-identity100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r*100.0%
distribute-lft-in100.0%
lft-mult-inverse99.7%
distribute-lft-in99.7%
associate-*l/100.0%
Simplified100.0%
if 1.00000000000000008e-5 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.9%
+-commutative99.9%
log1p-def99.9%
Simplified99.9%
add-log-exp99.9%
log1p-expm1-u7.9%
log1p-udef7.9%
diff-log7.9%
log1p-udef7.9%
rem-exp-log7.9%
+-commutative7.9%
add-exp-log7.9%
log1p-udef7.9%
log1p-expm1-u99.9%
add-exp-log99.9%
Applied egg-rr99.9%
Final simplification100.0%
(FPCore (N) :precision binary64 (if (<= N 240000.0) (log (/ (+ N 1.0) N)) (/ (- 1.0 (/ 0.5 N)) N)))
double code(double N) {
double tmp;
if (N <= 240000.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 <= 240000.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 <= 240000.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 <= 240000.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 <= 240000.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 <= 240000.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, 240000.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 240000:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 2.4e5Initial program 99.6%
+-commutative99.6%
log1p-def99.6%
Simplified99.6%
add-log-exp99.6%
log1p-expm1-u8.4%
log1p-udef8.4%
diff-log8.4%
log1p-udef8.4%
rem-exp-log8.4%
+-commutative8.4%
add-exp-log8.4%
log1p-udef8.4%
log1p-expm1-u99.6%
add-exp-log99.8%
Applied egg-rr99.8%
if 2.4e5 < N Initial program 6.8%
+-commutative6.8%
log1p-def6.8%
Simplified6.8%
Taylor expanded in N around inf 99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
frac-sub28.4%
unpow228.4%
cube-unmult28.4%
div-inv28.4%
*-un-lft-identity28.4%
unpow228.4%
distribute-lft-out--28.4%
metadata-eval28.4%
cube-div28.9%
inv-pow28.9%
pow-pow29.0%
metadata-eval29.0%
Applied egg-rr29.0%
*-commutative29.0%
associate-*r*32.9%
pow-plus50.7%
metadata-eval50.7%
sub-neg50.7%
metadata-eval50.7%
Simplified50.7%
Taylor expanded in N around 0 99.9%
sub-neg99.9%
*-rgt-identity99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
unpow299.9%
associate-/r*99.9%
*-rgt-identity99.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r*99.9%
distribute-lft-in100.0%
lft-mult-inverse99.7%
distribute-lft-in99.7%
associate-*l/100.0%
Simplified100.0%
Final simplification99.9%
(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.0%
neg-mul-199.0%
unsub-neg99.0%
Simplified99.0%
if 0.900000000000000022 < N Initial program 7.9%
+-commutative7.9%
log1p-def7.9%
Simplified7.9%
Taylor expanded in N around inf 99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
frac-sub28.9%
unpow228.9%
cube-unmult28.8%
div-inv28.8%
*-un-lft-identity28.8%
unpow228.8%
distribute-lft-out--28.8%
metadata-eval28.8%
cube-div29.4%
inv-pow29.4%
pow-pow29.5%
metadata-eval29.5%
Applied egg-rr29.5%
*-commutative29.5%
associate-*r*33.3%
pow-plus50.9%
metadata-eval50.9%
sub-neg50.9%
metadata-eval50.9%
Simplified50.9%
Taylor expanded in N around 0 99.4%
sub-neg99.4%
*-rgt-identity99.4%
*-commutative99.4%
distribute-rgt-neg-in99.4%
unpow299.4%
associate-/r*99.4%
*-rgt-identity99.4%
associate-*r/99.4%
metadata-eval99.4%
associate-*r*99.4%
distribute-lft-in99.4%
lft-mult-inverse99.1%
distribute-lft-in99.1%
associate-*l/99.4%
Simplified99.4%
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 97.7%
neg-mul-197.7%
Simplified97.7%
if 0.680000000000000049 < N Initial program 7.9%
+-commutative7.9%
log1p-def7.9%
Simplified7.9%
Taylor expanded in N around inf 99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
frac-sub28.9%
unpow228.9%
cube-unmult28.8%
div-inv28.8%
*-un-lft-identity28.8%
unpow228.8%
distribute-lft-out--28.8%
metadata-eval28.8%
cube-div29.4%
inv-pow29.4%
pow-pow29.5%
metadata-eval29.5%
Applied egg-rr29.5%
*-commutative29.5%
associate-*r*33.3%
pow-plus50.9%
metadata-eval50.9%
sub-neg50.9%
metadata-eval50.9%
Simplified50.9%
Taylor expanded in N around 0 99.4%
sub-neg99.4%
*-rgt-identity99.4%
*-commutative99.4%
distribute-rgt-neg-in99.4%
unpow299.4%
associate-/r*99.4%
*-rgt-identity99.4%
associate-*r/99.4%
metadata-eval99.4%
associate-*r*99.4%
distribute-lft-in99.4%
lft-mult-inverse99.1%
distribute-lft-in99.1%
associate-*l/99.4%
Simplified99.4%
Final simplification98.6%
(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 51.4%
+-commutative51.4%
log1p-def51.4%
Simplified51.4%
Taylor expanded in N around inf 54.5%
Final simplification54.5%
(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 51.4%
+-commutative51.4%
log1p-def51.4%
Simplified51.4%
Taylor expanded in N around 0 48.7%
neg-mul-148.7%
unsub-neg48.7%
Simplified48.7%
Taylor expanded in N around inf 4.4%
Final simplification4.4%
herbie shell --seed 2023300
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
(- (log (+ N 1.0)) (log N)))