expq2 (section 3.11)

Percentage Accurate: 37.4% → 99.3%

Time: 3.3s

Alternatives: 6

Speedup: 68.3×

Specification

Math

\[\begin{array}{l} \\ \frac{e^{x}}{e^{x} - 1} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 37.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{e^{x}}{e^{x} - 1} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{1}{\mathsf{expm1}\left(x\right)} \cdot e^{x} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (* (/ 1.0 (expm1 x)) (exp x)))

C

double code(double x) {
	return (1.0 / expm1(x)) * exp(x);
}

Java

public static double code(double x) {
	return (1.0 / Math.expm1(x)) * Math.exp(x);
}

Python

def code(x):
	return (1.0 / math.expm1(x)) * math.exp(x)

Julia

function code(x)
	return Float64(Float64(1.0 / expm1(x)) * exp(x))
end

Wolfram

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

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]
4. Step-by-step derivation

   1. clear-num 99.2%

      \[\leadsto \color{blue}{\frac{1}{\frac{\mathsf{expm1}\left(x\right)}{e^{x}}}} \]

   2. associate-/r/ 99.2%

      \[\leadsto \color{blue}{\frac{1}{\mathsf{expm1}\left(x\right)} \cdot e^{x}} \]

5. Applied egg-rr 99.2%

   \[\leadsto \color{blue}{\frac{1}{\mathsf{expm1}\left(x\right)} \cdot e^{x}} \]

6. Final simplification 99.2%

   \[\leadsto \frac{1}{\mathsf{expm1}\left(x\right)} \cdot e^{x} \]

Alternative 2: 99.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{e^{x}}{\mathsf{expm1}\left(x\right)} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (/ (exp x) (expm1 x)))

C

double code(double x) {
	return exp(x) / expm1(x);
}

Java

public static double code(double x) {
	return Math.exp(x) / Math.expm1(x);
}

Python

def code(x):
	return math.exp(x) / math.expm1(x)

Julia

function code(x)
	return Float64(exp(x) / expm1(x))
end

Wolfram

code[x_] := N[(N[Exp[x], $MachinePrecision] / N[(Exp[x] - 1), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]

4. Final simplification 99.2%

   \[\leadsto \frac{e^{x}}{\mathsf{expm1}\left(x\right)} \]

Alternative 3: 66.4% accurate, 22.8× speedup

Math

\[\begin{array}{l} \\ 0.5 + \left(x \cdot 0.08333333333333333 + \frac{1}{x}\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (+ 0.5 (+ (* x 0.08333333333333333) (/ 1.0 x))))

C

double code(double x) {
	return 0.5 + ((x * 0.08333333333333333) + (1.0 / x));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = 0.5d0 + ((x * 0.08333333333333333d0) + (1.0d0 / x))
end function

Java

public static double code(double x) {
	return 0.5 + ((x * 0.08333333333333333) + (1.0 / x));
}

Python

def code(x):
	return 0.5 + ((x * 0.08333333333333333) + (1.0 / x))

Julia

function code(x)
	return Float64(0.5 + Float64(Float64(x * 0.08333333333333333) + Float64(1.0 / x)))
end

MATLAB

function tmp = code(x)
	tmp = 0.5 + ((x * 0.08333333333333333) + (1.0 / x));
end

Wolfram

code[x_] := N[(0.5 + N[(N[(x * 0.08333333333333333), $MachinePrecision] + N[(1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]

4. Taylor expanded in x around 0 67.8%

   \[\leadsto \color{blue}{0.5 + \left(0.08333333333333333 \cdot x + \frac{1}{x}\right)} \]

5. Final simplification 67.8%

   \[\leadsto 0.5 + \left(x \cdot 0.08333333333333333 + \frac{1}{x}\right) \]

Alternative 4: 66.4% accurate, 41.0× speedup

Math

\[\begin{array}{l} \\ 0.5 + \frac{1}{x} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ 0.5 (/ 1.0 x)))

C

double code(double x) {
	return 0.5 + (1.0 / x);
}

Fortran

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

Java

public static double code(double x) {
	return 0.5 + (1.0 / x);
}

Python

def code(x):
	return 0.5 + (1.0 / x)

Julia

function code(x)
	return Float64(0.5 + Float64(1.0 / x))
end

MATLAB

function tmp = code(x)
	tmp = 0.5 + (1.0 / x);
end

Wolfram

code[x_] := N[(0.5 + N[(1.0 / x), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]

4. Taylor expanded in x around 0 67.6%

   \[\leadsto \color{blue}{0.5 + \frac{1}{x}} \]
5. Step-by-step derivation

   1. +-commutative 67.6%

      \[\leadsto \color{blue}{\frac{1}{x} + 0.5} \]

6. Simplified 67.6%

   \[\leadsto \color{blue}{\frac{1}{x} + 0.5} \]

7. Final simplification 67.6%

   \[\leadsto 0.5 + \frac{1}{x} \]

Alternative 5: 66.4% accurate, 68.3× speedup

Math

\[\begin{array}{l} \\ \frac{1}{x} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

public static double code(double x) {
	return 1.0 / x;
}

Python

def code(x):
	return 1.0 / x

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]

4. Taylor expanded in x around 0 67.4%

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

5. Final simplification 67.4%

   \[\leadsto \frac{1}{x} \]

Alternative 6: 3.3% accurate, 205.0× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 0.5)

C

double code(double x) {
	return 0.5;
}

Fortran

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

Java

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

Python

def code(x):
	return 0.5

Julia

function code(x)
	return 0.5
end

MATLAB

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

Wolfram

code[x_] := 0.5

Derivation

1. Initial program 36.5%

   \[\frac{e^{x}}{e^{x} - 1} \]
2. Step-by-step derivation

   1. expm1-def 99.2%

      \[\leadsto \frac{e^{x}}{\color{blue}{\mathsf{expm1}\left(x\right)}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{e^{x}}{\mathsf{expm1}\left(x\right)}} \]

4. Taylor expanded in x around 0 67.8%

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

   1. +-commutative 67.8%

      \[\leadsto 0.5 + \color{blue}{\left(\frac{1}{x} + 0.08333333333333333 \cdot x\right)} \]

   2. flip-+ 37.9%

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

   3. inv-pow 37.9%

      \[\leadsto 0.5 + \frac{\color{blue}{{x}^{-1}} \cdot \frac{1}{x} - \left(0.08333333333333333 \cdot x\right) \cdot \left(0.08333333333333333 \cdot x\right)}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   4. inv-pow 37.9%

      \[\leadsto 0.5 + \frac{{x}^{-1} \cdot \color{blue}{{x}^{-1}} - \left(0.08333333333333333 \cdot x\right) \cdot \left(0.08333333333333333 \cdot x\right)}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   5. pow-prod-up 37.7%

      \[\leadsto 0.5 + \frac{\color{blue}{{x}^{\left(-1 + -1\right)}} - \left(0.08333333333333333 \cdot x\right) \cdot \left(0.08333333333333333 \cdot x\right)}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   6. metadata-eval 37.7%

      \[\leadsto 0.5 + \frac{{x}^{\color{blue}{-2}} - \left(0.08333333333333333 \cdot x\right) \cdot \left(0.08333333333333333 \cdot x\right)}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   7. *-commutative 37.7%

      \[\leadsto 0.5 + \frac{{x}^{-2} - \color{blue}{\left(x \cdot 0.08333333333333333\right)} \cdot \left(0.08333333333333333 \cdot x\right)}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   8. *-commutative 37.7%

      \[\leadsto 0.5 + \frac{{x}^{-2} - \left(x \cdot 0.08333333333333333\right) \cdot \color{blue}{\left(x \cdot 0.08333333333333333\right)}}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   9. swap-sqr 37.7%

      \[\leadsto 0.5 + \frac{{x}^{-2} - \color{blue}{\left(x \cdot x\right) \cdot \left(0.08333333333333333 \cdot 0.08333333333333333\right)}}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   10. metadata-eval 37.7%

       \[\leadsto 0.5 + \frac{{x}^{-2} - \left(x \cdot x\right) \cdot \color{blue}{0.006944444444444444}}{\frac{1}{x} - 0.08333333333333333 \cdot x} \]

   11. *-commutative 37.7%

       \[\leadsto 0.5 + \frac{{x}^{-2} - \left(x \cdot x\right) \cdot 0.006944444444444444}{\frac{1}{x} - \color{blue}{x \cdot 0.08333333333333333}} \]

6. Applied egg-rr 37.7%

   \[\leadsto 0.5 + \color{blue}{\frac{{x}^{-2} - \left(x \cdot x\right) \cdot 0.006944444444444444}{\frac{1}{x} - x \cdot 0.08333333333333333}} \]

7. Taylor expanded in x around 0 38.1%

   \[\leadsto 0.5 + \frac{\color{blue}{\frac{1}{{x}^{2}}}}{\frac{1}{x} - x \cdot 0.08333333333333333} \]

9. Simplified 38.1%

   \[\leadsto 0.5 + \frac{\color{blue}{\frac{1}{x \cdot x}}}{\frac{1}{x} - x \cdot 0.08333333333333333} \]

10. Taylor expanded in x around inf 3.3%

    \[\leadsto \color{blue}{0.5} \]

11. Final simplification 3.3%

    \[\leadsto 0.5 \]

Developer target: 38.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \frac{1}{1 - e^{-x}} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023238 
(FPCore (x)
  :name "expq2 (section 3.11)"
  :precision binary64

  :herbie-target
  (/ 1.0 (- 1.0 (exp (- x))))

  (/ (exp x) (- (exp x) 1.0)))