exp2 (problem 3.3.7)

Percentage Accurate: 53.8% → 99.3%

Time: 11.0s

Alternatives: 9

Speedup: 2.0×

Specification

\[\left|x\right| \leq 710\]

Math

\[\begin{array}{l} \\ \left(e^{x} - 2\right) + e^{-x} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ (- (exp x) 2.0) (exp (- x))))

C

double code(double x) {
	return (exp(x) - 2.0) + exp(-x);
}

Fortran

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

Java

public static double code(double x) {
	return (Math.exp(x) - 2.0) + Math.exp(-x);
}

Python

def code(x):
	return (math.exp(x) - 2.0) + math.exp(-x)

Julia

function code(x)
	return Float64(Float64(exp(x) - 2.0) + exp(Float64(-x)))
end

MATLAB

function tmp = code(x)
	tmp = (exp(x) - 2.0) + exp(-x);
end

Wolfram

code[x_] := N[(N[(N[Exp[x], $MachinePrecision] - 2.0), $MachinePrecision] + N[Exp[(-x)], $MachinePrecision]), $MachinePrecision]

Initial Program: 53.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(e^{x} - 2\right) + e^{-x} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ (- (exp x) 2.0) (exp (- x))))

C

double code(double x) {
	return (exp(x) - 2.0) + exp(-x);
}

Fortran

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

Java

public static double code(double x) {
	return (Math.exp(x) - 2.0) + Math.exp(-x);
}

Python

def code(x):
	return (math.exp(x) - 2.0) + math.exp(-x)

Julia

function code(x)
	return Float64(Float64(exp(x) - 2.0) + exp(Float64(-x)))
end

MATLAB

function tmp = code(x)
	tmp = (exp(x) - 2.0) + exp(-x);
end

Wolfram

code[x_] := N[(N[(N[Exp[x], $MachinePrecision] - 2.0), $MachinePrecision] + N[Exp[(-x)], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, 5.511463844797178 \cdot 10^{-7}, 4.96031746031746 \cdot 10^{-5}\right), 0.002777777777777778\right), 0.08333333333333333\right) \cdot {x}^{4} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (+
  (pow x 2.0)
  (*
   (fma
    (pow x 2.0)
    (fma
     (pow x 2.0)
     (fma (pow x 2.0) 5.511463844797178e-7 4.96031746031746e-5)
     0.002777777777777778)
    0.08333333333333333)
   (pow x 4.0))))

C

double code(double x) {
	return pow(x, 2.0) + (fma(pow(x, 2.0), fma(pow(x, 2.0), fma(pow(x, 2.0), 5.511463844797178e-7, 4.96031746031746e-5), 0.002777777777777778), 0.08333333333333333) * pow(x, 4.0));
}

Julia

function code(x)
	return Float64((x ^ 2.0) + Float64(fma((x ^ 2.0), fma((x ^ 2.0), fma((x ^ 2.0), 5.511463844797178e-7, 4.96031746031746e-5), 0.002777777777777778), 0.08333333333333333) * (x ^ 4.0)))
end

Wolfram

code[x_] := N[(N[Power[x, 2.0], $MachinePrecision] + N[(N[(N[Power[x, 2.0], $MachinePrecision] * N[(N[Power[x, 2.0], $MachinePrecision] * N[(N[Power[x, 2.0], $MachinePrecision] * 5.511463844797178e-7 + 4.96031746031746e-5), $MachinePrecision] + 0.002777777777777778), $MachinePrecision] + 0.08333333333333333), $MachinePrecision] * N[Power[x, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing

5. Taylor expanded in x around 0 99.2%

   \[\leadsto \color{blue}{{x}^{2} \cdot \left(1 + {x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right)\right)} \]
6. Step-by-step derivation

   1. distribute-rgt-in 99.3%

      \[\leadsto \color{blue}{1 \cdot {x}^{2} + \left({x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right)\right) \cdot {x}^{2}} \]

   2. *-lft-identity 99.3%

      \[\leadsto \color{blue}{{x}^{2}} + \left({x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right)\right) \cdot {x}^{2} \]

   3. *-commutative 99.3%

      \[\leadsto {x}^{2} + \color{blue}{\left(\left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right) \cdot {x}^{2}\right)} \cdot {x}^{2} \]

   4. associate-*l* 99.3%

      \[\leadsto {x}^{2} + \color{blue}{\left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right) \cdot \left({x}^{2} \cdot {x}^{2}\right)} \]

   5. +-commutative 99.3%

      \[\leadsto {x}^{2} + \color{blue}{\left({x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right) + 0.08333333333333333\right)} \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   6. fma-define 99.3%

      \[\leadsto {x}^{2} + \color{blue}{\mathsf{fma}\left({x}^{2}, 0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right), 0.08333333333333333\right)} \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   7. +-commutative 99.3%

      \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \color{blue}{{x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right) + 0.002777777777777778}, 0.08333333333333333\right) \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   8. fma-define 99.3%

      \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \color{blue}{\mathsf{fma}\left({x}^{2}, 4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}, 0.002777777777777778\right)}, 0.08333333333333333\right) \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   9. +-commutative 99.3%

      \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \color{blue}{5.511463844797178 \cdot 10^{-7} \cdot {x}^{2} + 4.96031746031746 \cdot 10^{-5}}, 0.002777777777777778\right), 0.08333333333333333\right) \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   10. *-commutative 99.3%

       \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \color{blue}{{x}^{2} \cdot 5.511463844797178 \cdot 10^{-7}} + 4.96031746031746 \cdot 10^{-5}, 0.002777777777777778\right), 0.08333333333333333\right) \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   11. fma-define 99.3%

       \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \color{blue}{\mathsf{fma}\left({x}^{2}, 5.511463844797178 \cdot 10^{-7}, 4.96031746031746 \cdot 10^{-5}\right)}, 0.002777777777777778\right), 0.08333333333333333\right) \cdot \left({x}^{2} \cdot {x}^{2}\right) \]

   12. pow-sqr 99.3%

       \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, 5.511463844797178 \cdot 10^{-7}, 4.96031746031746 \cdot 10^{-5}\right), 0.002777777777777778\right), 0.08333333333333333\right) \cdot \color{blue}{{x}^{\left(2 \cdot 2\right)}} \]

   13. metadata-eval 99.3%

       \[\leadsto {x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, 5.511463844797178 \cdot 10^{-7}, 4.96031746031746 \cdot 10^{-5}\right), 0.002777777777777778\right), 0.08333333333333333\right) \cdot {x}^{\color{blue}{4}} \]

7. Simplified 99.3%

   \[\leadsto \color{blue}{{x}^{2} + \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, \mathsf{fma}\left({x}^{2}, 5.511463844797178 \cdot 10^{-7}, 4.96031746031746 \cdot 10^{-5}\right), 0.002777777777777778\right), 0.08333333333333333\right) \cdot {x}^{4}} \]
8. Add Preprocessing

Alternative 2: 99.3% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ {x}^{2} \cdot \left(1 + {x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + {x}^{2} \cdot 5.511463844797178 \cdot 10^{-7}\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (*
  (pow x 2.0)
  (+
   1.0
   (*
    (pow x 2.0)
    (+
     0.08333333333333333
     (*
      (pow x 2.0)
      (+
       0.002777777777777778
       (*
        (pow x 2.0)
        (+ 4.96031746031746e-5 (* (pow x 2.0) 5.511463844797178e-7))))))))))

C

double code(double x) {
	return pow(x, 2.0) * (1.0 + (pow(x, 2.0) * (0.08333333333333333 + (pow(x, 2.0) * (0.002777777777777778 + (pow(x, 2.0) * (4.96031746031746e-5 + (pow(x, 2.0) * 5.511463844797178e-7))))))));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (x ** 2.0d0) * (1.0d0 + ((x ** 2.0d0) * (0.08333333333333333d0 + ((x ** 2.0d0) * (0.002777777777777778d0 + ((x ** 2.0d0) * (4.96031746031746d-5 + ((x ** 2.0d0) * 5.511463844797178d-7))))))))
end function

Java

public static double code(double x) {
	return Math.pow(x, 2.0) * (1.0 + (Math.pow(x, 2.0) * (0.08333333333333333 + (Math.pow(x, 2.0) * (0.002777777777777778 + (Math.pow(x, 2.0) * (4.96031746031746e-5 + (Math.pow(x, 2.0) * 5.511463844797178e-7))))))));
}

Python

def code(x):
	return math.pow(x, 2.0) * (1.0 + (math.pow(x, 2.0) * (0.08333333333333333 + (math.pow(x, 2.0) * (0.002777777777777778 + (math.pow(x, 2.0) * (4.96031746031746e-5 + (math.pow(x, 2.0) * 5.511463844797178e-7))))))))

Julia

function code(x)
	return Float64((x ^ 2.0) * Float64(1.0 + Float64((x ^ 2.0) * Float64(0.08333333333333333 + Float64((x ^ 2.0) * Float64(0.002777777777777778 + Float64((x ^ 2.0) * Float64(4.96031746031746e-5 + Float64((x ^ 2.0) * 5.511463844797178e-7)))))))))
end

MATLAB

function tmp = code(x)
	tmp = (x ^ 2.0) * (1.0 + ((x ^ 2.0) * (0.08333333333333333 + ((x ^ 2.0) * (0.002777777777777778 + ((x ^ 2.0) * (4.96031746031746e-5 + ((x ^ 2.0) * 5.511463844797178e-7))))))));
end

Wolfram

code[x_] := N[(N[Power[x, 2.0], $MachinePrecision] * N[(1.0 + N[(N[Power[x, 2.0], $MachinePrecision] * N[(0.08333333333333333 + N[(N[Power[x, 2.0], $MachinePrecision] * N[(0.002777777777777778 + N[(N[Power[x, 2.0], $MachinePrecision] * N[(4.96031746031746e-5 + N[(N[Power[x, 2.0], $MachinePrecision] * 5.511463844797178e-7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing

5. Taylor expanded in x around 0 99.2%

   \[\leadsto \color{blue}{{x}^{2} \cdot \left(1 + {x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + 5.511463844797178 \cdot 10^{-7} \cdot {x}^{2}\right)\right)\right)\right)} \]
6. Step-by-step derivation

   1. *-commutative 99.2%

      \[\leadsto {x}^{2} \cdot \left(1 + {x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + \color{blue}{{x}^{2} \cdot 5.511463844797178 \cdot 10^{-7}}\right)\right)\right)\right) \]

7. Simplified 99.2%

   \[\leadsto \color{blue}{{x}^{2} \cdot \left(1 + {x}^{2} \cdot \left(0.08333333333333333 + {x}^{2} \cdot \left(0.002777777777777778 + {x}^{2} \cdot \left(4.96031746031746 \cdot 10^{-5} + {x}^{2} \cdot 5.511463844797178 \cdot 10^{-7}\right)\right)\right)\right)} \]
8. Add Preprocessing

Alternative 3: 98.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ x \cdot x + 0.08333333333333333 \cdot {x}^{4} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (+ (* x x) (* 0.08333333333333333 (pow x 4.0))))

C

double code(double x) {
	return (x * x) + (0.08333333333333333 * pow(x, 4.0));
}

Fortran

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

Java

public static double code(double x) {
	return (x * x) + (0.08333333333333333 * Math.pow(x, 4.0));
}

Python

def code(x):
	return (x * x) + (0.08333333333333333 * math.pow(x, 4.0))

Julia

function code(x)
	return Float64(Float64(x * x) + Float64(0.08333333333333333 * (x ^ 4.0)))
end

MATLAB

function tmp = code(x)
	tmp = (x * x) + (0.08333333333333333 * (x ^ 4.0));
end

Wolfram

code[x_] := N[(N[(x * x), $MachinePrecision] + N[(0.08333333333333333 * N[Power[x, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing

5. Taylor expanded in x around 0 98.6%

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

   1. distribute-rgt-in 98.7%

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

   2. *-lft-identity 98.7%

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

   3. associate-*l* 98.7%

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

   4. pow-sqr 98.7%

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

   5. metadata-eval 98.7%

      \[\leadsto {x}^{2} + 0.08333333333333333 \cdot {x}^{\color{blue}{4}} \]

7. Simplified 98.7%

   \[\leadsto \color{blue}{{x}^{2} + 0.08333333333333333 \cdot {x}^{4}} \]
8. Step-by-step derivation

   1. unpow2 98.7%

      \[\leadsto \color{blue}{x \cdot x} + 0.08333333333333333 \cdot {x}^{4} \]

9. Applied egg-rr 98.7%

   \[\leadsto \color{blue}{x \cdot x} + 0.08333333333333333 \cdot {x}^{4} \]
10. Add Preprocessing

Alternative 4: 98.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ {x}^{2} \end{array} \]

FPCore

(FPCore (x) :precision binary64 (pow x 2.0))

C

double code(double x) {
	return pow(x, 2.0);
}

Fortran

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

Java

public static double code(double x) {
	return Math.pow(x, 2.0);
}

Python

def code(x):
	return math.pow(x, 2.0)

Julia

function code(x)
	return x ^ 2.0
end

MATLAB

function tmp = code(x)
	tmp = x ^ 2.0;
end

Wolfram

code[x_] := N[Power[x, 2.0], $MachinePrecision]

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 47.7%

   \[\leadsto \left(\color{blue}{\left(1 + x \cdot \left(1 + 0.5 \cdot x\right)\right)} - 2\right) + e^{-x} \]
4. Step-by-step derivation

   1. *-commutative 47.7%

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

5. Simplified 47.7%

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

6. Taylor expanded in x around 0 47.9%

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

7. Taylor expanded in x around 0 98.0%

   \[\leadsto \color{blue}{{x}^{2}} \]
8. Add Preprocessing

Alternative 5: 52.6% accurate, 10.8× speedup

Math

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

FPCore

(FPCore (x)
 :precision binary64
 (+ (+ (* x (+ 1.0 (* x 0.5))) -1.0) (+ 1.0 (* x (+ (* x 0.5) -1.0)))))

C

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

Fortran

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

Java

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

Python

def code(x):
	return ((x * (1.0 + (x * 0.5))) + -1.0) + (1.0 + (x * ((x * 0.5) + -1.0)))

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Add Preprocessing

3. Taylor expanded in x around 0 47.7%

   \[\leadsto \left(\color{blue}{\left(1 + x \cdot \left(1 + 0.5 \cdot x\right)\right)} - 2\right) + e^{-x} \]
4. Step-by-step derivation

   1. *-commutative 47.7%

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

5. Simplified 47.7%

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

6. Taylor expanded in x around 0 47.9%

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

7. Taylor expanded in x around 0 47.9%

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

8. Final simplification 47.9%

   \[\leadsto \left(x \cdot \left(1 + x \cdot 0.5\right) + -1\right) + \left(1 + x \cdot \left(x \cdot 0.5 + -1\right)\right) \]
9. Add Preprocessing

Alternative 6: 52.6% accurate, 10.8× speedup

Math

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

FPCore

(FPCore (x)
 :precision binary64
 (+ (+ 1.0 (* x (+ 1.0 (* x 0.5)))) (+ (* x (+ (* x 0.5) -1.0)) -1.0)))

C

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

Fortran

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

Java

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

Python

def code(x):
	return (1.0 + (x * (1.0 + (x * 0.5)))) + ((x * ((x * 0.5) + -1.0)) + -1.0)

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing

5. Taylor expanded in x around 0 47.9%

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

6. Taylor expanded in x around 0 47.9%

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

   1. *-commutative 47.7%

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

8. Simplified 47.9%

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

9. Final simplification 47.9%

   \[\leadsto \left(1 + x \cdot \left(1 + x \cdot 0.5\right)\right) + \left(x \cdot \left(x \cdot 0.5 + -1\right) + -1\right) \]
10. Add Preprocessing

Alternative 7: 52.4% accurate, 22.9× speedup

Math

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

FPCore

(FPCore (x) :precision binary64 (+ x (* x (+ (* x 0.5) -1.0))))

C

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

Fortran

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

Java

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

Python

def code(x):
	return x + (x * ((x * 0.5) + -1.0))

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing

5. Taylor expanded in x around 0 47.9%

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

6. Taylor expanded in x around 0 47.2%

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

   1. +-commutative 47.2%

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

8. Simplified 47.2%

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

   1. *-un-lft-identity 47.2%

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

   2. associate-+l+ 6.2%

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

   3. add-exp-log 5.7%

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

   4. log1p-undefine 5.7%

      \[\leadsto 1 \cdot \left(x + e^{\color{blue}{\mathsf{log1p}\left(x \cdot \left(0.5 \cdot x - 1\right) - 1\right)}}\right) \]

   5. add-exp-log 2.5%

      \[\leadsto 1 \cdot \left(x + e^{\mathsf{log1p}\left(\color{blue}{e^{\log \left(x \cdot \left(0.5 \cdot x - 1\right)\right)}} - 1\right)}\right) \]

   6. expm1-define 2.5%

      \[\leadsto 1 \cdot \left(x + e^{\mathsf{log1p}\left(\color{blue}{\mathsf{expm1}\left(\log \left(x \cdot \left(0.5 \cdot x - 1\right)\right)\right)}\right)}\right) \]

   7. log1p-expm1-u 4.0%

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

   8. add-exp-log 47.5%

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

   9. *-commutative 47.5%

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

   10. fmm-def 47.5%

       \[\leadsto 1 \cdot \left(x + x \cdot \color{blue}{\mathsf{fma}\left(x, 0.5, -1\right)}\right) \]

   11. metadata-eval 47.5%

       \[\leadsto 1 \cdot \left(x + x \cdot \mathsf{fma}\left(x, 0.5, \color{blue}{-1}\right)\right) \]

10. Applied egg-rr 47.5%

    \[\leadsto \color{blue}{1 \cdot \left(x + x \cdot \mathsf{fma}\left(x, 0.5, -1\right)\right)} \]
11. Step-by-step derivation

    1. *-lft-identity 47.5%

       \[\leadsto \color{blue}{x + x \cdot \mathsf{fma}\left(x, 0.5, -1\right)} \]

12. Simplified 47.5%

    \[\leadsto \color{blue}{x + x \cdot \mathsf{fma}\left(x, 0.5, -1\right)} \]
13. Step-by-step derivation

    1. metadata-eval 47.5%

       \[\leadsto x + x \cdot \mathsf{fma}\left(x, 0.5, \color{blue}{-1}\right) \]

    2. fmm-def 47.5%

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

14. Applied egg-rr 47.5%

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

15. Final simplification 47.5%

    \[\leadsto x + x \cdot \left(x \cdot 0.5 + -1\right) \]
16. Add Preprocessing

Alternative 8: 51.8% accurate, 29.4× speedup

Math

\[\begin{array}{l} \\ -2 + \left(2 + x \cdot 2\right) \end{array} \]

FPCore

(FPCore (x) :precision binary64 (+ -2.0 (+ 2.0 (* x 2.0))))

C

double code(double x) {
	return -2.0 + (2.0 + (x * 2.0));
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    code = (-2.0d0) + (2.0d0 + (x * 2.0d0))
end function

Java

public static double code(double x) {
	return -2.0 + (2.0 + (x * 2.0));
}

Python

def code(x):
	return -2.0 + (2.0 + (x * 2.0))

Julia

function code(x)
	return Float64(-2.0 + Float64(2.0 + Float64(x * 2.0)))
end

MATLAB

function tmp = code(x)
	tmp = -2.0 + (2.0 + (x * 2.0));
end

Wolfram

code[x_] := N[(-2.0 + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. +-commutative 49.4%

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

   2. associate-+r+ 49.4%

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

   3. metadata-eval 49.4%

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

   4. sub-neg 49.4%

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

   5. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   6. add-sqr-sqrt 22.5%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{-x} \cdot \sqrt{-x}}}\right) \]

   7. sqrt-unprod 48.1%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{\left(-x\right) \cdot \left(-x\right)}}}\right) \]

   8. sqr-neg 48.1%

      \[\leadsto e^{x} - \left(2 - e^{\sqrt{\color{blue}{x \cdot x}}}\right) \]

   9. sqrt-unprod 25.6%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{x} \cdot \sqrt{x}}}\right) \]

   10. add-sqr-sqrt 47.0%

       \[\leadsto e^{x} - \left(2 - e^{\color{blue}{x}}\right) \]

6. Applied egg-rr 47.0%

   \[\leadsto \color{blue}{e^{x} - \left(2 - e^{x}\right)} \]
7. Step-by-step derivation

   1. associate--r- 47.0%

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

   2. sub-neg 47.0%

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

   3. metadata-eval 47.0%

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

   4. +-commutative 47.0%

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

   5. associate-+l+ 47.0%

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

   6. count-2 47.0%

      \[\leadsto -2 + \color{blue}{2 \cdot e^{x}} \]

8. Simplified 47.0%

   \[\leadsto \color{blue}{-2 + 2 \cdot e^{x}} \]

9. Taylor expanded in x around 0 47.0%

   \[\leadsto -2 + \color{blue}{\left(2 + 2 \cdot x\right)} \]
10. Step-by-step derivation

    1. *-commutative 47.0%

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

11. Simplified 47.0%

    \[\leadsto -2 + \color{blue}{\left(2 + x \cdot 2\right)} \]
12. Add Preprocessing

Alternative 9: 51.6% accurate, 206.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 49.4%

   \[\left(e^{x} - 2\right) + e^{-x} \]
2. Step-by-step derivation

   1. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   2. sub-neg 49.4%

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

   3. sub-neg 49.4%

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

   4. distribute-neg-in 49.4%

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

   5. remove-double-neg 49.4%

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

   6. +-commutative 49.4%

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

   7. metadata-eval 49.4%

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

3. Simplified 49.4%

   \[\leadsto \color{blue}{e^{x} + \left(e^{-x} + -2\right)} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. +-commutative 49.4%

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

   2. associate-+r+ 49.4%

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

   3. metadata-eval 49.4%

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

   4. sub-neg 49.4%

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

   5. associate-+l- 49.4%

      \[\leadsto \color{blue}{e^{x} - \left(2 - e^{-x}\right)} \]

   6. add-sqr-sqrt 22.5%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{-x} \cdot \sqrt{-x}}}\right) \]

   7. sqrt-unprod 48.1%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{\left(-x\right) \cdot \left(-x\right)}}}\right) \]

   8. sqr-neg 48.1%

      \[\leadsto e^{x} - \left(2 - e^{\sqrt{\color{blue}{x \cdot x}}}\right) \]

   9. sqrt-unprod 25.6%

      \[\leadsto e^{x} - \left(2 - e^{\color{blue}{\sqrt{x} \cdot \sqrt{x}}}\right) \]

   10. add-sqr-sqrt 47.0%

       \[\leadsto e^{x} - \left(2 - e^{\color{blue}{x}}\right) \]

6. Applied egg-rr 47.0%

   \[\leadsto \color{blue}{e^{x} - \left(2 - e^{x}\right)} \]
7. Step-by-step derivation

   1. associate--r- 47.0%

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

   2. sub-neg 47.0%

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

   3. metadata-eval 47.0%

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

   4. +-commutative 47.0%

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

   5. associate-+l+ 47.0%

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

   6. count-2 47.0%

      \[\leadsto -2 + \color{blue}{2 \cdot e^{x}} \]

8. Simplified 47.0%

   \[\leadsto \color{blue}{-2 + 2 \cdot e^{x}} \]
9. Step-by-step derivation

   1. add-sqr-sqrt 25.6%

      \[\leadsto -2 + 2 \cdot e^{\color{blue}{\sqrt{x} \cdot \sqrt{x}}} \]

   2. sqrt-unprod 47.2%

      \[\leadsto -2 + 2 \cdot e^{\color{blue}{\sqrt{x \cdot x}}} \]

   3. sqr-neg 47.2%

      \[\leadsto -2 + 2 \cdot e^{\sqrt{\color{blue}{\left(-x\right) \cdot \left(-x\right)}}} \]

   4. sqrt-unprod 21.6%

      \[\leadsto -2 + 2 \cdot e^{\color{blue}{\sqrt{-x} \cdot \sqrt{-x}}} \]

   5. add-sqr-sqrt 46.8%

      \[\leadsto -2 + 2 \cdot e^{\color{blue}{-x}} \]

   6. exp-neg 46.8%

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

   7. add-sqr-sqrt 46.8%

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

   8. associate-/r* 46.8%

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

   9. metadata-eval 46.8%

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

   10. sqrt-div 46.8%

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

   11. exp-neg 46.8%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{\color{blue}{e^{-x}}}}{\sqrt{e^{x}}} \]

   12. pow1 46.8%

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

   13. pow1 46.8%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{\color{blue}{e^{-x}}}}{\sqrt{e^{x}}} \]

   14. add-sqr-sqrt 21.6%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{e^{\color{blue}{\sqrt{-x} \cdot \sqrt{-x}}}}}{\sqrt{e^{x}}} \]

   15. sqrt-unprod 46.8%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{e^{\color{blue}{\sqrt{\left(-x\right) \cdot \left(-x\right)}}}}}{\sqrt{e^{x}}} \]

   16. sqr-neg 46.8%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{e^{\sqrt{\color{blue}{x \cdot x}}}}}{\sqrt{e^{x}}} \]

   17. sqrt-unprod 25.3%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{e^{\color{blue}{\sqrt{x} \cdot \sqrt{x}}}}}{\sqrt{e^{x}}} \]

   18. add-sqr-sqrt 46.6%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{e^{\color{blue}{x}}}}{\sqrt{e^{x}}} \]

   19. pow1 46.6%

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

   20. pow1 46.6%

       \[\leadsto -2 + 2 \cdot \frac{\sqrt{\color{blue}{e^{x}}}}{\sqrt{e^{x}}} \]

10. Applied egg-rr 46.6%

    \[\leadsto -2 + 2 \cdot \color{blue}{\frac{\sqrt{e^{x}}}{\sqrt{e^{x}}}} \]
11. Step-by-step derivation

    1. *-inverses 46.6%

       \[\leadsto -2 + 2 \cdot \color{blue}{1} \]

12. Simplified 46.6%

    \[\leadsto -2 + 2 \cdot \color{blue}{1} \]
13. Step-by-step derivation

    1. metadata-eval 46.6%

       \[\leadsto -2 + \color{blue}{2} \]

    2. metadata-eval 46.6%

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

14. Applied egg-rr 46.6%

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

Developer Target 1: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sinh \left(\frac{x}{2}\right)\\ 4 \cdot \left(t\_0 \cdot t\_0\right) \end{array} \end{array} \]

FPCore

(FPCore (x)
 :precision binary64
 (let* ((t_0 (sinh (/ x 2.0)))) (* 4.0 (* t_0 t_0))))

C

double code(double x) {
	double t_0 = sinh((x / 2.0));
	return 4.0 * (t_0 * t_0);
}

Fortran

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: t_0
    t_0 = sinh((x / 2.0d0))
    code = 4.0d0 * (t_0 * t_0)
end function

Java

public static double code(double x) {
	double t_0 = Math.sinh((x / 2.0));
	return 4.0 * (t_0 * t_0);
}

Python

def code(x):
	t_0 = math.sinh((x / 2.0))
	return 4.0 * (t_0 * t_0)

Julia

function code(x)
	t_0 = sinh(Float64(x / 2.0))
	return Float64(4.0 * Float64(t_0 * t_0))
end

MATLAB

function tmp = code(x)
	t_0 = sinh((x / 2.0));
	tmp = 4.0 * (t_0 * t_0);
end

Wolfram

code[x_] := Block[{t$95$0 = N[Sinh[N[(x / 2.0), $MachinePrecision]], $MachinePrecision]}, N[(4.0 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]

Reproduce

herbie shell --seed 2024179 
(FPCore (x)
  :name "exp2 (problem 3.3.7)"
  :precision binary64
  :pre (<= (fabs x) 710.0)

  :alt
  (! :herbie-platform default (* 4 (* (sinh (/ x 2)) (sinh (/ x 2)))))

  (+ (- (exp x) 2.0) (exp (- x))))