exp-w (used to crash)

Percentage Accurate: 99.5% → 99.5%

Time: 13.8s

Alternatives: 19

Speedup: 1.0×

• could not determine a ground truth

  1. w = 2.00000000000000007e154
  2. l = -2

Specification

Math

\[\begin{array}{l} \\ e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (* (exp (- w)) (pow l (exp w))))

C

double code(double w, double l) {
	return exp(-w) * pow(l, exp(w));
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = exp(-w) * (l ** exp(w))
end function

Java

public static double code(double w, double l) {
	return Math.exp(-w) * Math.pow(l, Math.exp(w));
}

Python

def code(w, l):
	return math.exp(-w) * math.pow(l, math.exp(w))

Julia

function code(w, l)
	return Float64(exp(Float64(-w)) * (l ^ exp(w)))
end

MATLAB

function tmp = code(w, l)
	tmp = exp(-w) * (l ^ exp(w));
end

Wolfram

code[w_, l_] := N[(N[Exp[(-w)], $MachinePrecision] * N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (* (exp (- w)) (pow l (exp w))))

C

double code(double w, double l) {
	return exp(-w) * pow(l, exp(w));
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = exp(-w) * (l ** exp(w))
end function

Java

public static double code(double w, double l) {
	return Math.exp(-w) * Math.pow(l, Math.exp(w));
}

Python

def code(w, l):
	return math.exp(-w) * math.pow(l, math.exp(w))

Julia

function code(w, l)
	return Float64(exp(Float64(-w)) * (l ^ exp(w)))
end

MATLAB

function tmp = code(w, l)
	tmp = exp(-w) * (l ^ exp(w));
end

Wolfram

code[w_, l_] := N[(N[Exp[(-w)], $MachinePrecision] * N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (* (exp (- w)) (pow l (exp w))))

C

double code(double w, double l) {
	return exp(-w) * pow(l, exp(w));
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = exp(-w) * (l ** exp(w))
end function

Java

public static double code(double w, double l) {
	return Math.exp(-w) * Math.pow(l, Math.exp(w));
}

Python

def code(w, l):
	return math.exp(-w) * math.pow(l, math.exp(w))

Julia

function code(w, l)
	return Float64(exp(Float64(-w)) * (l ^ exp(w)))
end

MATLAB

function tmp = code(w, l)
	tmp = exp(-w) * (l ^ exp(w));
end

Wolfram

code[w_, l_] := N[(N[Exp[(-w)], $MachinePrecision] * N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 99.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{{\ell}^{\left(e^{w}\right)}}{e^{w}} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (/ (pow l (exp w)) (exp w)))

C

double code(double w, double l) {
	return pow(l, exp(w)) / exp(w);
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = (l ** exp(w)) / exp(w)
end function

Java

public static double code(double w, double l) {
	return Math.pow(l, Math.exp(w)) / Math.exp(w);
}

Python

def code(w, l):
	return math.pow(l, math.exp(w)) / math.exp(w)

Julia

function code(w, l)
	return Float64((l ^ exp(w)) / exp(w))
end

MATLAB

function tmp = code(w, l)
	tmp = (l ^ exp(w)) / exp(w);
end

Wolfram

code[w_, l_] := N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] / N[Exp[w], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Step-by-step derivation

   1. exp-neg 99.2%

      \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   2. remove-double-neg 99.2%

      \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   3. associate-*l/ 99.2%

      \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

   4. *-lft-identity 99.2%

      \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

   5. remove-double-neg 99.2%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
4. Add Preprocessing
5. Add Preprocessing

Alternative 3: 99.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -260:\\ \;\;\;\;\frac{\ell}{e^{w}}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + w \cdot 0.5\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -260.0)
   (/ l (exp w))
   (/ (pow l (exp w)) (+ 1.0 (* w (+ 1.0 (* w 0.5)))))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -260.0) {
		tmp = l / exp(w);
	} else {
		tmp = pow(l, exp(w)) / (1.0 + (w * (1.0 + (w * 0.5))));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-260.0d0)) then
        tmp = l / exp(w)
    else
        tmp = (l ** exp(w)) / (1.0d0 + (w * (1.0d0 + (w * 0.5d0))))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -260.0) {
		tmp = l / Math.exp(w);
	} else {
		tmp = Math.pow(l, Math.exp(w)) / (1.0 + (w * (1.0 + (w * 0.5))));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -260.0:
		tmp = l / math.exp(w)
	else:
		tmp = math.pow(l, math.exp(w)) / (1.0 + (w * (1.0 + (w * 0.5))))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -260.0)
		tmp = Float64(l / exp(w));
	else
		tmp = Float64((l ^ exp(w)) / Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * 0.5)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -260.0)
		tmp = l / exp(w);
	else
		tmp = (l ^ exp(w)) / (1.0 + (w * (1.0 + (w * 0.5))));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -260.0], N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision], N[(N[Power[l, N[Exp[w], $MachinePrecision]], $MachinePrecision] / N[(1.0 + N[(w * N[(1.0 + N[(w * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -260

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 100.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   if -260 < w

   1. Initial program 98.9%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 98.9%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 98.9%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 98.9%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 98.9%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 98.9%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.9%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w \cdot \left(1 + 0.5 \cdot w\right)}} \]
   6. Step-by-step derivation

      1. *-commutative 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + \color{blue}{w \cdot 0.5}\right)} \]

   7. Simplified 98.9%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w \cdot \left(1 + w \cdot 0.5\right)}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 99.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + w \cdot \left(1 + w \cdot 0.5\right)\\ \mathbf{if}\;w \leq -2:\\ \;\;\;\;\frac{\ell}{e^{w}}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\ell}^{t\_0}}{t\_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (let* ((t_0 (+ 1.0 (* w (+ 1.0 (* w 0.5))))))
   (if (<= w -2.0) (/ l (exp w)) (/ (pow l t_0) t_0))))

C

double code(double w, double l) {
	double t_0 = 1.0 + (w * (1.0 + (w * 0.5)));
	double tmp;
	if (w <= -2.0) {
		tmp = l / exp(w);
	} else {
		tmp = pow(l, t_0) / t_0;
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 1.0d0 + (w * (1.0d0 + (w * 0.5d0)))
    if (w <= (-2.0d0)) then
        tmp = l / exp(w)
    else
        tmp = (l ** t_0) / t_0
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double t_0 = 1.0 + (w * (1.0 + (w * 0.5)));
	double tmp;
	if (w <= -2.0) {
		tmp = l / Math.exp(w);
	} else {
		tmp = Math.pow(l, t_0) / t_0;
	}
	return tmp;
}

Python

def code(w, l):
	t_0 = 1.0 + (w * (1.0 + (w * 0.5)))
	tmp = 0
	if w <= -2.0:
		tmp = l / math.exp(w)
	else:
		tmp = math.pow(l, t_0) / t_0
	return tmp

Julia

function code(w, l)
	t_0 = Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * 0.5))))
	tmp = 0.0
	if (w <= -2.0)
		tmp = Float64(l / exp(w));
	else
		tmp = Float64((l ^ t_0) / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	t_0 = 1.0 + (w * (1.0 + (w * 0.5)));
	tmp = 0.0;
	if (w <= -2.0)
		tmp = l / exp(w);
	else
		tmp = (l ^ t_0) / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := Block[{t$95$0 = N[(1.0 + N[(w * N[(1.0 + N[(w * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[w, -2.0], N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision], N[(N[Power[l, t$95$0], $MachinePrecision] / t$95$0), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if w < -2

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.7%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   if -2 < w

   1. Initial program 98.9%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 98.9%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 98.9%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 98.9%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 98.9%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 98.9%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 99.3%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w \cdot \left(1 + 0.5 \cdot w\right)}} \]
   6. Step-by-step derivation

      1. *-commutative 99.3%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + \color{blue}{w \cdot 0.5}\right)} \]

   7. Simplified 99.3%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w \cdot \left(1 + w \cdot 0.5\right)}} \]

   8. Taylor expanded in w around 0 99.2%

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

      1. *-commutative 99.3%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + \color{blue}{w \cdot 0.5}\right)} \]

   10. Simplified 99.2%

       \[\leadsto \frac{{\ell}^{\color{blue}{\left(1 + w \cdot \left(1 + w \cdot 0.5\right)\right)}}}{1 + w \cdot \left(1 + w \cdot 0.5\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 99.1% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -1:\\ \;\;\;\;\frac{\ell}{e^{w}}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\ell}^{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)\right)}}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -1.0)
   (/ l (exp w))
   (/
    (pow l (+ 1.0 (* w (+ 1.0 (* w (+ 0.5 (* w 0.16666666666666666)))))))
    (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / exp(w);
	} else {
		tmp = pow(l, (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))) / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-1.0d0)) then
        tmp = l / exp(w)
    else
        tmp = (l ** (1.0d0 + (w * (1.0d0 + (w * (0.5d0 + (w * 0.16666666666666666d0))))))) / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / Math.exp(w);
	} else {
		tmp = Math.pow(l, (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))) / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -1.0:
		tmp = l / math.exp(w)
	else:
		tmp = math.pow(l, (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))) / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -1.0)
		tmp = Float64(l / exp(w));
	else
		tmp = Float64((l ^ Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * Float64(0.5 + Float64(w * 0.16666666666666666))))))) / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -1.0)
		tmp = l / exp(w);
	else
		tmp = (l ^ (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))) / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -1.0], N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision], N[(N[Power[l, N[(1.0 + N[(w * N[(1.0 + N[(w * N[(0.5 + N[(w * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -1

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.7%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   if -1 < w

   1. Initial program 98.9%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 98.9%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 98.9%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 98.9%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 98.9%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 98.9%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w}} \]
   6. Step-by-step derivation

      1. +-commutative 99.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   7. Simplified 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Taylor expanded in w around 0 99.0%

      \[\leadsto \frac{{\ell}^{\color{blue}{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + 0.16666666666666666 \cdot w\right)\right)\right)}}}{w + 1} \]
   9. Step-by-step derivation

      1. *-commutative 99.0%

         \[\leadsto \frac{{\ell}^{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + \color{blue}{w \cdot 0.16666666666666666}\right)\right)\right)}}{w + 1} \]

   10. Simplified 99.0%

       \[\leadsto \frac{{\ell}^{\color{blue}{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)\right)}}}{w + 1} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 99.1% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -1:\\ \;\;\;\;\frac{\ell}{e^{w}}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\ell}^{\left(1 + w \cdot \left(1 + w \cdot 0.5\right)\right)}}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -1.0)
   (/ l (exp w))
   (/ (pow l (+ 1.0 (* w (+ 1.0 (* w 0.5))))) (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / exp(w);
	} else {
		tmp = pow(l, (1.0 + (w * (1.0 + (w * 0.5))))) / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-1.0d0)) then
        tmp = l / exp(w)
    else
        tmp = (l ** (1.0d0 + (w * (1.0d0 + (w * 0.5d0))))) / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / Math.exp(w);
	} else {
		tmp = Math.pow(l, (1.0 + (w * (1.0 + (w * 0.5))))) / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -1.0:
		tmp = l / math.exp(w)
	else:
		tmp = math.pow(l, (1.0 + (w * (1.0 + (w * 0.5))))) / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -1.0)
		tmp = Float64(l / exp(w));
	else
		tmp = Float64((l ^ Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * 0.5))))) / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -1.0)
		tmp = l / exp(w);
	else
		tmp = (l ^ (1.0 + (w * (1.0 + (w * 0.5))))) / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -1.0], N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision], N[(N[Power[l, N[(1.0 + N[(w * N[(1.0 + N[(w * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -1

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.7%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   if -1 < w

   1. Initial program 98.9%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 98.9%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 98.9%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 98.9%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 98.9%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 98.9%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w}} \]
   6. Step-by-step derivation

      1. +-commutative 99.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   7. Simplified 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Taylor expanded in w around 0 99.0%

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

      1. *-commutative 99.3%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + \color{blue}{w \cdot 0.5}\right)} \]

   10. Simplified 99.0%

       \[\leadsto \frac{{\ell}^{\color{blue}{\left(1 + w \cdot \left(1 + w \cdot 0.5\right)\right)}}}{w + 1} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 98.9% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -1:\\ \;\;\;\;\frac{\ell}{e^{w}}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\ell}^{\left(w + 1\right)}}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -1.0) (/ l (exp w)) (/ (pow l (+ w 1.0)) (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / exp(w);
	} else {
		tmp = pow(l, (w + 1.0)) / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-1.0d0)) then
        tmp = l / exp(w)
    else
        tmp = (l ** (w + 1.0d0)) / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -1.0) {
		tmp = l / Math.exp(w);
	} else {
		tmp = Math.pow(l, (w + 1.0)) / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -1.0:
		tmp = l / math.exp(w)
	else:
		tmp = math.pow(l, (w + 1.0)) / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -1.0)
		tmp = Float64(l / exp(w));
	else
		tmp = Float64((l ^ Float64(w + 1.0)) / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -1.0)
		tmp = l / exp(w);
	else
		tmp = (l ^ (w + 1.0)) / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -1.0], N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision], N[(N[Power[l, N[(w + 1.0), $MachinePrecision]], $MachinePrecision] / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -1

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.7%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   if -1 < w

   1. Initial program 98.9%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 98.9%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 98.9%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 98.9%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 98.9%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 98.9%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 98.9%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{1 + w}} \]
   6. Step-by-step derivation

      1. +-commutative 99.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   7. Simplified 99.0%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Taylor expanded in w around 0 98.6%

      \[\leadsto \frac{{\ell}^{\color{blue}{\left(1 + w\right)}}}{w + 1} \]
   9. Step-by-step derivation

      1. +-commutative 99.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   10. Simplified 98.6%

       \[\leadsto \frac{{\ell}^{\color{blue}{\left(w + 1\right)}}}{w + 1} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 8: 98.0% accurate, 2.9× speedup

Math

\[\begin{array}{l} \\ \ell \cdot \frac{1}{e^{w}} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (* l (/ 1.0 (exp w))))

C

double code(double w, double l) {
	return l * (1.0 / exp(w));
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = l * (1.0d0 / exp(w))
end function

Java

public static double code(double w, double l) {
	return l * (1.0 / Math.exp(w));
}

Python

def code(w, l):
	return l * (1.0 / math.exp(w))

Julia

function code(w, l)
	return Float64(l * Float64(1.0 / exp(w)))
end

MATLAB

function tmp = code(w, l)
	tmp = l * (1.0 / exp(w));
end

Wolfram

code[w_, l_] := N[(l * N[(1.0 / N[Exp[w], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Step-by-step derivation

   1. exp-neg 99.2%

      \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   2. remove-double-neg 99.2%

      \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   3. associate-*l/ 99.2%

      \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

   4. *-lft-identity 99.2%

      \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

   5. remove-double-neg 99.2%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
4. Add Preprocessing

5. Taylor expanded in w around 0 96.9%

   \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
6. Step-by-step derivation

   1. frac-2neg 96.9%

      \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

   2. div-inv 96.9%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

7. Applied egg-rr 96.9%

   \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

8. Final simplification 96.9%

   \[\leadsto \ell \cdot \frac{1}{e^{w}} \]
9. Add Preprocessing

Alternative 9: 98.0% accurate, 3.0× speedup

Math

\[\begin{array}{l} \\ \frac{\ell}{e^{w}} \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (/ l (exp w)))

C

double code(double w, double l) {
	return l / exp(w);
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = l / exp(w)
end function

Java

public static double code(double w, double l) {
	return l / Math.exp(w);
}

Python

def code(w, l):
	return l / math.exp(w)

Julia

function code(w, l)
	return Float64(l / exp(w))
end

MATLAB

function tmp = code(w, l)
	tmp = l / exp(w);
end

Wolfram

code[w_, l_] := N[(l / N[Exp[w], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Step-by-step derivation

   1. exp-neg 99.2%

      \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   2. remove-double-neg 99.2%

      \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   3. associate-*l/ 99.2%

      \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

   4. *-lft-identity 99.2%

      \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

   5. remove-double-neg 99.2%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
4. Add Preprocessing

5. Taylor expanded in w around 0 96.9%

   \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
6. Add Preprocessing

Alternative 10: 89.2% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -5 \cdot 10^{-13}:\\ \;\;\;\;\ell \cdot \left(w \cdot \left(-1 + w \cdot \left(0.5 - w \cdot 0.16666666666666666\right)\right) - -1\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -5e-13)
   (* l (- (* w (+ -1.0 (* w (- 0.5 (* w 0.16666666666666666))))) -1.0))
   (/ l (+ 1.0 (* w (+ 1.0 (* w (+ 0.5 (* w 0.16666666666666666)))))))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -5e-13) {
		tmp = l * ((w * (-1.0 + (w * (0.5 - (w * 0.16666666666666666))))) - -1.0);
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-5d-13)) then
        tmp = l * ((w * ((-1.0d0) + (w * (0.5d0 - (w * 0.16666666666666666d0))))) - (-1.0d0))
    else
        tmp = l / (1.0d0 + (w * (1.0d0 + (w * (0.5d0 + (w * 0.16666666666666666d0))))))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -5e-13) {
		tmp = l * ((w * (-1.0 + (w * (0.5 - (w * 0.16666666666666666))))) - -1.0);
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -5e-13:
		tmp = l * ((w * (-1.0 + (w * (0.5 - (w * 0.16666666666666666))))) - -1.0)
	else:
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -5e-13)
		tmp = Float64(l * Float64(Float64(w * Float64(-1.0 + Float64(w * Float64(0.5 - Float64(w * 0.16666666666666666))))) - -1.0));
	else
		tmp = Float64(l / Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * Float64(0.5 + Float64(w * 0.16666666666666666)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -5e-13)
		tmp = l * ((w * (-1.0 + (w * (0.5 - (w * 0.16666666666666666))))) - -1.0);
	else
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -5e-13], N[(l * N[(N[(w * N[(-1.0 + N[(w * N[(0.5 - N[(w * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision], N[(l / N[(1.0 + N[(w * N[(1.0 + N[(w * N[(0.5 + N[(w * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -4.9999999999999999e-13

   1. Initial program 99.2%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.2%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.2%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.2%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.2%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.2%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.2%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 94.1%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 94.1%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 94.1%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 94.1%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 75.3%

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

   if -4.9999999999999999e-13 < w

   1. Initial program 99.2%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.2%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.2%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.2%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.2%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.2%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.2%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.2%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 95.6%

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

      1. *-commutative 99.6%

         \[\leadsto \frac{{\ell}^{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + \color{blue}{w \cdot 0.16666666666666666}\right)\right)\right)}}{w + 1} \]

   8. Simplified 95.6%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 89.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq -5 \cdot 10^{-13}:\\ \;\;\;\;\ell \cdot \left(w \cdot \left(-1 + w \cdot \left(0.5 - w \cdot 0.16666666666666666\right)\right) - -1\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 85.7% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq 520000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w 520000000.0)
   (* l (+ 1.0 (* w (+ (* w 0.5) -1.0))))
   (/ l (+ 1.0 (* w (+ 1.0 (* w (+ 0.5 (* w 0.16666666666666666)))))))))

C

double code(double w, double l) {
	double tmp;
	if (w <= 520000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= 520000000.0d0) then
        tmp = l * (1.0d0 + (w * ((w * 0.5d0) + (-1.0d0))))
    else
        tmp = l / (1.0d0 + (w * (1.0d0 + (w * (0.5d0 + (w * 0.16666666666666666d0))))))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= 520000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= 520000000.0:
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)))
	else:
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= 520000000.0)
		tmp = Float64(l * Float64(1.0 + Float64(w * Float64(Float64(w * 0.5) + -1.0))));
	else
		tmp = Float64(l / Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * Float64(0.5 + Float64(w * 0.16666666666666666)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= 520000000.0)
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	else
		tmp = l / (1.0 + (w * (1.0 + (w * (0.5 + (w * 0.16666666666666666))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, 520000000.0], N[(l * N[(1.0 + N[(w * N[(N[(w * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(l / N[(1.0 + N[(w * N[(1.0 + N[(w * N[(0.5 + N[(w * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < 5.2e8

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in w around 0 86.4%

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

   4. Taylor expanded in w around 0 87.5%

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

   if 5.2e8 < w

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 100.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 85.5%

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

      1. *-commutative 100.0%

         \[\leadsto \frac{{\ell}^{\left(1 + w \cdot \left(1 + w \cdot \left(0.5 + \color{blue}{w \cdot 0.16666666666666666}\right)\right)\right)}}{w + 1} \]

   8. Simplified 85.5%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 87.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq 520000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot \left(0.5 + w \cdot 0.16666666666666666\right)\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 84.3% accurate, 16.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq 720000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\ell \cdot \frac{-1}{-1 + w \cdot \left(-1 + w \cdot -0.5\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w 720000000.0)
   (* l (+ 1.0 (* w (+ (* w 0.5) -1.0))))
   (* l (/ -1.0 (+ -1.0 (* w (+ -1.0 (* w -0.5))))))))

C

double code(double w, double l) {
	double tmp;
	if (w <= 720000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l * (-1.0 / (-1.0 + (w * (-1.0 + (w * -0.5)))));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= 720000000.0d0) then
        tmp = l * (1.0d0 + (w * ((w * 0.5d0) + (-1.0d0))))
    else
        tmp = l * ((-1.0d0) / ((-1.0d0) + (w * ((-1.0d0) + (w * (-0.5d0))))))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= 720000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l * (-1.0 / (-1.0 + (w * (-1.0 + (w * -0.5)))));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= 720000000.0:
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)))
	else:
		tmp = l * (-1.0 / (-1.0 + (w * (-1.0 + (w * -0.5)))))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= 720000000.0)
		tmp = Float64(l * Float64(1.0 + Float64(w * Float64(Float64(w * 0.5) + -1.0))));
	else
		tmp = Float64(l * Float64(-1.0 / Float64(-1.0 + Float64(w * Float64(-1.0 + Float64(w * -0.5))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= 720000000.0)
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	else
		tmp = l * (-1.0 / (-1.0 + (w * (-1.0 + (w * -0.5)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, 720000000.0], N[(l * N[(1.0 + N[(w * N[(N[(w * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(l * N[(-1.0 / N[(-1.0 + N[(w * N[(-1.0 + N[(w * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < 7.2e8

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in w around 0 86.4%

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

   4. Taylor expanded in w around 0 87.5%

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

   if 7.2e8 < w

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 100.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 100.0%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 100.0%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 100.0%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 79.4%

      \[\leadsto \left(-\ell\right) \cdot \frac{1}{\color{blue}{w \cdot \left(-0.5 \cdot w - 1\right) - 1}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 86.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq 720000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\ell \cdot \frac{-1}{-1 + w \cdot \left(-1 + w \cdot -0.5\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 84.3% accurate, 19.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq 510000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot 0.5\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w 510000000.0)
   (* l (+ 1.0 (* w (+ (* w 0.5) -1.0))))
   (/ l (+ 1.0 (* w (+ 1.0 (* w 0.5)))))))

C

double code(double w, double l) {
	double tmp;
	if (w <= 510000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * 0.5))));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= 510000000.0d0) then
        tmp = l * (1.0d0 + (w * ((w * 0.5d0) + (-1.0d0))))
    else
        tmp = l / (1.0d0 + (w * (1.0d0 + (w * 0.5d0))))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= 510000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (1.0 + (w * (1.0 + (w * 0.5))));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= 510000000.0:
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)))
	else:
		tmp = l / (1.0 + (w * (1.0 + (w * 0.5))))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= 510000000.0)
		tmp = Float64(l * Float64(1.0 + Float64(w * Float64(Float64(w * 0.5) + -1.0))));
	else
		tmp = Float64(l / Float64(1.0 + Float64(w * Float64(1.0 + Float64(w * 0.5)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= 510000000.0)
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	else
		tmp = l / (1.0 + (w * (1.0 + (w * 0.5))));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, 510000000.0], N[(l * N[(1.0 + N[(w * N[(N[(w * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(l / N[(1.0 + N[(w * N[(1.0 + N[(w * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < 5.1e8

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in w around 0 86.4%

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

   4. Taylor expanded in w around 0 87.5%

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

   if 5.1e8 < w

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 100.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 79.4%

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

      1. *-commutative 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{1 + w \cdot \left(1 + \color{blue}{w \cdot 0.5}\right)} \]

   8. Simplified 79.4%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w \cdot \left(1 + w \cdot 0.5\right)}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 86.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq 510000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{1 + w \cdot \left(1 + w \cdot 0.5\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 80.7% accurate, 19.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq 500000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w 500000000.0)
   (* l (+ 1.0 (* w (+ (* w 0.5) -1.0))))
   (/ l (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= 500000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= 500000000.0d0) then
        tmp = l * (1.0d0 + (w * ((w * 0.5d0) + (-1.0d0))))
    else
        tmp = l / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= 500000000.0) {
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= 500000000.0:
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)))
	else:
		tmp = l / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= 500000000.0)
		tmp = Float64(l * Float64(1.0 + Float64(w * Float64(Float64(w * 0.5) + -1.0))));
	else
		tmp = Float64(l / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= 500000000.0)
		tmp = l * (1.0 + (w * ((w * 0.5) + -1.0)));
	else
		tmp = l / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, 500000000.0], N[(l * N[(1.0 + N[(w * N[(N[(w * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(l / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < 5e8

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in w around 0 86.4%

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

   4. Taylor expanded in w around 0 87.5%

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

   if 5e8 < w

   1. Initial program 100.0%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 100.0%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 100.0%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 100.0%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 100.0%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 100.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 67.7%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w}} \]
   7. Step-by-step derivation

      1. +-commutative 100.0%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Simplified 67.7%

      \[\leadsto \frac{\ell}{\color{blue}{w + 1}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 85.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq 500000000:\\ \;\;\;\;\ell \cdot \left(1 + w \cdot \left(w \cdot 0.5 + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{w + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 70.5% accurate, 25.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -4 \cdot 10^{-8}:\\ \;\;\;\;\ell - w \cdot \ell\\ \mathbf{else}:\\ \;\;\;\;\ell \cdot \frac{1}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -4e-8) (- l (* w l)) (* l (/ 1.0 (+ w 1.0)))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -4e-8) {
		tmp = l - (w * l);
	} else {
		tmp = l * (1.0 / (w + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-4d-8)) then
        tmp = l - (w * l)
    else
        tmp = l * (1.0d0 / (w + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -4e-8) {
		tmp = l - (w * l);
	} else {
		tmp = l * (1.0 / (w + 1.0));
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -4e-8:
		tmp = l - (w * l)
	else:
		tmp = l * (1.0 / (w + 1.0))
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -4e-8)
		tmp = Float64(l - Float64(w * l));
	else
		tmp = Float64(l * Float64(1.0 / Float64(w + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -4e-8)
		tmp = l - (w * l);
	else
		tmp = l * (1.0 / (w + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -4e-8], N[(l - N[(w * l), $MachinePrecision]), $MachinePrecision], N[(l * N[(1.0 / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -4.0000000000000001e-8

   1. Initial program 99.4%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.3%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.3%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.4%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.4%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.4%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.4%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 94.4%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 94.4%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 94.4%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 94.4%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 27.9%

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

      1. mul-1-neg 27.9%

         \[\leadsto \ell + \color{blue}{\left(-\ell \cdot w\right)} \]

      2. unsub-neg 27.9%

         \[\leadsto \color{blue}{\ell - \ell \cdot w} \]

      3. *-commutative 27.9%

         \[\leadsto \ell - \color{blue}{w \cdot \ell} \]

   10. Simplified 27.9%

       \[\leadsto \color{blue}{\ell - w \cdot \ell} \]

   if -4.0000000000000001e-8 < w

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.1%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.1%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.1%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.1%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.1%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.1%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 98.0%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 98.0%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 98.0%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 92.3%

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

      1. +-commutative 99.5%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   10. Simplified 92.3%

       \[\leadsto \left(-\ell\right) \cdot \frac{1}{-\color{blue}{\left(w + 1\right)}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq -4 \cdot 10^{-8}:\\ \;\;\;\;\ell - w \cdot \ell\\ \mathbf{else}:\\ \;\;\;\;\ell \cdot \frac{1}{w + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 70.5% accurate, 27.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -1 \cdot 10^{-13}:\\ \;\;\;\;\ell \cdot \left(\left(--1\right) - w\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -1e-13) (* l (- (- -1.0) w)) (/ l (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -1e-13) {
		tmp = l * (-(-1.0) - w);
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-1d-13)) then
        tmp = l * (-(-1.0d0) - w)
    else
        tmp = l / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -1e-13) {
		tmp = l * (-(-1.0) - w);
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -1e-13:
		tmp = l * (-(-1.0) - w)
	else:
		tmp = l / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -1e-13)
		tmp = Float64(l * Float64(Float64(-(-1.0)) - w));
	else
		tmp = Float64(l / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -1e-13)
		tmp = l * (-(-1.0) - w);
	else
		tmp = l / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -1e-13], N[(l * N[((--1.0) - w), $MachinePrecision]), $MachinePrecision], N[(l / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -1e-13

   1. Initial program 99.2%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.2%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.2%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.2%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.2%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.2%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.2%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 94.1%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 94.1%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 94.1%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 94.1%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 28.4%

      \[\leadsto \left(-\ell\right) \cdot \color{blue}{\left(w - 1\right)} \]

   if -1e-13 < w

   1. Initial program 99.2%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.2%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.2%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.2%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.2%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.2%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.2%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.2%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 92.4%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w}} \]
   7. Step-by-step derivation

      1. +-commutative 99.6%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Simplified 92.4%

      \[\leadsto \frac{\ell}{\color{blue}{w + 1}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;w \leq -1 \cdot 10^{-13}:\\ \;\;\;\;\ell \cdot \left(\left(--1\right) - w\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{w + 1}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 70.5% accurate, 30.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;w \leq -1 \cdot 10^{-10}:\\ \;\;\;\;\ell - w \cdot \ell\\ \mathbf{else}:\\ \;\;\;\;\frac{\ell}{w + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (w l)
 :precision binary64
 (if (<= w -1e-10) (- l (* w l)) (/ l (+ w 1.0))))

C

double code(double w, double l) {
	double tmp;
	if (w <= -1e-10) {
		tmp = l - (w * l);
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    real(8) :: tmp
    if (w <= (-1d-10)) then
        tmp = l - (w * l)
    else
        tmp = l / (w + 1.0d0)
    end if
    code = tmp
end function

Java

public static double code(double w, double l) {
	double tmp;
	if (w <= -1e-10) {
		tmp = l - (w * l);
	} else {
		tmp = l / (w + 1.0);
	}
	return tmp;
}

Python

def code(w, l):
	tmp = 0
	if w <= -1e-10:
		tmp = l - (w * l)
	else:
		tmp = l / (w + 1.0)
	return tmp

Julia

function code(w, l)
	tmp = 0.0
	if (w <= -1e-10)
		tmp = Float64(l - Float64(w * l));
	else
		tmp = Float64(l / Float64(w + 1.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(w, l)
	tmp = 0.0;
	if (w <= -1e-10)
		tmp = l - (w * l);
	else
		tmp = l / (w + 1.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[w_, l_] := If[LessEqual[w, -1e-10], N[(l - N[(w * l), $MachinePrecision]), $MachinePrecision], N[(l / N[(w + 1.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if w < -1.00000000000000004e-10

   1. Initial program 99.4%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.3%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.3%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.4%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.4%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.4%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.4%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 94.4%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
   6. Step-by-step derivation

      1. frac-2neg 94.4%

         \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

      2. div-inv 94.4%

         \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   7. Applied egg-rr 94.4%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

   8. Taylor expanded in w around 0 27.9%

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

      1. mul-1-neg 27.9%

         \[\leadsto \ell + \color{blue}{\left(-\ell \cdot w\right)} \]

      2. unsub-neg 27.9%

         \[\leadsto \color{blue}{\ell - \ell \cdot w} \]

      3. *-commutative 27.9%

         \[\leadsto \ell - \color{blue}{w \cdot \ell} \]

   10. Simplified 27.9%

       \[\leadsto \color{blue}{\ell - w \cdot \ell} \]

   if -1.00000000000000004e-10 < w

   1. Initial program 99.1%

      \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
   2. Step-by-step derivation

      1. exp-neg 99.1%

         \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      2. remove-double-neg 99.1%

         \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

      3. associate-*l/ 99.1%

         \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

      4. *-lft-identity 99.1%

         \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

      5. remove-double-neg 99.1%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

   3. Simplified 99.1%

      \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
   4. Add Preprocessing

   5. Taylor expanded in w around 0 98.0%

      \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

   6. Taylor expanded in w around 0 92.3%

      \[\leadsto \frac{\ell}{\color{blue}{1 + w}} \]
   7. Step-by-step derivation

      1. +-commutative 99.5%

         \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{\color{blue}{w + 1}} \]

   8. Simplified 92.3%

      \[\leadsto \frac{\ell}{\color{blue}{w + 1}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 63.3% accurate, 61.0× speedup

Math

\[\begin{array}{l} \\ \ell - w \cdot \ell \end{array} \]

FPCore

(FPCore (w l) :precision binary64 (- l (* w l)))

C

double code(double w, double l) {
	return l - (w * l);
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = l - (w * l)
end function

Java

public static double code(double w, double l) {
	return l - (w * l);
}

Python

def code(w, l):
	return l - (w * l)

Julia

function code(w, l)
	return Float64(l - Float64(w * l))
end

MATLAB

function tmp = code(w, l)
	tmp = l - (w * l);
end

Wolfram

code[w_, l_] := N[(l - N[(w * l), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Step-by-step derivation

   1. exp-neg 99.2%

      \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   2. remove-double-neg 99.2%

      \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   3. associate-*l/ 99.2%

      \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

   4. *-lft-identity 99.2%

      \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

   5. remove-double-neg 99.2%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
4. Add Preprocessing

5. Taylor expanded in w around 0 96.9%

   \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]
6. Step-by-step derivation

   1. frac-2neg 96.9%

      \[\leadsto \color{blue}{\frac{-\ell}{-e^{w}}} \]

   2. div-inv 96.9%

      \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

7. Applied egg-rr 96.9%

   \[\leadsto \color{blue}{\left(-\ell\right) \cdot \frac{1}{-e^{w}}} \]

8. Taylor expanded in w around 0 65.1%

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

   1. mul-1-neg 65.1%

      \[\leadsto \ell + \color{blue}{\left(-\ell \cdot w\right)} \]

   2. unsub-neg 65.1%

      \[\leadsto \color{blue}{\ell - \ell \cdot w} \]

   3. *-commutative 65.1%

      \[\leadsto \ell - \color{blue}{w \cdot \ell} \]

10. Simplified 65.1%

    \[\leadsto \color{blue}{\ell - w \cdot \ell} \]
11. Add Preprocessing

Alternative 19: 56.4% accurate, 305.0× speedup

Math

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

FPCore

(FPCore (w l) :precision binary64 l)

C

double code(double w, double l) {
	return l;
}

Fortran

real(8) function code(w, l)
    real(8), intent (in) :: w
    real(8), intent (in) :: l
    code = l
end function

Java

public static double code(double w, double l) {
	return l;
}

Python

def code(w, l):
	return l

Julia

function code(w, l)
	return l
end

MATLAB

function tmp = code(w, l)
	tmp = l;
end

Wolfram

code[w_, l_] := l

Derivation

1. Initial program 99.2%

   \[e^{-w} \cdot {\ell}^{\left(e^{w}\right)} \]
2. Step-by-step derivation

   1. exp-neg 99.2%

      \[\leadsto \color{blue}{\frac{1}{e^{w}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   2. remove-double-neg 99.2%

      \[\leadsto \frac{1}{e^{\color{blue}{-\left(-w\right)}}} \cdot {\ell}^{\left(e^{w}\right)} \]

   3. associate-*l/ 99.2%

      \[\leadsto \color{blue}{\frac{1 \cdot {\ell}^{\left(e^{w}\right)}}{e^{-\left(-w\right)}}} \]

   4. *-lft-identity 99.2%

      \[\leadsto \frac{\color{blue}{{\ell}^{\left(e^{w}\right)}}}{e^{-\left(-w\right)}} \]

   5. remove-double-neg 99.2%

      \[\leadsto \frac{{\ell}^{\left(e^{w}\right)}}{e^{\color{blue}{w}}} \]

3. Simplified 99.2%

   \[\leadsto \color{blue}{\frac{{\ell}^{\left(e^{w}\right)}}{e^{w}}} \]
4. Add Preprocessing

5. Taylor expanded in w around 0 96.9%

   \[\leadsto \frac{\color{blue}{\ell}}{e^{w}} \]

6. Taylor expanded in w around 0 58.8%

   \[\leadsto \color{blue}{\ell} \]
7. Add Preprocessing

Reproduce

herbie shell --seed 2024112 
(FPCore (w l)
  :name "exp-w (used to crash)"
  :precision binary64
  (* (exp (- w)) (pow l (exp w))))