
(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)
(+
(/ 0.3333333333333333 (pow N 3.0))
(+ (/ (/ (+ N -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)) + ((((N + -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)) + ((((n + (-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)) + ((((N + -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)) + ((((N + -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(0.3333333333333333 / (N ^ 3.0)) + Float64(Float64(Float64(Float64(N + -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)) + ((((N + -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[(0.3333333333333333 / N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(N + -0.5), $MachinePrecision] / N), $MachinePrecision] / N), $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(\frac{\frac{N + -0.5}{N}}{N} + \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 6.3%
+-commutative6.3%
log1p-def6.3%
Simplified6.3%
add-log-exp6.3%
log1p-expm1-u6.3%
log1p-udef6.3%
diff-log5.8%
log1p-udef5.8%
rem-exp-log4.6%
+-commutative4.6%
add-exp-log4.6%
log1p-udef4.6%
log1p-expm1-u4.6%
add-exp-log6.6%
Applied egg-rr6.6%
Taylor expanded in N around inf 99.9%
Simplified52.3%
*-un-lft-identity52.3%
unpow252.3%
times-frac99.9%
Applied egg-rr99.9%
associate-*l/100.0%
*-un-lft-identity100.0%
Applied egg-rr100.0%
if 5.0000000000000001e-4 < (-.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-u8.2%
log1p-udef8.2%
diff-log8.2%
log1p-udef8.2%
rem-exp-log8.3%
+-commutative8.3%
add-exp-log8.3%
log1p-udef8.3%
log1p-expm1-u99.9%
add-exp-log99.9%
Applied egg-rr99.9%
clear-num99.9%
log-rec100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (N) :precision binary64 (if (<= (- (log (+ N 1.0)) (log N)) 0.0) (/ (/ (+ N -0.5) N) N) (- (log (/ N (+ N 1.0))))))
double code(double N) {
double tmp;
if ((log((N + 1.0)) - log(N)) <= 0.0) {
tmp = ((N + -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)) <= 0.0d0) then
tmp = ((n + (-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)) <= 0.0) {
tmp = ((N + -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)) <= 0.0: tmp = ((N + -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)) <= 0.0) tmp = Float64(Float64(Float64(N + -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)) <= 0.0) tmp = ((N + -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], 0.0], N[(N[(N[(N + -0.5), $MachinePrecision] / N), $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 0:\\
\;\;\;\;\frac{\frac{N + -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)) < 0.0Initial program 5.7%
+-commutative5.7%
log1p-def5.7%
Simplified5.7%
add-log-exp5.7%
log1p-expm1-u5.7%
log1p-udef5.7%
diff-log5.2%
log1p-udef5.2%
rem-exp-log4.0%
+-commutative4.0%
add-exp-log4.0%
log1p-udef4.0%
log1p-expm1-u4.0%
add-exp-log6.0%
Applied egg-rr6.0%
Taylor expanded in N around inf 100.0%
*-rgt-identity100.0%
*-rgt-identity100.0%
*-inverses48.3%
associate-/r*35.6%
*-commutative35.6%
*-lft-identity35.6%
*-inverses35.6%
associate-*r/35.6%
metadata-eval35.6%
times-frac35.7%
distribute-lft-neg-out35.7%
distribute-rgt-neg-out35.7%
metadata-eval35.7%
distribute-rgt-neg-in35.7%
distribute-lft-neg-out35.7%
remove-double-neg35.7%
Simplified52.0%
*-un-lft-identity52.0%
unpow252.0%
times-frac100.0%
Applied egg-rr100.0%
associate-*l/100.0%
*-un-lft-identity100.0%
Applied egg-rr100.0%
if 0.0 < (-.f64 (log.f64 (+.f64 N 1)) (log.f64 N)) Initial program 99.7%
+-commutative99.7%
log1p-def99.7%
Simplified99.7%
add-log-exp99.7%
log1p-expm1-u8.8%
log1p-udef8.8%
diff-log8.8%
log1p-udef8.8%
rem-exp-log8.8%
+-commutative8.8%
add-exp-log8.8%
log1p-udef8.8%
log1p-expm1-u99.8%
add-exp-log99.8%
Applied egg-rr99.8%
clear-num99.8%
log-rec99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (N) :precision binary64 (if (<= N 205000.0) (log (/ (+ N 1.0) N)) (/ (/ (+ N -0.5) N) N)))
double code(double N) {
double tmp;
if (N <= 205000.0) {
tmp = log(((N + 1.0) / N));
} else {
tmp = ((N + -0.5) / N) / N;
}
return tmp;
}
real(8) function code(n)
real(8), intent (in) :: n
real(8) :: tmp
if (n <= 205000.0d0) then
tmp = log(((n + 1.0d0) / n))
else
tmp = ((n + (-0.5d0)) / n) / n
end if
code = tmp
end function
public static double code(double N) {
double tmp;
if (N <= 205000.0) {
tmp = Math.log(((N + 1.0) / N));
} else {
tmp = ((N + -0.5) / N) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 205000.0: tmp = math.log(((N + 1.0) / N)) else: tmp = ((N + -0.5) / N) / N return tmp
function code(N) tmp = 0.0 if (N <= 205000.0) tmp = log(Float64(Float64(N + 1.0) / N)); else tmp = Float64(Float64(Float64(N + -0.5) / N) / N); end return tmp end
function tmp_2 = code(N) tmp = 0.0; if (N <= 205000.0) tmp = log(((N + 1.0) / N)); else tmp = ((N + -0.5) / N) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 205000.0], N[Log[N[(N[(N + 1.0), $MachinePrecision] / N), $MachinePrecision]], $MachinePrecision], N[(N[(N[(N + -0.5), $MachinePrecision] / N), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 205000:\\
\;\;\;\;\log \left(\frac{N + 1}{N}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{N + -0.5}{N}}{N}\\
\end{array}
\end{array}
if N < 205000Initial program 99.7%
+-commutative99.7%
log1p-def99.7%
Simplified99.7%
add-log-exp99.7%
log1p-expm1-u8.8%
log1p-udef8.8%
diff-log8.8%
log1p-udef8.8%
rem-exp-log8.8%
+-commutative8.8%
add-exp-log8.8%
log1p-udef8.8%
log1p-expm1-u99.8%
add-exp-log99.8%
Applied egg-rr99.8%
if 205000 < N Initial program 5.7%
+-commutative5.7%
log1p-def5.7%
Simplified5.7%
add-log-exp5.7%
log1p-expm1-u5.7%
log1p-udef5.7%
diff-log5.2%
log1p-udef5.2%
rem-exp-log4.0%
+-commutative4.0%
add-exp-log4.0%
log1p-udef4.0%
log1p-expm1-u4.0%
add-exp-log6.0%
Applied egg-rr6.0%
Taylor expanded in N around inf 100.0%
*-rgt-identity100.0%
*-rgt-identity100.0%
*-inverses48.3%
associate-/r*35.6%
*-commutative35.6%
*-lft-identity35.6%
*-inverses35.6%
associate-*r/35.6%
metadata-eval35.6%
times-frac35.7%
distribute-lft-neg-out35.7%
distribute-rgt-neg-out35.7%
metadata-eval35.7%
distribute-rgt-neg-in35.7%
distribute-lft-neg-out35.7%
remove-double-neg35.7%
Simplified52.0%
*-un-lft-identity52.0%
unpow252.0%
times-frac100.0%
Applied egg-rr100.0%
associate-*l/100.0%
*-un-lft-identity100.0%
Applied egg-rr100.0%
Final simplification99.9%
(FPCore (N) :precision binary64 (if (<= N 0.9) (- N (log N)) (/ (/ (+ N -0.5) N) N)))
double code(double N) {
double tmp;
if (N <= 0.9) {
tmp = N - log(N);
} else {
tmp = ((N + -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 = ((n + (-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 = ((N + -0.5) / N) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.9: tmp = N - math.log(N) else: tmp = ((N + -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(Float64(N + -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 = ((N + -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[(N[(N + -0.5), $MachinePrecision] / N), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.9:\\
\;\;\;\;N - \log N\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{N + -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.7%
neg-mul-198.7%
unsub-neg98.7%
Simplified98.7%
if 0.900000000000000022 < N Initial program 6.9%
+-commutative6.9%
log1p-def6.9%
Simplified6.9%
add-log-exp6.9%
log1p-expm1-u6.9%
log1p-udef6.9%
diff-log6.5%
log1p-udef6.4%
rem-exp-log5.3%
+-commutative5.3%
add-exp-log5.3%
log1p-udef5.3%
log1p-expm1-u5.3%
add-exp-log7.3%
Applied egg-rr7.3%
Taylor expanded in N around inf 99.2%
*-rgt-identity99.2%
*-rgt-identity99.2%
*-inverses48.4%
associate-/r*35.9%
*-commutative35.9%
*-lft-identity35.9%
*-inverses35.9%
associate-*r/35.9%
metadata-eval35.9%
times-frac35.9%
distribute-lft-neg-out35.9%
distribute-rgt-neg-out35.9%
metadata-eval35.9%
distribute-rgt-neg-in35.9%
distribute-lft-neg-out35.9%
remove-double-neg35.9%
Simplified51.9%
*-un-lft-identity52.4%
unpow252.4%
times-frac99.6%
Applied egg-rr99.2%
associate-*l/99.6%
*-un-lft-identity99.6%
Applied egg-rr99.2%
Final simplification98.9%
(FPCore (N) :precision binary64 (if (<= N 0.68) (- (log N)) (/ (/ (+ N -0.5) N) N)))
double code(double N) {
double tmp;
if (N <= 0.68) {
tmp = -log(N);
} else {
tmp = ((N + -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 = ((n + (-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 = ((N + -0.5) / N) / N;
}
return tmp;
}
def code(N): tmp = 0 if N <= 0.68: tmp = -math.log(N) else: tmp = ((N + -0.5) / N) / N return tmp
function code(N) tmp = 0.0 if (N <= 0.68) tmp = Float64(-log(N)); else tmp = Float64(Float64(Float64(N + -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 = ((N + -0.5) / N) / N; end tmp_2 = tmp; end
code[N_] := If[LessEqual[N, 0.68], (-N[Log[N], $MachinePrecision]), N[(N[(N[(N + -0.5), $MachinePrecision] / N), $MachinePrecision] / N), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;N \leq 0.68:\\
\;\;\;\;-\log N\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{N + -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.4%
neg-mul-197.4%
Simplified97.4%
if 0.680000000000000049 < N Initial program 6.9%
+-commutative6.9%
log1p-def6.9%
Simplified6.9%
add-log-exp6.9%
log1p-expm1-u6.9%
log1p-udef6.9%
diff-log6.5%
log1p-udef6.4%
rem-exp-log5.3%
+-commutative5.3%
add-exp-log5.3%
log1p-udef5.3%
log1p-expm1-u5.3%
add-exp-log7.3%
Applied egg-rr7.3%
Taylor expanded in N around inf 99.2%
*-rgt-identity99.2%
*-rgt-identity99.2%
*-inverses48.4%
associate-/r*35.9%
*-commutative35.9%
*-lft-identity35.9%
*-inverses35.9%
associate-*r/35.9%
metadata-eval35.9%
times-frac35.9%
distribute-lft-neg-out35.9%
distribute-rgt-neg-out35.9%
metadata-eval35.9%
distribute-rgt-neg-in35.9%
distribute-lft-neg-out35.9%
remove-double-neg35.9%
Simplified51.9%
*-un-lft-identity52.4%
unpow252.4%
times-frac99.6%
Applied egg-rr99.2%
associate-*l/99.6%
*-un-lft-identity99.6%
Applied egg-rr99.2%
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.9%
+-commutative54.9%
log1p-def54.9%
Simplified54.9%
Taylor expanded in N around inf 50.9%
Final simplification50.9%
(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.9%
+-commutative54.9%
log1p-def54.9%
Simplified54.9%
Taylor expanded in N around 0 52.7%
neg-mul-152.7%
unsub-neg52.7%
Simplified52.7%
Taylor expanded in N around inf 4.7%
Final simplification4.7%
herbie shell --seed 2023322
(FPCore (N)
:name "2log (problem 3.3.6)"
:precision binary64
(- (log (+ N 1.0)) (log N)))