Quotient of sum of exps

Percentage Accurate: 99.0% → 99.0%

Time: 10.9s

Alternatives: 14

Speedup: 1.0×

• could not determine a ground truth

  1. a = -2.00000000000000007e154
  2. b = -2.00000000000000007e154

Specification

Math

\[\begin{array}{l} \\ \frac{e^{a}}{e^{a} + e^{b}} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ (exp a) (+ (exp a) (exp b))))

C

double code(double a, double b) {
	return exp(a) / (exp(a) + exp(b));
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = exp(a) / (exp(a) + exp(b))
end function

Java

public static double code(double a, double b) {
	return Math.exp(a) / (Math.exp(a) + Math.exp(b));
}

Python

def code(a, b):
	return math.exp(a) / (math.exp(a) + math.exp(b))

Julia

function code(a, b)
	return Float64(exp(a) / Float64(exp(a) + exp(b)))
end

MATLAB

function tmp = code(a, b)
	tmp = exp(a) / (exp(a) + exp(b));
end

Wolfram

code[a_, b_] := N[(N[Exp[a], $MachinePrecision] / N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 99.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{e^{a}}{e^{a} + e^{b}} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ (exp a) (+ (exp a) (exp b))))

C

double code(double a, double b) {
	return exp(a) / (exp(a) + exp(b));
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = exp(a) / (exp(a) + exp(b))
end function

Java

public static double code(double a, double b) {
	return Math.exp(a) / (Math.exp(a) + Math.exp(b));
}

Python

def code(a, b):
	return math.exp(a) / (math.exp(a) + math.exp(b))

Julia

function code(a, b)
	return Float64(exp(a) / Float64(exp(a) + exp(b)))
end

MATLAB

function tmp = code(a, b)
	tmp = exp(a) / (exp(a) + exp(b));
end

Wolfram

code[a_, b_] := N[(N[Exp[a], $MachinePrecision] / N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{1}{\frac{e^{a} + e^{b}}{e^{a}}} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ 1.0 (/ (+ (exp a) (exp b)) (exp a))))

C

double code(double a, double b) {
	return 1.0 / ((exp(a) + exp(b)) / exp(a));
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = 1.0d0 / ((exp(a) + exp(b)) / exp(a))
end function

Java

public static double code(double a, double b) {
	return 1.0 / ((Math.exp(a) + Math.exp(b)) / Math.exp(a));
}

Python

def code(a, b):
	return 1.0 / ((math.exp(a) + math.exp(b)) / math.exp(a))

Julia

function code(a, b)
	return Float64(1.0 / Float64(Float64(exp(a) + exp(b)) / exp(a)))
end

MATLAB

function tmp = code(a, b)
	tmp = 1.0 / ((exp(a) + exp(b)) / exp(a));
end

Wolfram

code[a_, b_] := N[(1.0 / N[(N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision] / N[Exp[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.6%

   \[\frac{e^{a}}{e^{a} + e^{b}} \]
2. Add Preprocessing

4. Applied egg-rr 0

   \[\leadsto expr\]
5. Add Preprocessing

Alternative 2: 98.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{a} \leq 0:\\ \;\;\;\;\frac{e^{a}}{2}\\ \mathbf{else}:\\ \;\;\;\;e^{-\mathsf{log1p}\left(e^{b}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= (exp a) 0.0) (/ (exp a) 2.0) (exp (- (log1p (exp b))))))

C

double code(double a, double b) {
	double tmp;
	if (exp(a) <= 0.0) {
		tmp = exp(a) / 2.0;
	} else {
		tmp = exp(-log1p(exp(b)));
	}
	return tmp;
}

Java

public static double code(double a, double b) {
	double tmp;
	if (Math.exp(a) <= 0.0) {
		tmp = Math.exp(a) / 2.0;
	} else {
		tmp = Math.exp(-Math.log1p(Math.exp(b)));
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if math.exp(a) <= 0.0:
		tmp = math.exp(a) / 2.0
	else:
		tmp = math.exp(-math.log1p(math.exp(b)))
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (exp(a) <= 0.0)
		tmp = Float64(exp(a) / 2.0);
	else
		tmp = exp(Float64(-log1p(exp(b))));
	end
	return tmp
end

Wolfram

code[a_, b_] := If[LessEqual[N[Exp[a], $MachinePrecision], 0.0], N[(N[Exp[a], $MachinePrecision] / 2.0), $MachinePrecision], N[Exp[(-N[Log[1 + N[Exp[b], $MachinePrecision]], $MachinePrecision])], $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (exp.f64 a) < 0.0

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 0.0 < (exp.f64 a)

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 99.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{e^{a}}{e^{a} + e^{b}} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ (exp a) (+ (exp a) (exp b))))

C

double code(double a, double b) {
	return exp(a) / (exp(a) + exp(b));
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = exp(a) / (exp(a) + exp(b))
end function

Java

public static double code(double a, double b) {
	return Math.exp(a) / (Math.exp(a) + Math.exp(b));
}

Python

def code(a, b):
	return math.exp(a) / (math.exp(a) + math.exp(b))

Julia

function code(a, b)
	return Float64(exp(a) / Float64(exp(a) + exp(b)))
end

MATLAB

function tmp = code(a, b)
	tmp = exp(a) / (exp(a) + exp(b));
end

Wolfram

code[a_, b_] := N[(N[Exp[a], $MachinePrecision] / N[(N[Exp[a], $MachinePrecision] + N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.6%

   \[\frac{e^{a}}{e^{a} + e^{b}} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 4: 98.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{a} \leq 0:\\ \;\;\;\;\frac{e^{a}}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{1 + e^{b}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= (exp a) 0.0) (/ (exp a) 2.0) (/ 1.0 (+ 1.0 (exp b)))))

C

double code(double a, double b) {
	double tmp;
	if (exp(a) <= 0.0) {
		tmp = exp(a) / 2.0;
	} else {
		tmp = 1.0 / (1.0 + exp(b));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (exp(a) <= 0.0d0) then
        tmp = exp(a) / 2.0d0
    else
        tmp = 1.0d0 / (1.0d0 + exp(b))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double tmp;
	if (Math.exp(a) <= 0.0) {
		tmp = Math.exp(a) / 2.0;
	} else {
		tmp = 1.0 / (1.0 + Math.exp(b));
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if math.exp(a) <= 0.0:
		tmp = math.exp(a) / 2.0
	else:
		tmp = 1.0 / (1.0 + math.exp(b))
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (exp(a) <= 0.0)
		tmp = Float64(exp(a) / 2.0);
	else
		tmp = Float64(1.0 / Float64(1.0 + exp(b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	tmp = 0.0;
	if (exp(a) <= 0.0)
		tmp = exp(a) / 2.0;
	else
		tmp = 1.0 / (1.0 + exp(b));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := If[LessEqual[N[Exp[a], $MachinePrecision], 0.0], N[(N[Exp[a], $MachinePrecision] / 2.0), $MachinePrecision], N[(1.0 / N[(1.0 + N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (exp.f64 a) < 0.0

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 0.0 < (exp.f64 a)

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 62.4% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 + b \cdot 0.16666666666666666\\ t_1 := b \cdot t\_0\\ t_2 := t\_1 \cdot \left(\left(b \cdot b\right) \cdot \left(t\_0 \cdot t\_0\right)\right)\\ \mathbf{if}\;b \leq 2.1 \cdot 10^{-44}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{elif}\;b \leq 1.65 \cdot 10^{+31}:\\ \;\;\;\;\frac{1}{2 + \frac{\left(1 - t\_2 \cdot t\_2\right) \cdot b}{\left(1 - t\_2\right) \cdot \left(1 + b \cdot \left(t\_0 \cdot \left(t\_1 + -1\right)\right)\right)}}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{2 + \frac{\left(1 + t\_1 \cdot \left(b \cdot \left(t\_0 \cdot t\_1\right)\right)\right) \cdot b}{1 + -0.5 \cdot b}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (let* ((t_0 (+ 0.5 (* b 0.16666666666666666)))
        (t_1 (* b t_0))
        (t_2 (* t_1 (* (* b b) (* t_0 t_0)))))
   (if (<= b 2.1e-44)
     (+ 0.5 (* a 0.25))
     (if (<= b 1.65e+31)
       (/
        1.0
        (+
         2.0
         (/
          (* (- 1.0 (* t_2 t_2)) b)
          (* (- 1.0 t_2) (+ 1.0 (* b (* t_0 (+ t_1 -1.0))))))))
       (/
        1.0
        (+
         2.0
         (/ (* (+ 1.0 (* t_1 (* b (* t_0 t_1)))) b) (+ 1.0 (* -0.5 b)))))))))

C

double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double t_2 = t_1 * ((b * b) * (t_0 * t_0));
	double tmp;
	if (b <= 2.1e-44) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1.65e+31) {
		tmp = 1.0 / (2.0 + (((1.0 - (t_2 * t_2)) * b) / ((1.0 - t_2) * (1.0 + (b * (t_0 * (t_1 + -1.0)))))));
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = 0.5d0 + (b * 0.16666666666666666d0)
    t_1 = b * t_0
    t_2 = t_1 * ((b * b) * (t_0 * t_0))
    if (b <= 2.1d-44) then
        tmp = 0.5d0 + (a * 0.25d0)
    else if (b <= 1.65d+31) then
        tmp = 1.0d0 / (2.0d0 + (((1.0d0 - (t_2 * t_2)) * b) / ((1.0d0 - t_2) * (1.0d0 + (b * (t_0 * (t_1 + (-1.0d0))))))))
    else
        tmp = 1.0d0 / (2.0d0 + (((1.0d0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0d0 + ((-0.5d0) * b))))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double t_2 = t_1 * ((b * b) * (t_0 * t_0));
	double tmp;
	if (b <= 2.1e-44) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1.65e+31) {
		tmp = 1.0 / (2.0 + (((1.0 - (t_2 * t_2)) * b) / ((1.0 - t_2) * (1.0 + (b * (t_0 * (t_1 + -1.0)))))));
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = 0.5 + (b * 0.16666666666666666)
	t_1 = b * t_0
	t_2 = t_1 * ((b * b) * (t_0 * t_0))
	tmp = 0
	if b <= 2.1e-44:
		tmp = 0.5 + (a * 0.25)
	elif b <= 1.65e+31:
		tmp = 1.0 / (2.0 + (((1.0 - (t_2 * t_2)) * b) / ((1.0 - t_2) * (1.0 + (b * (t_0 * (t_1 + -1.0)))))))
	else:
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))))
	return tmp

Julia

function code(a, b)
	t_0 = Float64(0.5 + Float64(b * 0.16666666666666666))
	t_1 = Float64(b * t_0)
	t_2 = Float64(t_1 * Float64(Float64(b * b) * Float64(t_0 * t_0)))
	tmp = 0.0
	if (b <= 2.1e-44)
		tmp = Float64(0.5 + Float64(a * 0.25));
	elseif (b <= 1.65e+31)
		tmp = Float64(1.0 / Float64(2.0 + Float64(Float64(Float64(1.0 - Float64(t_2 * t_2)) * b) / Float64(Float64(1.0 - t_2) * Float64(1.0 + Float64(b * Float64(t_0 * Float64(t_1 + -1.0))))))));
	else
		tmp = Float64(1.0 / Float64(2.0 + Float64(Float64(Float64(1.0 + Float64(t_1 * Float64(b * Float64(t_0 * t_1)))) * b) / Float64(1.0 + Float64(-0.5 * b)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = 0.5 + (b * 0.16666666666666666);
	t_1 = b * t_0;
	t_2 = t_1 * ((b * b) * (t_0 * t_0));
	tmp = 0.0;
	if (b <= 2.1e-44)
		tmp = 0.5 + (a * 0.25);
	elseif (b <= 1.65e+31)
		tmp = 1.0 / (2.0 + (((1.0 - (t_2 * t_2)) * b) / ((1.0 - t_2) * (1.0 + (b * (t_0 * (t_1 + -1.0)))))));
	else
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[(0.5 + N[(b * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b * t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(N[(b * b), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, 2.1e-44], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.65e+31], N[(1.0 / N[(2.0 + N[(N[(N[(1.0 - N[(t$95$2 * t$95$2), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(N[(1.0 - t$95$2), $MachinePrecision] * N[(1.0 + N[(b * N[(t$95$0 * N[(t$95$1 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(2.0 + N[(N[(N[(1.0 + N[(t$95$1 * N[(b * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(1.0 + N[(-0.5 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < 2.10000000000000001e-44

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.10000000000000001e-44 < b < 1.64999999999999996e31

   1. Initial program 99.8%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.64999999999999996e31 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 80.0% accurate, 2.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 + b \cdot 0.16666666666666666\\ t_1 := b \cdot t\_0\\ \mathbf{if}\;b \leq 4.1 \cdot 10^{+35}:\\ \;\;\;\;\frac{e^{a}}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{2 + \frac{\left(1 + t\_1 \cdot \left(b \cdot \left(t\_0 \cdot t\_1\right)\right)\right) \cdot b}{1 + -0.5 \cdot b}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (let* ((t_0 (+ 0.5 (* b 0.16666666666666666))) (t_1 (* b t_0)))
   (if (<= b 4.1e+35)
     (/ (exp a) 2.0)
     (/
      1.0
      (+
       2.0
       (/ (* (+ 1.0 (* t_1 (* b (* t_0 t_1)))) b) (+ 1.0 (* -0.5 b))))))))

C

double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 4.1e+35) {
		tmp = exp(a) / 2.0;
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 0.5d0 + (b * 0.16666666666666666d0)
    t_1 = b * t_0
    if (b <= 4.1d+35) then
        tmp = exp(a) / 2.0d0
    else
        tmp = 1.0d0 / (2.0d0 + (((1.0d0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0d0 + ((-0.5d0) * b))))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 4.1e+35) {
		tmp = Math.exp(a) / 2.0;
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = 0.5 + (b * 0.16666666666666666)
	t_1 = b * t_0
	tmp = 0
	if b <= 4.1e+35:
		tmp = math.exp(a) / 2.0
	else:
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))))
	return tmp

Julia

function code(a, b)
	t_0 = Float64(0.5 + Float64(b * 0.16666666666666666))
	t_1 = Float64(b * t_0)
	tmp = 0.0
	if (b <= 4.1e+35)
		tmp = Float64(exp(a) / 2.0);
	else
		tmp = Float64(1.0 / Float64(2.0 + Float64(Float64(Float64(1.0 + Float64(t_1 * Float64(b * Float64(t_0 * t_1)))) * b) / Float64(1.0 + Float64(-0.5 * b)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = 0.5 + (b * 0.16666666666666666);
	t_1 = b * t_0;
	tmp = 0.0;
	if (b <= 4.1e+35)
		tmp = exp(a) / 2.0;
	else
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[(0.5 + N[(b * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b * t$95$0), $MachinePrecision]}, If[LessEqual[b, 4.1e+35], N[(N[Exp[a], $MachinePrecision] / 2.0), $MachinePrecision], N[(1.0 / N[(2.0 + N[(N[(N[(1.0 + N[(t$95$1 * N[(b * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(1.0 + N[(-0.5 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if b < 4.0999999999999998e35

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 4.0999999999999998e35 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 60.2% accurate, 7.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 + b \cdot 0.16666666666666666\\ t_1 := b \cdot t\_0\\ \mathbf{if}\;b \leq 3 \cdot 10^{-40}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{elif}\;b \leq 10^{+102}:\\ \;\;\;\;\frac{1}{2 + \frac{\left(1 - b \cdot \left(t\_0 \cdot t\_1\right)\right) \cdot b}{1 - t\_1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{6}{b \cdot \left(b \cdot b\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (let* ((t_0 (+ 0.5 (* b 0.16666666666666666))) (t_1 (* b t_0)))
   (if (<= b 3e-40)
     (+ 0.5 (* a 0.25))
     (if (<= b 1e+102)
       (/ 1.0 (+ 2.0 (/ (* (- 1.0 (* b (* t_0 t_1))) b) (- 1.0 t_1))))
       (/ 6.0 (* b (* b b)))))))

C

double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 3e-40) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1e+102) {
		tmp = 1.0 / (2.0 + (((1.0 - (b * (t_0 * t_1))) * b) / (1.0 - t_1)));
	} else {
		tmp = 6.0 / (b * (b * b));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 0.5d0 + (b * 0.16666666666666666d0)
    t_1 = b * t_0
    if (b <= 3d-40) then
        tmp = 0.5d0 + (a * 0.25d0)
    else if (b <= 1d+102) then
        tmp = 1.0d0 / (2.0d0 + (((1.0d0 - (b * (t_0 * t_1))) * b) / (1.0d0 - t_1)))
    else
        tmp = 6.0d0 / (b * (b * b))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 3e-40) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1e+102) {
		tmp = 1.0 / (2.0 + (((1.0 - (b * (t_0 * t_1))) * b) / (1.0 - t_1)));
	} else {
		tmp = 6.0 / (b * (b * b));
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = 0.5 + (b * 0.16666666666666666)
	t_1 = b * t_0
	tmp = 0
	if b <= 3e-40:
		tmp = 0.5 + (a * 0.25)
	elif b <= 1e+102:
		tmp = 1.0 / (2.0 + (((1.0 - (b * (t_0 * t_1))) * b) / (1.0 - t_1)))
	else:
		tmp = 6.0 / (b * (b * b))
	return tmp

Julia

function code(a, b)
	t_0 = Float64(0.5 + Float64(b * 0.16666666666666666))
	t_1 = Float64(b * t_0)
	tmp = 0.0
	if (b <= 3e-40)
		tmp = Float64(0.5 + Float64(a * 0.25));
	elseif (b <= 1e+102)
		tmp = Float64(1.0 / Float64(2.0 + Float64(Float64(Float64(1.0 - Float64(b * Float64(t_0 * t_1))) * b) / Float64(1.0 - t_1))));
	else
		tmp = Float64(6.0 / Float64(b * Float64(b * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = 0.5 + (b * 0.16666666666666666);
	t_1 = b * t_0;
	tmp = 0.0;
	if (b <= 3e-40)
		tmp = 0.5 + (a * 0.25);
	elseif (b <= 1e+102)
		tmp = 1.0 / (2.0 + (((1.0 - (b * (t_0 * t_1))) * b) / (1.0 - t_1)));
	else
		tmp = 6.0 / (b * (b * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[(0.5 + N[(b * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b * t$95$0), $MachinePrecision]}, If[LessEqual[b, 3e-40], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+102], N[(1.0 / N[(2.0 + N[(N[(N[(1.0 - N[(b * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(1.0 - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(6.0 / N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if b < 3.0000000000000002e-40

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.0000000000000002e-40 < b < 9.99999999999999977e101

   1. Initial program 99.9%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 9.99999999999999977e101 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 61.8% accurate, 7.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.5 + b \cdot 0.16666666666666666\\ t_1 := b \cdot t\_0\\ \mathbf{if}\;b \leq 7 \cdot 10^{-40}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{2 + \frac{\left(1 + t\_1 \cdot \left(b \cdot \left(t\_0 \cdot t\_1\right)\right)\right) \cdot b}{1 + -0.5 \cdot b}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (let* ((t_0 (+ 0.5 (* b 0.16666666666666666))) (t_1 (* b t_0)))
   (if (<= b 7e-40)
     (+ 0.5 (* a 0.25))
     (/
      1.0
      (+
       2.0
       (/ (* (+ 1.0 (* t_1 (* b (* t_0 t_1)))) b) (+ 1.0 (* -0.5 b))))))))

C

double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 7e-40) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 0.5d0 + (b * 0.16666666666666666d0)
    t_1 = b * t_0
    if (b <= 7d-40) then
        tmp = 0.5d0 + (a * 0.25d0)
    else
        tmp = 1.0d0 / (2.0d0 + (((1.0d0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0d0 + ((-0.5d0) * b))))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = 0.5 + (b * 0.16666666666666666);
	double t_1 = b * t_0;
	double tmp;
	if (b <= 7e-40) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = 0.5 + (b * 0.16666666666666666)
	t_1 = b * t_0
	tmp = 0
	if b <= 7e-40:
		tmp = 0.5 + (a * 0.25)
	else:
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))))
	return tmp

Julia

function code(a, b)
	t_0 = Float64(0.5 + Float64(b * 0.16666666666666666))
	t_1 = Float64(b * t_0)
	tmp = 0.0
	if (b <= 7e-40)
		tmp = Float64(0.5 + Float64(a * 0.25));
	else
		tmp = Float64(1.0 / Float64(2.0 + Float64(Float64(Float64(1.0 + Float64(t_1 * Float64(b * Float64(t_0 * t_1)))) * b) / Float64(1.0 + Float64(-0.5 * b)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = 0.5 + (b * 0.16666666666666666);
	t_1 = b * t_0;
	tmp = 0.0;
	if (b <= 7e-40)
		tmp = 0.5 + (a * 0.25);
	else
		tmp = 1.0 / (2.0 + (((1.0 + (t_1 * (b * (t_0 * t_1)))) * b) / (1.0 + (-0.5 * b))));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[(0.5 + N[(b * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b * t$95$0), $MachinePrecision]}, If[LessEqual[b, 7e-40], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(2.0 + N[(N[(N[(1.0 + N[(t$95$1 * N[(b * N[(t$95$0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(1.0 + N[(-0.5 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if b < 7.0000000000000003e-40

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 7.0000000000000003e-40 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 59.0% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := b \cdot \left(b \cdot b\right)\\ \mathbf{if}\;b \leq 10^{-42}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{elif}\;b \leq 10^{+102}:\\ \;\;\;\;\frac{1}{2 + b \cdot \left(1 + \frac{\left(0.125 + t\_0 \cdot 0.004629629629629629\right) \cdot b}{0.25 + \left(b \cdot 0.16666666666666666\right) \cdot \left(b \cdot 0.16666666666666666 + -0.5\right)}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{6}{t\_0}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (let* ((t_0 (* b (* b b))))
   (if (<= b 1e-42)
     (+ 0.5 (* a 0.25))
     (if (<= b 1e+102)
       (/
        1.0
        (+
         2.0
         (*
          b
          (+
           1.0
           (/
            (* (+ 0.125 (* t_0 0.004629629629629629)) b)
            (+
             0.25
             (*
              (* b 0.16666666666666666)
              (+ (* b 0.16666666666666666) -0.5))))))))
       (/ 6.0 t_0)))))

C

double code(double a, double b) {
	double t_0 = b * (b * b);
	double tmp;
	if (b <= 1e-42) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1e+102) {
		tmp = 1.0 / (2.0 + (b * (1.0 + (((0.125 + (t_0 * 0.004629629629629629)) * b) / (0.25 + ((b * 0.16666666666666666) * ((b * 0.16666666666666666) + -0.5)))))));
	} else {
		tmp = 6.0 / t_0;
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_0
    real(8) :: tmp
    t_0 = b * (b * b)
    if (b <= 1d-42) then
        tmp = 0.5d0 + (a * 0.25d0)
    else if (b <= 1d+102) then
        tmp = 1.0d0 / (2.0d0 + (b * (1.0d0 + (((0.125d0 + (t_0 * 0.004629629629629629d0)) * b) / (0.25d0 + ((b * 0.16666666666666666d0) * ((b * 0.16666666666666666d0) + (-0.5d0))))))))
    else
        tmp = 6.0d0 / t_0
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double t_0 = b * (b * b);
	double tmp;
	if (b <= 1e-42) {
		tmp = 0.5 + (a * 0.25);
	} else if (b <= 1e+102) {
		tmp = 1.0 / (2.0 + (b * (1.0 + (((0.125 + (t_0 * 0.004629629629629629)) * b) / (0.25 + ((b * 0.16666666666666666) * ((b * 0.16666666666666666) + -0.5)))))));
	} else {
		tmp = 6.0 / t_0;
	}
	return tmp;
}

Python

def code(a, b):
	t_0 = b * (b * b)
	tmp = 0
	if b <= 1e-42:
		tmp = 0.5 + (a * 0.25)
	elif b <= 1e+102:
		tmp = 1.0 / (2.0 + (b * (1.0 + (((0.125 + (t_0 * 0.004629629629629629)) * b) / (0.25 + ((b * 0.16666666666666666) * ((b * 0.16666666666666666) + -0.5)))))))
	else:
		tmp = 6.0 / t_0
	return tmp

Julia

function code(a, b)
	t_0 = Float64(b * Float64(b * b))
	tmp = 0.0
	if (b <= 1e-42)
		tmp = Float64(0.5 + Float64(a * 0.25));
	elseif (b <= 1e+102)
		tmp = Float64(1.0 / Float64(2.0 + Float64(b * Float64(1.0 + Float64(Float64(Float64(0.125 + Float64(t_0 * 0.004629629629629629)) * b) / Float64(0.25 + Float64(Float64(b * 0.16666666666666666) * Float64(Float64(b * 0.16666666666666666) + -0.5))))))));
	else
		tmp = Float64(6.0 / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	t_0 = b * (b * b);
	tmp = 0.0;
	if (b <= 1e-42)
		tmp = 0.5 + (a * 0.25);
	elseif (b <= 1e+102)
		tmp = 1.0 / (2.0 + (b * (1.0 + (((0.125 + (t_0 * 0.004629629629629629)) * b) / (0.25 + ((b * 0.16666666666666666) * ((b * 0.16666666666666666) + -0.5)))))));
	else
		tmp = 6.0 / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := Block[{t$95$0 = N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, 1e-42], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+102], N[(1.0 / N[(2.0 + N[(b * N[(1.0 + N[(N[(N[(0.125 + N[(t$95$0 * 0.004629629629629629), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(0.25 + N[(N[(b * 0.16666666666666666), $MachinePrecision] * N[(N[(b * 0.16666666666666666), $MachinePrecision] + -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(6.0 / t$95$0), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if b < 1.00000000000000004e-42

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.00000000000000004e-42 < b < 9.99999999999999977e101

   1. Initial program 99.9%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 9.99999999999999977e101 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 56.9% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq 7.6 \cdot 10^{-44}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{2 + b \cdot \left(1 + b \cdot \left(0.5 + b \cdot 0.16666666666666666\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= b 7.6e-44)
   (+ 0.5 (* a 0.25))
   (/ 1.0 (+ 2.0 (* b (+ 1.0 (* b (+ 0.5 (* b 0.16666666666666666)))))))))

C

double code(double a, double b) {
	double tmp;
	if (b <= 7.6e-44) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 1.0 / (2.0 + (b * (1.0 + (b * (0.5 + (b * 0.16666666666666666))))));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (b <= 7.6d-44) then
        tmp = 0.5d0 + (a * 0.25d0)
    else
        tmp = 1.0d0 / (2.0d0 + (b * (1.0d0 + (b * (0.5d0 + (b * 0.16666666666666666d0))))))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double tmp;
	if (b <= 7.6e-44) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 1.0 / (2.0 + (b * (1.0 + (b * (0.5 + (b * 0.16666666666666666))))));
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if b <= 7.6e-44:
		tmp = 0.5 + (a * 0.25)
	else:
		tmp = 1.0 / (2.0 + (b * (1.0 + (b * (0.5 + (b * 0.16666666666666666))))))
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (b <= 7.6e-44)
		tmp = Float64(0.5 + Float64(a * 0.25));
	else
		tmp = Float64(1.0 / Float64(2.0 + Float64(b * Float64(1.0 + Float64(b * Float64(0.5 + Float64(b * 0.16666666666666666)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	tmp = 0.0;
	if (b <= 7.6e-44)
		tmp = 0.5 + (a * 0.25);
	else
		tmp = 1.0 / (2.0 + (b * (1.0 + (b * (0.5 + (b * 0.16666666666666666))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := If[LessEqual[b, 7.6e-44], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(2.0 + N[(b * N[(1.0 + N[(b * N[(0.5 + N[(b * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < 7.6000000000000002e-44

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 7.6000000000000002e-44 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 56.7% accurate, 25.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq 2:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \mathbf{else}:\\ \;\;\;\;\frac{6}{b \cdot \left(b \cdot b\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= b 2.0) (+ 0.5 (* a 0.25)) (/ 6.0 (* b (* b b)))))

C

double code(double a, double b) {
	double tmp;
	if (b <= 2.0) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 6.0 / (b * (b * b));
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (b <= 2.0d0) then
        tmp = 0.5d0 + (a * 0.25d0)
    else
        tmp = 6.0d0 / (b * (b * b))
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double tmp;
	if (b <= 2.0) {
		tmp = 0.5 + (a * 0.25);
	} else {
		tmp = 6.0 / (b * (b * b));
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if b <= 2.0:
		tmp = 0.5 + (a * 0.25)
	else:
		tmp = 6.0 / (b * (b * b))
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (b <= 2.0)
		tmp = Float64(0.5 + Float64(a * 0.25));
	else
		tmp = Float64(6.0 / Float64(b * Float64(b * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	tmp = 0.0;
	if (b <= 2.0)
		tmp = 0.5 + (a * 0.25);
	else
		tmp = 6.0 / (b * (b * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := If[LessEqual[b, 2.0], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision], N[(6.0 / N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < 2

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2 < b

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 51.1% accurate, 25.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -580:\\ \;\;\;\;0.020833333333333332 \cdot \left(b \cdot \left(b \cdot b\right)\right)\\ \mathbf{else}:\\ \;\;\;\;0.5 + a \cdot 0.25\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= a -580.0) (* 0.020833333333333332 (* b (* b b))) (+ 0.5 (* a 0.25))))

C

double code(double a, double b) {
	double tmp;
	if (a <= -580.0) {
		tmp = 0.020833333333333332 * (b * (b * b));
	} else {
		tmp = 0.5 + (a * 0.25);
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (a <= (-580.0d0)) then
        tmp = 0.020833333333333332d0 * (b * (b * b))
    else
        tmp = 0.5d0 + (a * 0.25d0)
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double tmp;
	if (a <= -580.0) {
		tmp = 0.020833333333333332 * (b * (b * b));
	} else {
		tmp = 0.5 + (a * 0.25);
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if a <= -580.0:
		tmp = 0.020833333333333332 * (b * (b * b))
	else:
		tmp = 0.5 + (a * 0.25)
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (a <= -580.0)
		tmp = Float64(0.020833333333333332 * Float64(b * Float64(b * b)));
	else
		tmp = Float64(0.5 + Float64(a * 0.25));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	tmp = 0.0;
	if (a <= -580.0)
		tmp = 0.020833333333333332 * (b * (b * b));
	else
		tmp = 0.5 + (a * 0.25);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := If[LessEqual[a, -580.0], N[(0.020833333333333332 * N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -580

   1. Initial program 100.0%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -580 < a

   1. Initial program 99.4%

      \[\frac{e^{a}}{e^{a} + e^{b}} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 39.1% accurate, 61.0× speedup

Math

\[\begin{array}{l} \\ 0.5 + a \cdot 0.25 \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (+ 0.5 (* a 0.25)))

C

double code(double a, double b) {
	return 0.5 + (a * 0.25);
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = 0.5d0 + (a * 0.25d0)
end function

Java

public static double code(double a, double b) {
	return 0.5 + (a * 0.25);
}

Python

def code(a, b):
	return 0.5 + (a * 0.25)

Julia

function code(a, b)
	return Float64(0.5 + Float64(a * 0.25))
end

MATLAB

function tmp = code(a, b)
	tmp = 0.5 + (a * 0.25);
end

Wolfram

code[a_, b_] := N[(0.5 + N[(a * 0.25), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.6%

   \[\frac{e^{a}}{e^{a} + e^{b}} \]
2. Add Preprocessing

3. Taylor expanded in b around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in a around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Alternative 14: 38.9% accurate, 305.0× speedup

Math

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

FPCore

(FPCore (a b) :precision binary64 0.5)

C

double code(double a, double b) {
	return 0.5;
}

Fortran

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

Java

public static double code(double a, double b) {
	return 0.5;
}

Python

def code(a, b):
	return 0.5

Julia

function code(a, b)
	return 0.5
end

MATLAB

function tmp = code(a, b)
	tmp = 0.5;
end

Wolfram

code[a_, b_] := 0.5

Derivation

1. Initial program 99.6%

   \[\frac{e^{a}}{e^{a} + e^{b}} \]
2. Add Preprocessing

3. Taylor expanded in a around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in b around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Developer Target 1: 100.0% accurate, 2.9× speedup

Math

\[\begin{array}{l} \\ \frac{1}{1 + e^{b - a}} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ 1.0 (+ 1.0 (exp (- b a)))))

C

double code(double a, double b) {
	return 1.0 / (1.0 + exp((b - a)));
}

Fortran

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

Java

public static double code(double a, double b) {
	return 1.0 / (1.0 + Math.exp((b - a)));
}

Python

def code(a, b):
	return 1.0 / (1.0 + math.exp((b - a)))

Julia

function code(a, b)
	return Float64(1.0 / Float64(1.0 + exp(Float64(b - a))))
end

MATLAB

function tmp = code(a, b)
	tmp = 1.0 / (1.0 + exp((b - a)));
end

Wolfram

code[a_, b_] := N[(1.0 / N[(1.0 + N[Exp[N[(b - a), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024111 
(FPCore (a b)
  :name "Quotient of sum of exps"
  :precision binary64

  :alt
  (! :herbie-platform default (/ 1 (+ 1 (exp (- b a)))))

  (/ (exp a) (+ (exp a) (exp b))))