Average Error: 29.0 → 0.0
Time: 6.4s
Precision: binary64
Cost: 6592
\[\log \left(N + 1\right) - \log N \]
↓
\[\mathsf{log1p}\left(\frac{1}{N}\right) \]
(FPCore (N) :precision binary64 (- (log (+ N 1.0)) (log N)))
↓
(FPCore (N) :precision binary64 (log1p (/ 1.0 N)))
double code(double N) {
	return log((N + 1.0)) - log(N);
}
↓
double code(double N) {
	return log1p((1.0 / N));
}

public static double code(double N) {
	return Math.log((N + 1.0)) - Math.log(N);
}
↓
public static double code(double N) {
	return Math.log1p((1.0 / N));
}

def code(N):
	return math.log((N + 1.0)) - math.log(N)
↓
def code(N):
	return math.log1p((1.0 / N))

function code(N)
	return Float64(log(Float64(N + 1.0)) - log(N))
end
↓
function code(N)
	return log1p(Float64(1.0 / N))
end

code[N_] := N[(N[Log[N[(N + 1.0), $MachinePrecision]], $MachinePrecision] - N[Log[N], $MachinePrecision]), $MachinePrecision]
↓
code[N_] := N[Log[1 + N[(1.0 / N), $MachinePrecision]], $MachinePrecision]

\log \left(N + 1\right) - \log N
↓
\mathsf{log1p}\left(\frac{1}{N}\right)

Error

Try it out

Your Program's Arguments

Results

Enter valid numbers for all inputs

Derivation

  1. Initial program 29.0

    \[\log \left(N + 1\right) - \log N \]

  2. Simplified29.0

    \[\leadsto \color{blue}{\mathsf{log1p}\left(N\right) - \log N} \]
    Proof
    (-.f64 (log1p.f64 N) (log.f64 N)): 0 points increase in error, 0 points decrease in error
    (-.f64 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 N))) (log.f64 N)): 3 points increase in error, 0 points decrease in error
    (-.f64 (log.f64 (Rewrite<= +-commutative_binary64 (+.f64 N 1))) (log.f64 N)): 0 points increase in error, 3 points decrease in error

  3. Applied egg-rr28.9

    \[\leadsto \color{blue}{\log \left(\frac{N + 1}{N}\right)} \]

  4. Applied egg-rr28.9

    \[\leadsto \color{blue}{\mathsf{log1p}\left(\frac{N + 1}{N} - 1\right)} \]

  5. Simplified0.0

    \[\leadsto \color{blue}{\mathsf{log1p}\left(\frac{1}{N} + 0\right)} \]
    Proof
    (log1p.f64 (+.f64 (/.f64 1 N) 0)): 0 points increase in error, 0 points decrease in error
    (log1p.f64 (+.f64 (/.f64 1 N) (Rewrite<= metadata-eval (-.f64 1 1)))): 5 points increase in error, 3 points decrease in error
    (log1p.f64 (Rewrite<= associate--l+_binary64 (-.f64 (+.f64 (/.f64 1 N) 1) 1))): 0 points increase in error, 8 points decrease in error
    (log1p.f64 (-.f64 (+.f64 (Rewrite<= *-lft-identity_binary64 (*.f64 1 (/.f64 1 N))) 1) 1)): 0 points increase in error, 8 points decrease in error
    (log1p.f64 (-.f64 (+.f64 (*.f64 1 (/.f64 1 N)) (Rewrite<= rgt-mult-inverse_binary64 (*.f64 N (/.f64 1 N)))) 1)): 0 points increase in error, 0 points decrease in error
    (log1p.f64 (-.f64 (Rewrite<= distribute-rgt-in_binary64 (*.f64 (/.f64 1 N) (+.f64 1 N))) 1)): 0 points increase in error, 0 points decrease in error
    (log1p.f64 (-.f64 (*.f64 (/.f64 1 N) (Rewrite<= +-commutative_binary64 (+.f64 N 1))) 1)): 0 points increase in error, 0 points decrease in error
    (log1p.f64 (-.f64 (Rewrite=> associate-*l/_binary64 (/.f64 (*.f64 1 (+.f64 N 1)) N)) 1)): 8 points increase in error, 0 points decrease in error
    (log1p.f64 (-.f64 (Rewrite<= associate-*r/_binary64 (*.f64 1 (/.f64 (+.f64 N 1) N))) 1)): 0 points increase in error, 8 points decrease in error
    (log1p.f64 (-.f64 (Rewrite=> *-lft-identity_binary64 (/.f64 (+.f64 N 1) N)) 1)): 8 points increase in error, 0 points decrease in error

  6. Applied egg-rr28.9

    \[\leadsto \color{blue}{\left(1 + \mathsf{log1p}\left(\frac{1}{N}\right)\right) - 1} \]

  7. Simplified0.0

    \[\leadsto \color{blue}{\mathsf{log1p}\left(\frac{1}{N}\right)} \]
    Proof
    (log1p.f64 (/.f64 1 N)): 0 points increase in error, 0 points decrease in error
    (Rewrite<= +-rgt-identity_binary64 (+.f64 (log1p.f64 (/.f64 1 N)) 0)): 2 points increase in error, 0 points decrease in error
    (+.f64 (log1p.f64 (/.f64 1 N)) (Rewrite<= metadata-eval (-.f64 1 1))): 0 points increase in error, 2 points decrease in error
    (Rewrite<= associate--l+_binary64 (-.f64 (+.f64 (log1p.f64 (/.f64 1 N)) 1) 1)): 0 points increase in error, 2 points decrease in error
    (-.f64 (Rewrite<= +-commutative_binary64 (+.f64 1 (log1p.f64 (/.f64 1 N)))) 1): 0 points increase in error, 0 points decrease in error

  8. Final simplification0.0

    \[\leadsto \mathsf{log1p}\left(\frac{1}{N}\right) \]

Alternatives

Alternative 1
Error0.7
Cost6660
\[\begin{array}{l} \mathbf{if}\;N \leq 0.6:\\ \;\;\;\;-\log N\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{N} + \frac{\frac{0.3333333333333333}{N} + -0.5}{N \cdot N}\\ \end{array} \]
Alternative 2
Error31.3
Cost192
\[\frac{1}{N} \]
Alternative 3
Error61.1
Cost64
\[N \]

Error

Reproduce

herbie shell --seed 2022343 
(FPCore (N)
  :name "2log (problem 3.3.6)"
  :precision binary64
  (- (log (+ N 1.0)) (log N)))