2log (problem 3.3.6)

Percentage Accurate: 23.7% → 99.8%

Time: 5.6s

Alternatives: 9

Speedup: 9.4×

Specification

\[N > 1 \land N < 10^{+40}\]

Math

\[\begin{array}{l} \\ \log \left(N + 1\right) - \log N \end{array} \]

FPCore

(FPCore (N) :precision binary64 (- (log (+ N 1.0)) (log N)))

C

double code(double N) {
	return log((N + 1.0)) - log(N);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = log((n + 1.0d0)) - log(n)
end function

Java

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

Python

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

Julia

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

MATLAB

function tmp = code(N)
	tmp = log((N + 1.0)) - log(N);
end

Wolfram

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

Initial Program: 23.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \log \left(N + 1\right) - \log N \end{array} \]

FPCore

(FPCore (N) :precision binary64 (- (log (+ N 1.0)) (log N)))

C

double code(double N) {
	return log((N + 1.0)) - log(N);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = log((n + 1.0d0)) - log(n)
end function

Java

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

Python

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

Julia

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

MATLAB

function tmp = code(N)
	tmp = log((N + 1.0)) - log(N);
end

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \mathsf{log1p}\left({N}^{-1}\right) \end{array} \]

FPCore

(FPCore (N) :precision binary64 (log1p (pow N -1.0)))

C

double code(double N) {
	return log1p(pow(N, -1.0));
}

Java

public static double code(double N) {
	return Math.log1p(Math.pow(N, -1.0));
}

Python

def code(N):
	return math.log1p(math.pow(N, -1.0))

Julia

function code(N)
	return log1p((N ^ -1.0))
end

Wolfram

code[N_] := N[Log[1 + N[Power[N, -1.0], $MachinePrecision]], $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift--.f64 N/A

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

   2. lift-log.f64 N/A

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

   3. lift-log.f64 N/A

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

   4. diff-log N/A

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

   5. lift-+.f64 N/A

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

   6. div-add N/A

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

   7. *-inverses N/A

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

   8. lower-log1p.f64 N/A

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

   9. inv-pow N/A

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

   10. lower-pow.f64 99.8

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

4. Applied rewrites 99.8%

   \[\leadsto \color{blue}{\mathsf{log1p}\left({N}^{-1}\right)} \]
5. Step-by-step derivation

   1. lift-pow.f64 N/A

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

   2. inv-pow N/A

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

   3. lift-/.f64 99.8

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

6. Applied rewrites 99.8%

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

7. Final simplification 99.8%

   \[\leadsto \mathsf{log1p}\left({N}^{-1}\right) \]
8. Add Preprocessing

Alternative 2: 84.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ {N}^{-1} \end{array} \]

FPCore

(FPCore (N) :precision binary64 (pow N -1.0))

C

double code(double N) {
	return pow(N, -1.0);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = n ** (-1.0d0)
end function

Java

public static double code(double N) {
	return Math.pow(N, -1.0);
}

Python

def code(N):
	return math.pow(N, -1.0)

Julia

function code(N)
	return N ^ -1.0
end

MATLAB

function tmp = code(N)
	tmp = N ^ -1.0;
end

Wolfram

code[N_] := N[Power[N, -1.0], $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{1}{N}} \]
4. Step-by-step derivation

   1. lower-/.f64 84.3

      \[\leadsto \color{blue}{\frac{1}{N}} \]

5. Applied rewrites 84.3%

   \[\leadsto \color{blue}{\frac{1}{N}} \]

6. Final simplification 84.3%

   \[\leadsto {N}^{-1} \]
7. Add Preprocessing

Alternative 3: 96.4% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{\frac{\frac{-0.25}{N} + 0.3333333333333333}{N} - 0.5}{N} - -1}{N} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (/ (- (/ (- (/ (+ (/ -0.25 N) 0.3333333333333333) N) 0.5) N) -1.0) N))

C

double code(double N) {
	return ((((((-0.25 / N) + 0.3333333333333333) / N) - 0.5) / N) - -1.0) / N;
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = (((((((-0.25d0) / n) + 0.3333333333333333d0) / n) - 0.5d0) / n) - (-1.0d0)) / n
end function

Java

public static double code(double N) {
	return ((((((-0.25 / N) + 0.3333333333333333) / N) - 0.5) / N) - -1.0) / N;
}

Python

def code(N):
	return ((((((-0.25 / N) + 0.3333333333333333) / N) - 0.5) / N) - -1.0) / N

Julia

function code(N)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(-0.25 / N) + 0.3333333333333333) / N) - 0.5) / N) - -1.0) / N)
end

MATLAB

function tmp = code(N)
	tmp = ((((((-0.25 / N) + 0.3333333333333333) / N) - 0.5) / N) - -1.0) / N;
end

Wolfram

code[N_] := N[(N[(N[(N[(N[(N[(N[(-0.25 / N), $MachinePrecision] + 0.3333333333333333), $MachinePrecision] / N), $MachinePrecision] - 0.5), $MachinePrecision] / N), $MachinePrecision] - -1.0), $MachinePrecision] / N), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \left(\frac{1}{2} \cdot \frac{1}{N} + \frac{1}{4} \cdot \frac{1}{{N}^{3}}\right)}{N}} \]

5. Applied rewrites 95.8%

   \[\leadsto \color{blue}{\frac{\frac{\frac{\frac{-0.25}{N} + 0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]
6. Add Preprocessing

Alternative 4: 96.3% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{\frac{-0.25}{N} + \mathsf{fma}\left(N - 0.5, N, 0.3333333333333333\right)}{N \cdot N}}{N} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (/ (/ (+ (/ -0.25 N) (fma (- N 0.5) N 0.3333333333333333)) (* N N)) N))

C

double code(double N) {
	return (((-0.25 / N) + fma((N - 0.5), N, 0.3333333333333333)) / (N * N)) / N;
}

Julia

function code(N)
	return Float64(Float64(Float64(Float64(-0.25 / N) + fma(Float64(N - 0.5), N, 0.3333333333333333)) / Float64(N * N)) / N)
end

Wolfram

code[N_] := N[(N[(N[(N[(-0.25 / N), $MachinePrecision] + N[(N[(N - 0.5), $MachinePrecision] * N + 0.3333333333333333), $MachinePrecision]), $MachinePrecision] / N[(N * N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift--.f64 N/A

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

   2. lift-log.f64 N/A

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

   3. lift-log.f64 N/A

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

   4. diff-log N/A

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

   5. lift-+.f64 N/A

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

   6. div-add N/A

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

   7. *-inverses N/A

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

   8. lower-log1p.f64 N/A

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

   9. inv-pow N/A

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

   10. lower-pow.f64 99.8

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

4. Applied rewrites 99.8%

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

5. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \left(\frac{1}{2} \cdot \frac{1}{N} + \frac{1}{4} \cdot \frac{1}{{N}^{3}}\right)}{N}} \]
6. Step-by-step derivation

   1. lower-/.f64 N/A

      \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \left(\frac{1}{2} \cdot \frac{1}{N} + \frac{1}{4} \cdot \frac{1}{{N}^{3}}\right)}{N}} \]

7. Applied rewrites 95.7%

   \[\leadsto \color{blue}{\frac{\frac{\frac{-0.25}{N} + \mathsf{fma}\left(N - 0.5, N, 0.3333333333333333\right)}{N \cdot N}}{N}} \]
8. Add Preprocessing

Alternative 5: 96.1% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \frac{\left(0.5 - \frac{0.3333333333333333 - \frac{0.25}{N}}{N}\right) - N}{\left(-N\right) \cdot N} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (/ (- (- 0.5 (/ (- 0.3333333333333333 (/ 0.25 N)) N)) N) (* (- N) N)))

C

double code(double N) {
	return ((0.5 - ((0.3333333333333333 - (0.25 / N)) / N)) - N) / (-N * N);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = ((0.5d0 - ((0.3333333333333333d0 - (0.25d0 / n)) / n)) - n) / (-n * n)
end function

Java

public static double code(double N) {
	return ((0.5 - ((0.3333333333333333 - (0.25 / N)) / N)) - N) / (-N * N);
}

Python

def code(N):
	return ((0.5 - ((0.3333333333333333 - (0.25 / N)) / N)) - N) / (-N * N)

Julia

function code(N)
	return Float64(Float64(Float64(0.5 - Float64(Float64(0.3333333333333333 - Float64(0.25 / N)) / N)) - N) / Float64(Float64(-N) * N))
end

MATLAB

function tmp = code(N)
	tmp = ((0.5 - ((0.3333333333333333 - (0.25 / N)) / N)) - N) / (-N * N);
end

Wolfram

code[N_] := N[(N[(N[(0.5 - N[(N[(0.3333333333333333 - N[(0.25 / N), $MachinePrecision]), $MachinePrecision] / N), $MachinePrecision]), $MachinePrecision] - N), $MachinePrecision] / N[((-N) * N), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \left(\frac{1}{2} \cdot \frac{1}{N} + \frac{1}{4} \cdot \frac{1}{{N}^{3}}\right)}{N}} \]

5. Applied rewrites 95.8%

   \[\leadsto \color{blue}{\frac{\frac{\frac{\frac{-0.25}{N} + 0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]
6. Step-by-step derivation

7. Applied rewrites 95.5%

   \[\leadsto \frac{\frac{\frac{\frac{-0.25}{N} + 0.3333333333333333}{N} - 0.5}{N} \cdot \left(-N\right) - N}{\color{blue}{N \cdot \left(-N\right)}} \]

8. Taylor expanded in N around 0

   \[\leadsto \frac{\frac{\frac{1}{4} + N \cdot \left(\frac{1}{2} \cdot N - \frac{1}{3}\right)}{{N}^{2}} - N}{N \cdot \left(-N\right)} \]
9. Step-by-step derivation

10. Applied rewrites 95.5%

    \[\leadsto \frac{\left(0.5 - \frac{0.3333333333333333 - \frac{0.25}{N}}{N}\right) - N}{N \cdot \left(-N\right)} \]

11. Final simplification 95.5%

    \[\leadsto \frac{\left(0.5 - \frac{0.3333333333333333 - \frac{0.25}{N}}{N}\right) - N}{\left(-N\right) \cdot N} \]
12. Add Preprocessing

Alternative 6: 95.0% accurate, 5.2× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} - -1}{N} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (/ (- (/ (- (/ 0.3333333333333333 N) 0.5) N) -1.0) N))

C

double code(double N) {
	return ((((0.3333333333333333 / N) - 0.5) / N) - -1.0) / N;
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = ((((0.3333333333333333d0 / n) - 0.5d0) / n) - (-1.0d0)) / n
end function

Java

public static double code(double N) {
	return ((((0.3333333333333333 / N) - 0.5) / N) - -1.0) / N;
}

Python

def code(N):
	return ((((0.3333333333333333 / N) - 0.5) / N) - -1.0) / N

Julia

function code(N)
	return Float64(Float64(Float64(Float64(Float64(0.3333333333333333 / N) - 0.5) / N) - -1.0) / N)
end

MATLAB

function tmp = code(N)
	tmp = ((((0.3333333333333333 / N) - 0.5) / N) - -1.0) / N;
end

Wolfram

code[N_] := N[(N[(N[(N[(N[(0.3333333333333333 / N), $MachinePrecision] - 0.5), $MachinePrecision] / N), $MachinePrecision] - -1.0), $MachinePrecision] / N), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \frac{1}{2} \cdot \frac{1}{N}}{N}} \]

5. Applied rewrites 94.5%

   \[\leadsto \color{blue}{\frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]
6. Add Preprocessing

Alternative 7: 94.8% accurate, 5.8× speedup

Math

\[\begin{array}{l} \\ \frac{\left(0.5 - \frac{0.3333333333333333}{N}\right) - N}{\left(-N\right) \cdot N} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (/ (- (- 0.5 (/ 0.3333333333333333 N)) N) (* (- N) N)))

C

double code(double N) {
	return ((0.5 - (0.3333333333333333 / N)) - N) / (-N * N);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = ((0.5d0 - (0.3333333333333333d0 / n)) - n) / (-n * n)
end function

Java

public static double code(double N) {
	return ((0.5 - (0.3333333333333333 / N)) - N) / (-N * N);
}

Python

def code(N):
	return ((0.5 - (0.3333333333333333 / N)) - N) / (-N * N)

Julia

function code(N)
	return Float64(Float64(Float64(0.5 - Float64(0.3333333333333333 / N)) - N) / Float64(Float64(-N) * N))
end

MATLAB

function tmp = code(N)
	tmp = ((0.5 - (0.3333333333333333 / N)) - N) / (-N * N);
end

Wolfram

code[N_] := N[(N[(N[(0.5 - N[(0.3333333333333333 / N), $MachinePrecision]), $MachinePrecision] - N), $MachinePrecision] / N[((-N) * N), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \frac{1}{2} \cdot \frac{1}{N}}{N}} \]

5. Applied rewrites 94.5%

   \[\leadsto \color{blue}{\frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]
6. Step-by-step derivation

7. Applied rewrites 94.2%

   \[\leadsto \frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} \cdot \left(-N\right) - N}{\color{blue}{N \cdot \left(-N\right)}} \]

8. Taylor expanded in N around 0

   \[\leadsto \frac{\frac{\frac{1}{2} \cdot N - \frac{1}{3}}{N} - N}{N \cdot \left(-N\right)} \]
9. Step-by-step derivation

10. Applied rewrites 94.2%

    \[\leadsto \frac{\left(0.5 - \frac{0.3333333333333333}{N}\right) - N}{N \cdot \left(-N\right)} \]

11. Final simplification 94.2%

    \[\leadsto \frac{\left(0.5 - \frac{0.3333333333333333}{N}\right) - N}{\left(-N\right) \cdot N} \]
12. Add Preprocessing

Alternative 8: 92.4% accurate, 8.0× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{N - 0.5}{N}}{N} \end{array} \]

FPCore

(FPCore (N) :precision binary64 (/ (/ (- N 0.5) N) N))

C

double code(double N) {
	return ((N - 0.5) / N) / N;
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = ((n - 0.5d0) / n) / n
end function

Java

public static double code(double N) {
	return ((N - 0.5) / N) / N;
}

Python

def code(N):
	return ((N - 0.5) / N) / N

Julia

function code(N)
	return Float64(Float64(Float64(N - 0.5) / N) / N)
end

MATLAB

function tmp = code(N)
	tmp = ((N - 0.5) / N) / N;
end

Wolfram

code[N_] := N[(N[(N[(N - 0.5), $MachinePrecision] / N), $MachinePrecision] / N), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \frac{1}{2} \cdot \frac{1}{N}}{N}} \]

5. Applied rewrites 94.5%

   \[\leadsto \color{blue}{\frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]

6. Taylor expanded in N around inf

   \[\leadsto \frac{1 - \frac{1}{2} \cdot \frac{1}{N}}{N} \]
7. Step-by-step derivation

8. Applied rewrites 92.1%

   \[\leadsto \frac{\frac{N - 0.5}{N}}{N} \]
9. Add Preprocessing

Alternative 9: 92.1% accurate, 9.4× speedup

Math

\[\begin{array}{l} \\ \frac{0.5 - N}{\left(-N\right) \cdot N} \end{array} \]

FPCore

(FPCore (N) :precision binary64 (/ (- 0.5 N) (* (- N) N)))

C

double code(double N) {
	return (0.5 - N) / (-N * N);
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = (0.5d0 - n) / (-n * n)
end function

Java

public static double code(double N) {
	return (0.5 - N) / (-N * N);
}

Python

def code(N):
	return (0.5 - N) / (-N * N)

Julia

function code(N)
	return Float64(Float64(0.5 - N) / Float64(Float64(-N) * N))
end

MATLAB

function tmp = code(N)
	tmp = (0.5 - N) / (-N * N);
end

Wolfram

code[N_] := N[(N[(0.5 - N), $MachinePrecision] / N[((-N) * N), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 23.9%

   \[\log \left(N + 1\right) - \log N \]
2. Add Preprocessing

3. Taylor expanded in N around inf

   \[\leadsto \color{blue}{\frac{\left(1 + \frac{\frac{1}{3}}{{N}^{2}}\right) - \frac{1}{2} \cdot \frac{1}{N}}{N}} \]

5. Applied rewrites 94.5%

   \[\leadsto \color{blue}{\frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} - -1}{N}} \]
6. Step-by-step derivation

7. Applied rewrites 94.2%

   \[\leadsto \frac{\frac{\frac{0.3333333333333333}{N} - 0.5}{N} \cdot \left(-N\right) - N}{\color{blue}{N \cdot \left(-N\right)}} \]

8. Taylor expanded in N around inf

   \[\leadsto \frac{\frac{1}{2} - N}{N \cdot \left(-N\right)} \]
9. Step-by-step derivation

10. Applied rewrites 91.8%

    \[\leadsto \frac{0.5 - N}{N \cdot \left(-N\right)} \]

11. Final simplification 91.8%

    \[\leadsto \frac{0.5 - N}{\left(-N\right) \cdot N} \]
12. Add Preprocessing

Developer Target 1: 96.3% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \left(\left(\frac{1}{N} + \frac{-1}{2 \cdot {N}^{2}}\right) + \frac{1}{3 \cdot {N}^{3}}\right) + \frac{-1}{4 \cdot {N}^{4}} \end{array} \]

FPCore

(FPCore (N)
 :precision binary64
 (+
  (+ (+ (/ 1.0 N) (/ -1.0 (* 2.0 (pow N 2.0)))) (/ 1.0 (* 3.0 (pow N 3.0))))
  (/ -1.0 (* 4.0 (pow N 4.0)))))

C

double code(double N) {
	return (((1.0 / N) + (-1.0 / (2.0 * pow(N, 2.0)))) + (1.0 / (3.0 * pow(N, 3.0)))) + (-1.0 / (4.0 * pow(N, 4.0)));
}

Fortran

real(8) function code(n)
    real(8), intent (in) :: n
    code = (((1.0d0 / n) + ((-1.0d0) / (2.0d0 * (n ** 2.0d0)))) + (1.0d0 / (3.0d0 * (n ** 3.0d0)))) + ((-1.0d0) / (4.0d0 * (n ** 4.0d0)))
end function

Java

public static double code(double N) {
	return (((1.0 / N) + (-1.0 / (2.0 * Math.pow(N, 2.0)))) + (1.0 / (3.0 * Math.pow(N, 3.0)))) + (-1.0 / (4.0 * Math.pow(N, 4.0)));
}

Python

def code(N):
	return (((1.0 / N) + (-1.0 / (2.0 * math.pow(N, 2.0)))) + (1.0 / (3.0 * math.pow(N, 3.0)))) + (-1.0 / (4.0 * math.pow(N, 4.0)))

Julia

function code(N)
	return Float64(Float64(Float64(Float64(1.0 / N) + Float64(-1.0 / Float64(2.0 * (N ^ 2.0)))) + Float64(1.0 / Float64(3.0 * (N ^ 3.0)))) + Float64(-1.0 / Float64(4.0 * (N ^ 4.0))))
end

MATLAB

function tmp = code(N)
	tmp = (((1.0 / N) + (-1.0 / (2.0 * (N ^ 2.0)))) + (1.0 / (3.0 * (N ^ 3.0)))) + (-1.0 / (4.0 * (N ^ 4.0)));
end

Wolfram

code[N_] := N[(N[(N[(N[(1.0 / N), $MachinePrecision] + N[(-1.0 / N[(2.0 * N[Power[N, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(3.0 * N[Power[N, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / N[(4.0 * N[Power[N, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024340 
(FPCore (N)
  :name "2log (problem 3.3.6)"
  :precision binary64
  :pre (and (> N 1.0) (< N 1e+40))

  :alt
  (! :herbie-platform default (+ (/ 1 N) (/ -1 (* 2 (pow N 2))) (/ 1 (* 3 (pow N 3))) (/ -1 (* 4 (pow N 4)))))

  (- (log (+ N 1.0)) (log N)))