neg log

Percentage Accurate: 100.0% → 100.0%

Time: 5.3s

Alternatives: 4

Speedup: 1.0×

Specification

Math

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

FPCore

(FPCore (x) :precision binary64 (- (log (- (/ 1.0 x) 1.0))))

C

double code(double x) {
	return -log(((1.0 / x) - 1.0));
}

Fortran

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

Java

public static double code(double x) {
	return -Math.log(((1.0 / x) - 1.0));
}

Python

def code(x):
	return -math.log(((1.0 / x) - 1.0))

Julia

function code(x)
	return Float64(-log(Float64(Float64(1.0 / x) - 1.0)))
end

MATLAB

function tmp = code(x)
	tmp = -log(((1.0 / x) - 1.0));
end

Wolfram

code[x_] := (-N[Log[N[(N[(1.0 / x), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision])

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 (- (log (- (/ 1.0 x) 1.0))))

C

double code(double x) {
	return -log(((1.0 / x) - 1.0));
}

Fortran

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

Java

public static double code(double x) {
	return -Math.log(((1.0 / x) - 1.0));
}

Python

def code(x):
	return -math.log(((1.0 / x) - 1.0))

Julia

function code(x)
	return Float64(-log(Float64(Float64(1.0 / x) - 1.0)))
end

MATLAB

function tmp = code(x)
	tmp = -log(((1.0 / x) - 1.0));
end

Wolfram

code[x_] := (-N[Log[N[(N[(1.0 / x), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision])

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 (log (/ x (- 1.0 x))))

C

double code(double x) {
	return log((x / (1.0 - x)));
}

Fortran

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

Java

public static double code(double x) {
	return Math.log((x / (1.0 - x)));
}

Python

def code(x):
	return math.log((x / (1.0 - x)))

Julia

function code(x)
	return log(Float64(x / Float64(1.0 - x)))
end

MATLAB

function tmp = code(x)
	tmp = log((x / (1.0 - x)));
end

Wolfram

code[x_] := N[Log[N[(x / N[(1.0 - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[-\log \left(\frac{1}{x} - 1\right) \]
2. Add Preprocessing

3. Taylor expanded in x around 0 100.0%

   \[\leadsto -\log \color{blue}{\left(\frac{1 + -1 \cdot x}{x}\right)} \]
4. Step-by-step derivation

   1. mul-1-neg 100.0%

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

   2. unsub-neg 100.0%

      \[\leadsto -\log \left(\frac{\color{blue}{1 - x}}{x}\right) \]

5. Simplified 100.0%

   \[\leadsto -\log \color{blue}{\left(\frac{1 - x}{x}\right)} \]
6. Step-by-step derivation

   1. neg-log 100.0%

      \[\leadsto \color{blue}{\log \left(\frac{1}{\frac{1 - x}{x}}\right)} \]

   2. clear-num 100.0%

      \[\leadsto \log \color{blue}{\left(\frac{x}{1 - x}\right)} \]

   3. diff-log 100.0%

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

   4. log1p-expm1-u 6.0%

      \[\leadsto \color{blue}{\mathsf{log1p}\left(\mathsf{expm1}\left(\log x\right)\right)} - \log \left(1 - x\right) \]

   5. log1p-undefine 6.0%

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

   6. diff-log 6.0%

      \[\leadsto \color{blue}{\log \left(\frac{1 + \mathsf{expm1}\left(\log x\right)}{1 - x}\right)} \]

   7. expm1-undefine 6.0%

      \[\leadsto \log \left(\frac{1 + \color{blue}{\left(e^{\log x} - 1\right)}}{1 - x}\right) \]

   8. add-exp-log 6.0%

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

7. Applied egg-rr 6.0%

   \[\leadsto \color{blue}{\log \left(\frac{1 + \left(x - 1\right)}{1 - x}\right)} \]
8. Step-by-step derivation

   1. +-commutative 6.0%

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

   2. associate-+l- 100.0%

      \[\leadsto \log \left(\frac{\color{blue}{x - \left(1 - 1\right)}}{1 - x}\right) \]

   3. metadata-eval 100.0%

      \[\leadsto \log \left(\frac{x - \color{blue}{0}}{1 - x}\right) \]

   4. --rgt-identity 100.0%

      \[\leadsto \log \left(\frac{\color{blue}{x}}{1 - x}\right) \]

9. Simplified 100.0%

   \[\leadsto \color{blue}{\log \left(\frac{x}{1 - x}\right)} \]
10. Add Preprocessing

Alternative 2: 99.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x + \log x \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ x (log x)))

C

double code(double x) {
	return x + log(x);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = x + log(x)
end function

Java

public static double code(double x) {
	return x + Math.log(x);
}

Python

def code(x):
	return x + math.log(x)

Julia

function code(x)
	return Float64(x + log(x))
end

MATLAB

function tmp = code(x)
	tmp = x + log(x);
end

Wolfram

code[x_] := N[(x + N[Log[x], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[-\log \left(\frac{1}{x} - 1\right) \]
2. Add Preprocessing

3. Taylor expanded in x around 0 99.6%

   \[\leadsto \color{blue}{x - -1 \cdot \log x} \]
4. Step-by-step derivation

   1. cancel-sign-sub-inv 99.6%

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

   2. metadata-eval 99.6%

      \[\leadsto x + \color{blue}{1} \cdot \log x \]

   3. *-lft-identity 99.6%

      \[\leadsto x + \color{blue}{\log x} \]

5. Simplified 99.6%

   \[\leadsto \color{blue}{x + \log x} \]
6. Add Preprocessing

Alternative 3: 98.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \log x \end{array} \]

FPCore

(FPCore (x) :precision binary64 (log x))

C

double code(double x) {
	return log(x);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = log(x)
end function

Java

public static double code(double x) {
	return Math.log(x);
}

Python

def code(x):
	return math.log(x)

Julia

function code(x)
	return log(x)
end

MATLAB

function tmp = code(x)
	tmp = log(x);
end

Wolfram

code[x_] := N[Log[x], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[-\log \left(\frac{1}{x} - 1\right) \]
2. Add Preprocessing

3. Taylor expanded in x around 0 98.8%

   \[\leadsto \color{blue}{\log x} \]
4. Add Preprocessing

Alternative 4: 3.1% accurate, 106.0× speedup

Math

\[\begin{array}{l} \\ 0 \end{array} \]

FPCore

(FPCore (x) :precision binary64 0.0)

C

double code(double x) {
	return 0.0;
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = 0.0d0
end function

Java

public static double code(double x) {
	return 0.0;
}

Python

def code(x):
	return 0.0

Julia

function code(x)
	return 0.0
end

MATLAB

function tmp = code(x)
	tmp = 0.0;
end

Wolfram

code[x_] := 0.0

Derivation

1. Initial program 100.0%

   \[-\log \left(\frac{1}{x} - 1\right) \]
2. Add Preprocessing
3. Step-by-step derivation

   1. add-sqr-sqrt 0.0%

      \[\leadsto \color{blue}{\sqrt{-\log \left(\frac{1}{x} - 1\right)} \cdot \sqrt{-\log \left(\frac{1}{x} - 1\right)}} \]

   2. sqrt-unprod 1.5%

      \[\leadsto \color{blue}{\sqrt{\left(-\log \left(\frac{1}{x} - 1\right)\right) \cdot \left(-\log \left(\frac{1}{x} - 1\right)\right)}} \]

   3. sqr-neg 1.5%

      \[\leadsto \sqrt{\color{blue}{\log \left(\frac{1}{x} - 1\right) \cdot \log \left(\frac{1}{x} - 1\right)}} \]

   4. sqrt-unprod 1.5%

      \[\leadsto \color{blue}{\sqrt{\log \left(\frac{1}{x} - 1\right)} \cdot \sqrt{\log \left(\frac{1}{x} - 1\right)}} \]

   5. add-sqr-sqrt 1.5%

      \[\leadsto \color{blue}{\log \left(\frac{1}{x} - 1\right)} \]

   6. add-sqr-sqrt 1.5%

      \[\leadsto \log \color{blue}{\left(\sqrt{\frac{1}{x} - 1} \cdot \sqrt{\frac{1}{x} - 1}\right)} \]

   7. log-prod 1.5%

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

4. Applied egg-rr 3.1%

   \[\leadsto \color{blue}{0} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024188 
(FPCore (x)
  :name "neg log"
  :precision binary64
  (- (log (- (/ 1.0 x) 1.0))))