expax (section 3.5)

Average Error: 29.8 → 0.8

Time: 24.8s

Precision: binary64

Cost: 47940

Math

\[e^{a \cdot x} - 1 \]

↓

\[\begin{array}{l} t_0 := e^{a \cdot x} + -1\\ t_1 := t_0 \cdot t_0\\ \mathbf{if}\;a \cdot x \leq -1 \cdot 10^{-7}:\\ \;\;\;\;\frac{1}{\frac{1}{t_1} \cdot \left(t_0 \cdot t_1\right)} \cdot t_1\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

FPCore

(FPCore (a x) :precision binary64 (- (exp (* a x)) 1.0))

↓

(FPCore (a x)
 :precision binary64
 (let* ((t_0 (+ (exp (* a x)) -1.0)) (t_1 (* t_0 t_0)))
   (if (<= (* a x) -1e-7)
     (* (/ 1.0 (* (/ 1.0 t_1) (* t_0 t_1))) t_1)
     (* a x))))

C

double code(double a, double x) {
	return exp((a * x)) - 1.0;
}

↓

double code(double a, double x) {
	double t_0 = exp((a * x)) + -1.0;
	double t_1 = t_0 * t_0;
	double tmp;
	if ((a * x) <= -1e-7) {
		tmp = (1.0 / ((1.0 / t_1) * (t_0 * t_1))) * t_1;
	} else {
		tmp = a * x;
	}
	return tmp;
}

Fortran

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

↓

real(8) function code(a, x)
    real(8), intent (in) :: a
    real(8), intent (in) :: x
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = exp((a * x)) + (-1.0d0)
    t_1 = t_0 * t_0
    if ((a * x) <= (-1d-7)) then
        tmp = (1.0d0 / ((1.0d0 / t_1) * (t_0 * t_1))) * t_1
    else
        tmp = a * x
    end if
    code = tmp
end function

Java

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

↓

public static double code(double a, double x) {
	double t_0 = Math.exp((a * x)) + -1.0;
	double t_1 = t_0 * t_0;
	double tmp;
	if ((a * x) <= -1e-7) {
		tmp = (1.0 / ((1.0 / t_1) * (t_0 * t_1))) * t_1;
	} else {
		tmp = a * x;
	}
	return tmp;
}

Python

def code(a, x):
	return math.exp((a * x)) - 1.0

↓

def code(a, x):
	t_0 = math.exp((a * x)) + -1.0
	t_1 = t_0 * t_0
	tmp = 0
	if (a * x) <= -1e-7:
		tmp = (1.0 / ((1.0 / t_1) * (t_0 * t_1))) * t_1
	else:
		tmp = a * x
	return tmp

Julia

function code(a, x)
	return Float64(exp(Float64(a * x)) - 1.0)
end

↓

function code(a, x)
	t_0 = Float64(exp(Float64(a * x)) + -1.0)
	t_1 = Float64(t_0 * t_0)
	tmp = 0.0
	if (Float64(a * x) <= -1e-7)
		tmp = Float64(Float64(1.0 / Float64(Float64(1.0 / t_1) * Float64(t_0 * t_1))) * t_1);
	else
		tmp = Float64(a * x);
	end
	return tmp
end

MATLAB

function tmp = code(a, x)
	tmp = exp((a * x)) - 1.0;
end

↓

function tmp_2 = code(a, x)
	t_0 = exp((a * x)) + -1.0;
	t_1 = t_0 * t_0;
	tmp = 0.0;
	if ((a * x) <= -1e-7)
		tmp = (1.0 / ((1.0 / t_1) * (t_0 * t_1))) * t_1;
	else
		tmp = a * x;
	end
	tmp_2 = tmp;
end

Wolfram

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

↓

code[a_, x_] := Block[{t$95$0 = N[(N[Exp[N[(a * x), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * t$95$0), $MachinePrecision]}, If[LessEqual[N[(a * x), $MachinePrecision], -1e-7], N[(N[(1.0 / N[(N[(1.0 / t$95$1), $MachinePrecision] * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], N[(a * x), $MachinePrecision]]]]

Target

Original	29.8
Target	0.2
Herbie	0.8

\[\begin{array}{l} \mathbf{if}\;\left|a \cdot x\right| < 0.1:\\ \;\;\;\;\left(a \cdot x\right) \cdot \left(1 + \left(\frac{a \cdot x}{2} + \frac{{\left(a \cdot x\right)}^{2}}{6}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;e^{a \cdot x} - 1\\ \end{array} \]

Derivation

1. Split input into 2 regimes

2. if (*.f64 a x) < -9.9999999999999995e-8

   1. Initial program 0.2

      \[e^{a \cdot x} - 1 \]

   2. Applied egg-rr 0.2

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

   3. Applied egg-rr 0.2

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

   if -9.9999999999999995e-8 < (*.f64 a x)

   1. Initial program 44.3

      \[e^{a \cdot x} - 1 \]

   2. Taylor expanded in a around 0 1.1

      \[\leadsto \color{blue}{a \cdot x} \]
3. Recombined 2 regimes into one program.

4. Final simplification 0.8

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \cdot x \leq -1 \cdot 10^{-7}:\\ \;\;\;\;\frac{1}{\frac{1}{\left(e^{a \cdot x} + -1\right) \cdot \left(e^{a \cdot x} + -1\right)} \cdot \left(\left(e^{a \cdot x} + -1\right) \cdot \left(\left(e^{a \cdot x} + -1\right) \cdot \left(e^{a \cdot x} + -1\right)\right)\right)} \cdot \left(\left(e^{a \cdot x} + -1\right) \cdot \left(e^{a \cdot x} + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternatives

Alternative 1
Error	0.8
Cost	34372

\[\begin{array}{l} t_0 := e^{a \cdot x} + -1\\ \mathbf{if}\;a \cdot x \leq -1 \cdot 10^{-7}:\\ \;\;\;\;\frac{1}{t_0 \cdot \left(t_0 \cdot \frac{1}{t_0}\right)} \cdot \left(t_0 \cdot t_0\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternative 2
Error	0.8
Cost	20356

\[\begin{array}{l} t_0 := e^{a \cdot x}\\ \mathbf{if}\;a \cdot x \leq -1 \cdot 10^{-7}:\\ \;\;\;\;\frac{1}{t_0 + -1} \cdot {\left(t_0 - 1\right)}^{2}\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternative 3
Error	0.8
Cost	6980

\[\begin{array}{l} \mathbf{if}\;a \cdot x \leq -1 \cdot 10^{-7}:\\ \;\;\;\;e^{a \cdot x} - 1\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternative 4
Error	17.8
Cost	900

\[\begin{array}{l} \mathbf{if}\;a \cdot x \leq -2.4:\\ \;\;\;\;-\left(2 + \frac{1}{a \cdot x} \cdot 4\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternative 5
Error	17.8
Cost	452

\[\begin{array}{l} \mathbf{if}\;a \cdot x \leq -2:\\ \;\;\;\;-2\\ \mathbf{else}:\\ \;\;\;\;a \cdot x\\ \end{array} \]

Alternative 6
Error	58.5
Cost	64

\[-2 \]

Reproduce

herbie shell --seed 2023092 
(FPCore (a x)
  :name "expax (section 3.5)"
  :precision binary64

  :herbie-target
  (if (< (fabs (* a x)) 0.1) (* (* a x) (+ 1.0 (+ (/ (* a x) 2.0) (/ (pow (* a x) 2.0) 6.0)))) (- (exp (* a x)) 1.0))

  (- (exp (* a x)) 1.0))