Octave 3.8, jcobi/3

Percentage Accurate: 70.1% → 99.9%

Time: 4.4s

Alternatives: 18

Speedup: 1.7×

• Could not converge on a ground truth

  1. alpha = 1.7533746046869366e+195
  2. beta = -1.7030234586554808e+258

Specification

\[\alpha > -1 \land \beta > -1\]

Math

\[\begin{array}{l} t_0 := \left(\alpha + \beta\right) + 2 \cdot 1\\ \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{t\_0}}{t\_0}}{t\_0 + 1} \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (+ alpha beta) (* 2.0 1.0))))
  (/
   (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) t_0) t_0)
   (+ t_0 1.0))))

C

double code(double alpha, double beta) {
	double t_0 = (alpha + beta) + (2.0 * 1.0);
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    t_0 = (alpha + beta) + (2.0d0 * 1.0d0)
    code = (((((alpha + beta) + (beta * alpha)) + 1.0d0) / t_0) / t_0) / (t_0 + 1.0d0)
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = (alpha + beta) + (2.0 * 1.0);
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}

Python

def code(alpha, beta):
	t_0 = (alpha + beta) + (2.0 * 1.0)
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0)

Julia

function code(alpha, beta)
	t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * 1.0))
	return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) + Float64(beta * alpha)) + 1.0) / t_0) / t_0) / Float64(t_0 + 1.0))
end

MATLAB

function tmp = code(alpha, beta)
	t_0 = (alpha + beta) + (2.0 * 1.0);
	tmp = (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]]

Initial Program: 70.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_0 := \left(\alpha + \beta\right) + 2 \cdot 1\\ \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{t\_0}}{t\_0}}{t\_0 + 1} \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (+ alpha beta) (* 2.0 1.0))))
  (/
   (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) t_0) t_0)
   (+ t_0 1.0))))

C

double code(double alpha, double beta) {
	double t_0 = (alpha + beta) + (2.0 * 1.0);
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    t_0 = (alpha + beta) + (2.0d0 * 1.0d0)
    code = (((((alpha + beta) + (beta * alpha)) + 1.0d0) / t_0) / t_0) / (t_0 + 1.0d0)
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = (alpha + beta) + (2.0 * 1.0);
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}

Python

def code(alpha, beta):
	t_0 = (alpha + beta) + (2.0 * 1.0)
	return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0)

Julia

function code(alpha, beta)
	t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * 1.0))
	return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) + Float64(beta * alpha)) + 1.0) / t_0) / t_0) / Float64(t_0 + 1.0))
end

MATLAB

function tmp = code(alpha, beta)
	t_0 = (alpha + beta) + (2.0 * 1.0);
	tmp = (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]]

Alternative 1: 99.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \frac{1}{\mathsf{max}\left(\alpha, \beta\right)}\\ t_1 := \left(\mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\right) + 2 \cdot 1\\ t_2 := t\_1 + 1\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{\frac{\mathsf{max}\left(\alpha, \beta\right) \cdot \left(1 + \left(\mathsf{min}\left(\alpha, \beta\right) + \left(t\_0 + \frac{\mathsf{min}\left(\alpha, \beta\right)}{\mathsf{max}\left(\alpha, \beta\right)}\right)\right)\right)}{t\_1}}{t\_1}}{t\_2}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{fma}\left(\frac{\mathsf{max}\left(\alpha, \beta\right)}{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -2}, \frac{\mathsf{min}\left(\alpha, \beta\right)}{1}, 1 - t\_0\right)}{t\_1}}{t\_2}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (/ 1.0 (fmax alpha beta)))
       (t_1 (+ (+ (fmin alpha beta) (fmax alpha beta)) (* 2.0 1.0)))
       (t_2 (+ t_1 1.0)))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/
       (/
        (/
         (*
          (fmax alpha beta)
          (+
           1.0
           (+
            (fmin alpha beta)
            (+ t_0 (/ (fmin alpha beta) (fmax alpha beta))))))
         t_1)
        t_1)
       t_2)
      (/
       (/
        (fma
         (/
          (fmax alpha beta)
          (- (+ (fmax alpha beta) (fmin alpha beta)) -2.0))
         (/ (fmin alpha beta) 1.0)
         (- 1.0 t_0))
        t_1)
       t_2)))))

C

double code(double alpha, double beta) {
	double t_0 = 1.0 / fmax(alpha, beta);
	double t_1 = (fmin(alpha, beta) + fmax(alpha, beta)) + (2.0 * 1.0);
	double t_2 = t_1 + 1.0;
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = (((fmax(alpha, beta) * (1.0 + (fmin(alpha, beta) + (t_0 + (fmin(alpha, beta) / fmax(alpha, beta)))))) / t_1) / t_1) / t_2;
	} else {
		tmp = (fma((fmax(alpha, beta) / ((fmax(alpha, beta) + fmin(alpha, beta)) - -2.0)), (fmin(alpha, beta) / 1.0), (1.0 - t_0)) / t_1) / t_2;
	}
	return tmp;
}

Julia

function code(alpha, beta)
	t_0 = Float64(1.0 / fmax(alpha, beta))
	t_1 = Float64(Float64(fmin(alpha, beta) + fmax(alpha, beta)) + Float64(2.0 * 1.0))
	t_2 = Float64(t_1 + 1.0)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(Float64(fmax(alpha, beta) * Float64(1.0 + Float64(fmin(alpha, beta) + Float64(t_0 + Float64(fmin(alpha, beta) / fmax(alpha, beta)))))) / t_1) / t_1) / t_2);
	else
		tmp = Float64(Float64(fma(Float64(fmax(alpha, beta) / Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -2.0)), Float64(fmin(alpha, beta) / 1.0), Float64(1.0 - t_0)) / t_1) / t_2);
	end
	return tmp
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(1.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1.0), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] * N[(1.0 + N[(N[Min[alpha, beta], $MachinePrecision] + N[(t$95$0 + N[(N[Min[alpha, beta], $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] / N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -2.0), $MachinePrecision]), $MachinePrecision] * N[(N[Min[alpha, beta], $MachinePrecision] / 1.0), $MachinePrecision] + N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \left(1 + \left(\alpha + \left(\frac{1}{\beta} + \frac{\alpha}{\beta}\right)\right)\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \color{blue}{\left(1 + \left(\alpha + \left(\frac{1}{\beta} + \frac{\alpha}{\beta}\right)\right)\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \left(1 + \color{blue}{\left(\alpha + \left(\frac{1}{\beta} + \frac{\alpha}{\beta}\right)\right)}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \left(1 + \left(\alpha + \color{blue}{\left(\frac{1}{\beta} + \frac{\alpha}{\beta}\right)}\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. lower-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \left(1 + \left(\alpha + \left(\frac{1}{\beta} + \color{blue}{\frac{\alpha}{\beta}}\right)\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      5. lower-/.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \left(1 + \left(\alpha + \left(\frac{1}{\beta} + \frac{\color{blue}{\alpha}}{\beta}\right)\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      6. lower-/.f64 59.0%

         \[\leadsto \frac{\frac{\frac{\beta \cdot \left(1 + \left(\alpha + \left(\frac{1}{\beta} + \frac{\alpha}{\color{blue}{\beta}}\right)\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 59.0%

      \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \left(1 + \left(\alpha + \left(\frac{1}{\beta} + \frac{\alpha}{\beta}\right)\right)\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \frac{\frac{\color{blue}{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. +-commutative N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\beta \cdot \alpha + \left(\alpha + \beta\right)\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      5. associate-+l+ N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      6. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \color{blue}{\left(2 - 1\right)}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      7. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      8. lift-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      9. associate--l+ N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \color{blue}{\left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      10. lift-+.f64 N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right)} - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      11. div-add N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta \cdot \alpha}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      12. lift-*.f64 N/A

          \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha}}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      13. *-rgt-identity N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha}{\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot 1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      14. times-frac N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{\alpha}{1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      15. lower-fma.f64 N/A

          \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1}, \frac{\alpha}{1}, \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   3. Applied rewrites 79.2%

      \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \frac{\left(\beta + \alpha\right) - -1}{\left(\beta + \alpha\right) - -2}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Taylor expanded in beta around inf

      \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \color{blue}{1 - \frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. lower--.f64 N/A

         \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, 1 - \color{blue}{\frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-/.f64 42.3%

         \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, 1 - \frac{1}{\color{blue}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 42.3%

      \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \color{blue}{1 - \frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 2: 99.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ t_1 := t\_0 - -2\\ t_2 := \left(\mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\right) + 2 \cdot 1\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{fma}\left(\frac{\mathsf{max}\left(\alpha, \beta\right)}{t\_1}, \frac{\mathsf{min}\left(\alpha, \beta\right)}{1}, \frac{t\_0 - -1}{t\_1}\right)}{t\_2}}{t\_2 + 1}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta)))
       (t_1 (- t_0 -2.0))
       (t_2 (+ (+ (fmin alpha beta) (fmax alpha beta)) (* 2.0 1.0))))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (/
     (/
      (fma
       (/ (fmax alpha beta) t_1)
       (/ (fmin alpha beta) 1.0)
       (/ (- t_0 -1.0) t_1))
      t_2)
     (+ t_2 1.0)))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = t_0 - -2.0;
	double t_2 = (fmin(alpha, beta) + fmax(alpha, beta)) + (2.0 * 1.0);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = (fma((fmax(alpha, beta) / t_1), (fmin(alpha, beta) / 1.0), ((t_0 - -1.0) / t_1)) / t_2) / (t_2 + 1.0);
	}
	return tmp;
}

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	t_1 = Float64(t_0 - -2.0)
	t_2 = Float64(Float64(fmin(alpha, beta) + fmax(alpha, beta)) + Float64(2.0 * 1.0))
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(Float64(fma(Float64(fmax(alpha, beta) / t_1), Float64(fmin(alpha, beta) / 1.0), Float64(Float64(t_0 - -1.0) / t_1)) / t_2) / Float64(t_2 + 1.0));
	end
	return tmp
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[Min[alpha, beta], $MachinePrecision] / 1.0), $MachinePrecision] + N[(N[(t$95$0 - -1.0), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \frac{\frac{\color{blue}{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. +-commutative N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\beta \cdot \alpha + \left(\alpha + \beta\right)\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      5. associate-+l+ N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      6. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \color{blue}{\left(2 - 1\right)}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      7. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      8. lift-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      9. associate--l+ N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \color{blue}{\left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      10. lift-+.f64 N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right)} - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      11. div-add N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta \cdot \alpha}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      12. lift-*.f64 N/A

          \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha}}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      13. *-rgt-identity N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha}{\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot 1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      14. times-frac N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{\alpha}{1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      15. lower-fma.f64 N/A

          \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1}, \frac{\alpha}{1}, \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   3. Applied rewrites 79.2%

      \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \frac{\left(\beta + \alpha\right) - -1}{\left(\beta + \alpha\right) - -2}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 99.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\\ t_1 := t\_0 + 2 \cdot 1\\ t_2 := t\_1 + 1\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{\frac{\left(t\_0 + \mathsf{max}\left(\alpha, \beta\right) \cdot \mathsf{min}\left(\alpha, \beta\right)\right) + 1}{t\_1}}{t\_1}}{t\_2}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{fma}\left(\frac{\mathsf{max}\left(\alpha, \beta\right)}{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -2}, \frac{\mathsf{min}\left(\alpha, \beta\right)}{1}, 1 - \frac{1}{\mathsf{max}\left(\alpha, \beta\right)}\right)}{t\_1}}{t\_2}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmin alpha beta) (fmax alpha beta)))
       (t_1 (+ t_0 (* 2.0 1.0)))
       (t_2 (+ t_1 1.0)))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/
       (/
        (/
         (+ (+ t_0 (* (fmax alpha beta) (fmin alpha beta))) 1.0)
         t_1)
        t_1)
       t_2)
      (/
       (/
        (fma
         (/
          (fmax alpha beta)
          (- (+ (fmax alpha beta) (fmin alpha beta)) -2.0))
         (/ (fmin alpha beta) 1.0)
         (- 1.0 (/ 1.0 (fmax alpha beta))))
        t_1)
       t_2)))))

C

double code(double alpha, double beta) {
	double t_0 = fmin(alpha, beta) + fmax(alpha, beta);
	double t_1 = t_0 + (2.0 * 1.0);
	double t_2 = t_1 + 1.0;
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = ((((t_0 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / t_2;
	} else {
		tmp = (fma((fmax(alpha, beta) / ((fmax(alpha, beta) + fmin(alpha, beta)) - -2.0)), (fmin(alpha, beta) / 1.0), (1.0 - (1.0 / fmax(alpha, beta)))) / t_1) / t_2;
	}
	return tmp;
}

Julia

function code(alpha, beta)
	t_0 = Float64(fmin(alpha, beta) + fmax(alpha, beta))
	t_1 = Float64(t_0 + Float64(2.0 * 1.0))
	t_2 = Float64(t_1 + 1.0)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(Float64(Float64(t_0 + Float64(fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / t_2);
	else
		tmp = Float64(Float64(fma(Float64(fmax(alpha, beta) / Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -2.0)), Float64(fmin(alpha, beta) / 1.0), Float64(1.0 - Float64(1.0 / fmax(alpha, beta)))) / t_1) / t_2);
	end
	return tmp
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1.0), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(N[(N[(t$95$0 + N[(N[Max[alpha, beta], $MachinePrecision] * N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] / N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -2.0), $MachinePrecision]), $MachinePrecision] * N[(N[Min[alpha, beta], $MachinePrecision] / 1.0), $MachinePrecision] + N[(1.0 - N[(1.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \frac{\frac{\color{blue}{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-+.f64 N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. +-commutative N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\left(\beta \cdot \alpha + \left(\alpha + \beta\right)\right)} + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      5. associate-+l+ N/A

         \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      6. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \color{blue}{\left(2 - 1\right)}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      7. metadata-eval N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      8. lift-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\left(\alpha + \beta\right) + \left(\color{blue}{2 \cdot 1} - 1\right)\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      9. associate--l+ N/A

         \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \color{blue}{\left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      10. lift-+.f64 N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha + \left(\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right)} - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      11. div-add N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta \cdot \alpha}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      12. lift-*.f64 N/A

          \[\leadsto \frac{\frac{\frac{\color{blue}{\beta \cdot \alpha}}{\left(\alpha + \beta\right) + 2 \cdot 1} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      13. *-rgt-identity N/A

          \[\leadsto \frac{\frac{\frac{\beta \cdot \alpha}{\color{blue}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot 1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      14. times-frac N/A

          \[\leadsto \frac{\frac{\color{blue}{\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{\alpha}{1}} + \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      15. lower-fma.f64 N/A

          \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\alpha + \beta\right) + 2 \cdot 1}, \frac{\alpha}{1}, \frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) - 1}{\left(\alpha + \beta\right) + 2 \cdot 1}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   3. Applied rewrites 79.2%

      \[\leadsto \frac{\frac{\color{blue}{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \frac{\left(\beta + \alpha\right) - -1}{\left(\beta + \alpha\right) - -2}\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Taylor expanded in beta around inf

      \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \color{blue}{1 - \frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. lower--.f64 N/A

         \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, 1 - \color{blue}{\frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-/.f64 42.3%

         \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, 1 - \frac{1}{\color{blue}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 42.3%

      \[\leadsto \frac{\frac{\mathsf{fma}\left(\frac{\beta}{\left(\beta + \alpha\right) - -2}, \frac{\alpha}{1}, \color{blue}{1 - \frac{1}{\beta}}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 99.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ t_1 := t\_0 - -2\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{t\_0 - -3}{\mathsf{fma}\left(\mathsf{min}\left(\alpha, \beta\right), \frac{\frac{\mathsf{max}\left(\alpha, \beta\right)}{t\_1}}{t\_1}, \frac{-1 - t\_0}{\left(-2 - t\_0\right) \cdot t\_1}\right)}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta)))
       (t_1 (- t_0 -2.0)))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (/
     1.0
     (/
      (- t_0 -3.0)
      (fma
       (fmin alpha beta)
       (/ (/ (fmax alpha beta) t_1) t_1)
       (/ (- -1.0 t_0) (* (- -2.0 t_0) t_1))))))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = t_0 - -2.0;
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = 1.0 / ((t_0 - -3.0) / fma(fmin(alpha, beta), ((fmax(alpha, beta) / t_1) / t_1), ((-1.0 - t_0) / ((-2.0 - t_0) * t_1))));
	}
	return tmp;
}

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	t_1 = Float64(t_0 - -2.0)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(1.0 / Float64(Float64(t_0 - -3.0) / fma(fmin(alpha, beta), Float64(Float64(fmax(alpha, beta) / t_1) / t_1), Float64(Float64(-1.0 - t_0) / Float64(Float64(-2.0 - t_0) * t_1)))));
	end
	return tmp
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - -2.0), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(t$95$0 - -3.0), $MachinePrecision] / N[(N[Min[alpha, beta], $MachinePrecision] * N[(N[(N[Max[alpha, beta], $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$1), $MachinePrecision] + N[(N[(-1.0 - t$95$0), $MachinePrecision] / N[(N[(-2.0 - t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   2. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      2. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}}} \]

      3. remove-sound-/ N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}}} \]

      4. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}}} \]

      5. remove-sound-/ N/A

         \[\leadsto \frac{1}{\color{blue}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}}} \]

      6. lower-/.f64 70.0%

         \[\leadsto \frac{1}{\color{blue}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}}} \]

   3. Applied rewrites 71.0%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\frac{-1 - \mathsf{fma}\left(\beta, \alpha, \beta + \alpha\right)}{\left(-2 - \left(\beta + \alpha\right)\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}}}} \]

   5. Applied rewrites 79.2%

      \[\leadsto \frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\color{blue}{\mathsf{fma}\left(\alpha, \frac{\frac{\beta}{\left(\beta + \alpha\right) - -2}}{\left(\beta + \alpha\right) - -2}, \frac{-1 - \left(\beta + \alpha\right)}{\left(-2 - \left(\beta + \alpha\right)\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}\right)}}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 99.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\\ t_1 := t\_0 + 2 \cdot 1\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{\frac{\left(t\_0 + \mathsf{max}\left(\alpha, \beta\right) \cdot \mathsf{min}\left(\alpha, \beta\right)\right) + 1}{t\_1}}{t\_1}}{t\_1 + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -3}{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\mathsf{max}\left(\alpha, \beta\right)}}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmin alpha beta) (fmax alpha beta)))
       (t_1 (+ t_0 (* 2.0 1.0))))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/
       (/
        (/
         (+ (+ t_0 (* (fmax alpha beta) (fmin alpha beta))) 1.0)
         t_1)
        t_1)
       (+ t_1 1.0))
      (/
       1.0
       (/
        (- (+ (fmax alpha beta) (fmin alpha beta)) -3.0)
        (/ (- (fmin alpha beta) -1.0) (fmax alpha beta))))))))

C

double code(double alpha, double beta) {
	double t_0 = fmin(alpha, beta) + fmax(alpha, beta);
	double t_1 = t_0 + (2.0 * 1.0);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = ((((t_0 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / (t_1 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = fmin(alpha, beta) + fmax(alpha, beta)
    t_1 = t_0 + (2.0d0 * 1.0d0)
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else if (fmin(alpha, beta) <= 4.3d-44) then
        tmp = ((((t_0 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0d0) / t_1) / t_1) / (t_1 + 1.0d0)
    else
        tmp = 1.0d0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - (-3.0d0)) / ((fmin(alpha, beta) - (-1.0d0)) / fmax(alpha, beta)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmin(alpha, beta) + fmax(alpha, beta);
	double t_1 = t_0 + (2.0 * 1.0);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = ((((t_0 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / (t_1 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmin(alpha, beta) + fmax(alpha, beta)
	t_1 = t_0 + (2.0 * 1.0)
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	elif fmin(alpha, beta) <= 4.3e-44:
		tmp = ((((t_0 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / (t_1 + 1.0)
	else:
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)))
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmin(alpha, beta) + fmax(alpha, beta))
	t_1 = Float64(t_0 + Float64(2.0 * 1.0))
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(Float64(Float64(t_0 + Float64(fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_1) / t_1) / Float64(t_1 + 1.0));
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / Float64(Float64(fmin(alpha, beta) - -1.0) / fmax(alpha, beta))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = min(alpha, beta) + max(alpha, beta);
	t_1 = t_0 + (2.0 * 1.0);
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	elseif (min(alpha, beta) <= 4.3e-44)
		tmp = ((((t_0 + (max(alpha, beta) * min(alpha, beta))) + 1.0) / t_1) / t_1) / (t_1 + 1.0);
	else
		tmp = 1.0 / (((max(alpha, beta) + min(alpha, beta)) - -3.0) / ((min(alpha, beta) - -1.0) / max(alpha, beta)));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(N[(N[(t$95$0 + N[(N[Max[alpha, beta], $MachinePrecision] * N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$1), $MachinePrecision] / N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -3.0), $MachinePrecision] / N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      4. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      5. remove-sound-/ N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      6. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

   6. Applied rewrites 28.8%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\frac{\alpha - -1}{\beta}}}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 98.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_0 := 2 + \mathsf{max}\left(\alpha, \beta\right)\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{\frac{\left(\left(\mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\right) + \mathsf{max}\left(\alpha, \beta\right) \cdot \mathsf{min}\left(\alpha, \beta\right)\right) + 1}{t\_0}}{t\_0}}{t\_0 + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -3}{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\mathsf{max}\left(\alpha, \beta\right)}}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ 2.0 (fmax alpha beta))))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/
       (/
        (/
         (+
          (+
           (+ (fmin alpha beta) (fmax alpha beta))
           (* (fmax alpha beta) (fmin alpha beta)))
          1.0)
         t_0)
        t_0)
       (+ t_0 1.0))
      (/
       1.0
       (/
        (- (+ (fmax alpha beta) (fmin alpha beta)) -3.0)
        (/ (- (fmin alpha beta) -1.0) (fmax alpha beta))))))))

C

double code(double alpha, double beta) {
	double t_0 = 2.0 + fmax(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = (((((fmin(alpha, beta) + fmax(alpha, beta)) + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 2.0d0 + fmax(alpha, beta)
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else if (fmin(alpha, beta) <= 4.3d-44) then
        tmp = (((((fmin(alpha, beta) + fmax(alpha, beta)) + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0d0) / t_0) / t_0) / (t_0 + 1.0d0)
    else
        tmp = 1.0d0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - (-3.0d0)) / ((fmin(alpha, beta) - (-1.0d0)) / fmax(alpha, beta)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = 2.0 + fmax(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = (((((fmin(alpha, beta) + fmax(alpha, beta)) + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = 2.0 + fmax(alpha, beta)
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	elif fmin(alpha, beta) <= 4.3e-44:
		tmp = (((((fmin(alpha, beta) + fmax(alpha, beta)) + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_0) / t_0) / (t_0 + 1.0)
	else:
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)))
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(2.0 + fmax(alpha, beta))
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(Float64(Float64(Float64(fmin(alpha, beta) + fmax(alpha, beta)) + Float64(fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_0) / t_0) / Float64(t_0 + 1.0));
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / Float64(Float64(fmin(alpha, beta) - -1.0) / fmax(alpha, beta))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = 2.0 + max(alpha, beta);
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	elseif (min(alpha, beta) <= 4.3e-44)
		tmp = (((((min(alpha, beta) + max(alpha, beta)) + (max(alpha, beta) * min(alpha, beta))) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
	else
		tmp = 1.0 / (((max(alpha, beta) + min(alpha, beta)) - -3.0) / ((min(alpha, beta) - -1.0) / max(alpha, beta)));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(2.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(N[(N[(N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] + N[(N[Max[alpha, beta], $MachinePrecision] * N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -3.0), $MachinePrecision] / N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\color{blue}{2 + \beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-+.f64 49.4%

         \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \color{blue}{\beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 49.4%

      \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\color{blue}{2 + \beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \beta}}{\color{blue}{2 + \beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   6. Step-by-step derivation

      1. lower-+.f64 48.7%

         \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \beta}}{2 + \color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   7. Applied rewrites 48.7%

      \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \beta}}{\color{blue}{2 + \beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   8. Taylor expanded in alpha around 0

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

      1. lower-+.f64 48.4%

         \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \beta}}{2 + \beta}}{\left(2 + \color{blue}{\beta}\right) + 1} \]

   10. Applied rewrites 48.4%

       \[\leadsto \frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{2 + \beta}}{2 + \beta}}{\color{blue}{\left(2 + \beta\right)} + 1} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      4. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      5. remove-sound-/ N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      6. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

   6. Applied rewrites 28.8%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\frac{\alpha - -1}{\beta}}}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 98.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_0 := 2 + \mathsf{max}\left(\alpha, \beta\right)\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -90:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{\frac{1 + \mathsf{max}\left(\alpha, \beta\right)}{t\_0}}{t\_0}}{t\_0 + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -3}{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\mathsf{max}\left(\alpha, \beta\right)}}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ 2.0 (fmax alpha beta))))
  (if (<= (fmin alpha beta) -90.0)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/ (/ (/ (+ 1.0 (fmax alpha beta)) t_0) t_0) (+ t_0 1.0))
      (/
       1.0
       (/
        (- (+ (fmax alpha beta) (fmin alpha beta)) -3.0)
        (/ (- (fmin alpha beta) -1.0) (fmax alpha beta))))))))

C

double code(double alpha, double beta) {
	double t_0 = 2.0 + fmax(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -90.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = (((1.0 + fmax(alpha, beta)) / t_0) / t_0) / (t_0 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: tmp
    t_0 = 2.0d0 + fmax(alpha, beta)
    if (fmin(alpha, beta) <= (-90.0d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else if (fmin(alpha, beta) <= 4.3d-44) then
        tmp = (((1.0d0 + fmax(alpha, beta)) / t_0) / t_0) / (t_0 + 1.0d0)
    else
        tmp = 1.0d0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - (-3.0d0)) / ((fmin(alpha, beta) - (-1.0d0)) / fmax(alpha, beta)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = 2.0 + fmax(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -90.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = (((1.0 + fmax(alpha, beta)) / t_0) / t_0) / (t_0 + 1.0);
	} else {
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = 2.0 + fmax(alpha, beta)
	tmp = 0
	if fmin(alpha, beta) <= -90.0:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	elif fmin(alpha, beta) <= 4.3e-44:
		tmp = (((1.0 + fmax(alpha, beta)) / t_0) / t_0) / (t_0 + 1.0)
	else:
		tmp = 1.0 / (((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)))
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(2.0 + fmax(alpha, beta))
	tmp = 0.0
	if (fmin(alpha, beta) <= -90.0)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(Float64(1.0 + fmax(alpha, beta)) / t_0) / t_0) / Float64(t_0 + 1.0));
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -3.0) / Float64(Float64(fmin(alpha, beta) - -1.0) / fmax(alpha, beta))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = 2.0 + max(alpha, beta);
	tmp = 0.0;
	if (min(alpha, beta) <= -90.0)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	elseif (min(alpha, beta) <= 4.3e-44)
		tmp = (((1.0 + max(alpha, beta)) / t_0) / t_0) / (t_0 + 1.0);
	else
		tmp = 1.0 / (((max(alpha, beta) + min(alpha, beta)) - -3.0) / ((min(alpha, beta) - -1.0) / max(alpha, beta)));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(2.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -90.0], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(N[(1.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -3.0), $MachinePrecision] / N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -90

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -90 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-+.f64 77.2%

         \[\leadsto \frac{\frac{\frac{1 + \color{blue}{\beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 77.2%

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{1 + \beta}{\color{blue}{2 + \beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   6. Step-by-step derivation

      1. lower-+.f64 75.2%

         \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \color{blue}{\beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   7. Applied rewrites 75.2%

      \[\leadsto \frac{\frac{\frac{1 + \beta}{\color{blue}{2 + \beta}}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   8. Taylor expanded in alpha around 0

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

      1. lower-+.f64 60.7%

         \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \beta}}{2 + \color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   10. Applied rewrites 60.7%

       \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \beta}}{\color{blue}{2 + \beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   11. Taylor expanded in alpha around 0

       \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \beta}}{2 + \beta}}{\color{blue}{\left(2 + \beta\right)} + 1} \]
   12. Step-by-step derivation

       1. lower-+.f64 57.0%

          \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \beta}}{2 + \beta}}{\left(2 + \color{blue}{\beta}\right) + 1} \]

   13. Applied rewrites 57.0%

       \[\leadsto \frac{\frac{\frac{1 + \beta}{2 + \beta}}{2 + \beta}}{\color{blue}{\left(2 + \beta\right)} + 1} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      4. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      5. remove-sound-/ N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      6. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

   6. Applied rewrites 28.8%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\frac{\alpha - -1}{\beta}}}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 98.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ t_1 := t\_0 - -2\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -36:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 8.4 \cdot 10^{-23}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(\alpha, \beta\right) - -1}{t\_1}}{\left(2 + \mathsf{max}\left(\alpha, \beta\right)\right) \cdot \left(3 + \mathsf{max}\left(\alpha, \beta\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{t\_1}}{t\_0 - -3}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta)))
       (t_1 (- t_0 -2.0)))
  (if (<= (fmin alpha beta) -36.0)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 8.4e-23)
      (/
       (/ (- (fmax alpha beta) -1.0) t_1)
       (* (+ 2.0 (fmax alpha beta)) (+ 3.0 (fmax alpha beta))))
      (/ (/ (- (fmin alpha beta) -1.0) t_1) (- t_0 -3.0))))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = t_0 - -2.0;
	double tmp;
	if (fmin(alpha, beta) <= -36.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 8.4e-23) {
		tmp = ((fmax(alpha, beta) - -1.0) / t_1) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)));
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / t_1) / (t_0 - -3.0);
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = fmax(alpha, beta) + fmin(alpha, beta)
    t_1 = t_0 - (-2.0d0)
    if (fmin(alpha, beta) <= (-36.0d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else if (fmin(alpha, beta) <= 8.4d-23) then
        tmp = ((fmax(alpha, beta) - (-1.0d0)) / t_1) / ((2.0d0 + fmax(alpha, beta)) * (3.0d0 + fmax(alpha, beta)))
    else
        tmp = ((fmin(alpha, beta) - (-1.0d0)) / t_1) / (t_0 - (-3.0d0))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = t_0 - -2.0;
	double tmp;
	if (fmin(alpha, beta) <= -36.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 8.4e-23) {
		tmp = ((fmax(alpha, beta) - -1.0) / t_1) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)));
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / t_1) / (t_0 - -3.0);
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmax(alpha, beta) + fmin(alpha, beta)
	t_1 = t_0 - -2.0
	tmp = 0
	if fmin(alpha, beta) <= -36.0:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	elif fmin(alpha, beta) <= 8.4e-23:
		tmp = ((fmax(alpha, beta) - -1.0) / t_1) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)))
	else:
		tmp = ((fmin(alpha, beta) - -1.0) / t_1) / (t_0 - -3.0)
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	t_1 = Float64(t_0 - -2.0)
	tmp = 0.0
	if (fmin(alpha, beta) <= -36.0)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 8.4e-23)
		tmp = Float64(Float64(Float64(fmax(alpha, beta) - -1.0) / t_1) / Float64(Float64(2.0 + fmax(alpha, beta)) * Float64(3.0 + fmax(alpha, beta))));
	else
		tmp = Float64(Float64(Float64(fmin(alpha, beta) - -1.0) / t_1) / Float64(t_0 - -3.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = max(alpha, beta) + min(alpha, beta);
	t_1 = t_0 - -2.0;
	tmp = 0.0;
	if (min(alpha, beta) <= -36.0)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	elseif (min(alpha, beta) <= 8.4e-23)
		tmp = ((max(alpha, beta) - -1.0) / t_1) / ((2.0 + max(alpha, beta)) * (3.0 + max(alpha, beta)));
	else
		tmp = ((min(alpha, beta) - -1.0) / t_1) / (t_0 - -3.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - -2.0), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -36.0], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 8.4e-23], N[(N[(N[(N[Max[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / t$95$1), $MachinePrecision] / N[(N[(2.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] * N[(3.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / t$95$1), $MachinePrecision] / N[(t$95$0 - -3.0), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -36

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -36 < alpha < 8.4000000000000003e-23

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-+.f64 77.2%

         \[\leadsto \frac{\frac{\frac{1 + \color{blue}{\beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 77.2%

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\color{blue}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)}} \]
   6. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \color{blue}{\left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)}} \]

      2. lower-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \left(\beta \cdot \color{blue}{\left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)}\right)} \]

      3. lower--.f64 N/A

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - \color{blue}{1}\right)\right)} \]

      4. lower-*.f64 N/A

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)} \]

      5. lower-/.f64 N/A

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)} \]

      6. lower-+.f64 77.8%

         \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)} \]

   7. Applied rewrites 77.8%

      \[\leadsto \frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\color{blue}{-1 \cdot \left(\beta \cdot \left(-1 \cdot \frac{3 + \alpha}{\beta} - 1\right)\right)}} \]

   9. Applied rewrites 77.8%

      \[\leadsto \color{blue}{\frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\left(\left(1 + \frac{\alpha - -3}{\beta}\right) \cdot \beta\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}} \]

   10. Taylor expanded in alpha around 0

       \[\leadsto \frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\color{blue}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}} \]
   11. Step-by-step derivation

       1. lower-*.f64 N/A

          \[\leadsto \frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\left(2 + \beta\right) \cdot \color{blue}{\left(3 + \beta\right)}} \]

       2. lower-+.f64 N/A

          \[\leadsto \frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\left(2 + \beta\right) \cdot \left(\color{blue}{3} + \beta\right)} \]

       3. lower-+.f64 60.5%

          \[\leadsto \frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\left(2 + \beta\right) \cdot \left(3 + \color{blue}{\beta}\right)} \]

   12. Applied rewrites 60.5%

       \[\leadsto \frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2}}{\color{blue}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}} \]

   if 8.4000000000000003e-23 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \color{blue}{\left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - \color{blue}{1}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-*.f64 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 34.1%

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 34.1%

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

Alternative 9: 98.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -36:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{elif}\;\mathsf{min}\left(\alpha, \beta\right) \leq 4.3 \cdot 10^{-44}:\\ \;\;\;\;\frac{\frac{1 + \mathsf{max}\left(\alpha, \beta\right)}{\left(2 + \mathsf{max}\left(\alpha, \beta\right)\right) \cdot \left(3 + \mathsf{max}\left(\alpha, \beta\right)\right)}}{t\_0 - -2}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{t\_0 - -3}{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\mathsf{max}\left(\alpha, \beta\right)}}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta))))
  (if (<= (fmin alpha beta) -36.0)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (if (<= (fmin alpha beta) 4.3e-44)
      (/
       (/
        (+ 1.0 (fmax alpha beta))
        (* (+ 2.0 (fmax alpha beta)) (+ 3.0 (fmax alpha beta))))
       (- t_0 -2.0))
      (/
       1.0
       (/
        (- t_0 -3.0)
        (/ (- (fmin alpha beta) -1.0) (fmax alpha beta))))))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -36.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = ((1.0 + fmax(alpha, beta)) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)))) / (t_0 - -2.0);
	} else {
		tmp = 1.0 / ((t_0 - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(alpha, beta) + fmin(alpha, beta)
    if (fmin(alpha, beta) <= (-36.0d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else if (fmin(alpha, beta) <= 4.3d-44) then
        tmp = ((1.0d0 + fmax(alpha, beta)) / ((2.0d0 + fmax(alpha, beta)) * (3.0d0 + fmax(alpha, beta)))) / (t_0 - (-2.0d0))
    else
        tmp = 1.0d0 / ((t_0 - (-3.0d0)) / ((fmin(alpha, beta) - (-1.0d0)) / fmax(alpha, beta)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -36.0) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else if (fmin(alpha, beta) <= 4.3e-44) {
		tmp = ((1.0 + fmax(alpha, beta)) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)))) / (t_0 - -2.0);
	} else {
		tmp = 1.0 / ((t_0 - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)));
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmax(alpha, beta) + fmin(alpha, beta)
	tmp = 0
	if fmin(alpha, beta) <= -36.0:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	elif fmin(alpha, beta) <= 4.3e-44:
		tmp = ((1.0 + fmax(alpha, beta)) / ((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta)))) / (t_0 - -2.0)
	else:
		tmp = 1.0 / ((t_0 - -3.0) / ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)))
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	tmp = 0.0
	if (fmin(alpha, beta) <= -36.0)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	elseif (fmin(alpha, beta) <= 4.3e-44)
		tmp = Float64(Float64(Float64(1.0 + fmax(alpha, beta)) / Float64(Float64(2.0 + fmax(alpha, beta)) * Float64(3.0 + fmax(alpha, beta)))) / Float64(t_0 - -2.0));
	else
		tmp = Float64(1.0 / Float64(Float64(t_0 - -3.0) / Float64(Float64(fmin(alpha, beta) - -1.0) / fmax(alpha, beta))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = max(alpha, beta) + min(alpha, beta);
	tmp = 0.0;
	if (min(alpha, beta) <= -36.0)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	elseif (min(alpha, beta) <= 4.3e-44)
		tmp = ((1.0 + max(alpha, beta)) / ((2.0 + max(alpha, beta)) * (3.0 + max(alpha, beta)))) / (t_0 - -2.0);
	else
		tmp = 1.0 / ((t_0 - -3.0) / ((min(alpha, beta) - -1.0) / max(alpha, beta)));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -36.0], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[alpha, beta], $MachinePrecision], 4.3e-44], N[(N[(N[(1.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(N[(2.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] * N[(3.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - -2.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(t$95$0 - -3.0), $MachinePrecision] / N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if alpha < -36

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -36 < alpha < 4.3000000000000001e-44

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-+.f64 77.2%

         \[\leadsto \frac{\frac{\frac{1 + \color{blue}{\beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 77.2%

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      2. mult-flip N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. associate-*l/ N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \]

      5. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \]

   6. Applied rewrites 77.2%

      \[\leadsto \color{blue}{\frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2} \cdot \frac{-1}{-3 - \left(\beta + \alpha\right)}}{\left(\beta + \alpha\right) - -2}} \]

   7. Taylor expanded in alpha around 0

      \[\leadsto \frac{\color{blue}{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}}}{\left(\beta + \alpha\right) - -2} \]
   8. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \beta}{\color{blue}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}}}{\left(\beta + \alpha\right) - -2} \]

      2. lower-+.f64 N/A

         \[\leadsto \frac{\frac{1 + \beta}{\color{blue}{\left(2 + \beta\right)} \cdot \left(3 + \beta\right)}}{\left(\beta + \alpha\right) - -2} \]

      3. lower-*.f64 N/A

         \[\leadsto \frac{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \color{blue}{\left(3 + \beta\right)}}}{\left(\beta + \alpha\right) - -2} \]

      4. lower-+.f64 N/A

         \[\leadsto \frac{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(\color{blue}{3} + \beta\right)}}{\left(\beta + \alpha\right) - -2} \]

      5. lower-+.f64 60.5%

         \[\leadsto \frac{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(3 + \color{blue}{\beta}\right)}}{\left(\beta + \alpha\right) - -2} \]

   9. Applied rewrites 60.5%

      \[\leadsto \frac{\color{blue}{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}}}{\left(\beta + \alpha\right) - -2} \]

   if 4.3000000000000001e-44 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      4. div-flip N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      5. remove-sound-/ N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

      6. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}{\frac{1 + \alpha}{\beta}}}} \]

   6. Applied rewrites 28.8%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\beta + \alpha\right) - -3}{\frac{\alpha - -1}{\beta}}}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 83.7% accurate, 0.2× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ t_1 := \frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ t_2 := \mathsf{min}\left(\alpha, \beta\right) + \mathsf{max}\left(\alpha, \beta\right)\\ t_3 := t\_2 + 2 \cdot 1\\ t_4 := \frac{\frac{\frac{\left(t\_2 + \mathsf{max}\left(\alpha, \beta\right) \cdot \mathsf{min}\left(\alpha, \beta\right)\right) + 1}{t\_3}}{t\_3}}{t\_3 + 1}\\ t_5 := t\_0 - -2\\ \mathbf{if}\;t\_4 \leq -5 \cdot 10^{-245}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_4 \leq 10^{-228}:\\ \;\;\;\;\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\left(t\_0 - -3\right) \cdot t\_5}\\ \mathbf{elif}\;t\_4 \leq 4 \cdot 10^{-8}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{1 + \mathsf{min}\left(\alpha, \beta\right)}{\left(2 + \mathsf{min}\left(\alpha, \beta\right)\right) \cdot \left(3 + \mathsf{min}\left(\alpha, \beta\right)\right)}}{t\_5}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta)))
       (t_1 (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0)))
       (t_2 (+ (fmin alpha beta) (fmax alpha beta)))
       (t_3 (+ t_2 (* 2.0 1.0)))
       (t_4
        (/
         (/
          (/
           (+ (+ t_2 (* (fmax alpha beta) (fmin alpha beta))) 1.0)
           t_3)
          t_3)
         (+ t_3 1.0)))
       (t_5 (- t_0 -2.0)))
  (if (<= t_4 -5e-245)
    t_1
    (if (<= t_4 1e-228)
      (/ (- (fmin alpha beta) -1.0) (* (- t_0 -3.0) t_5))
      (if (<= t_4 4e-8)
        t_1
        (/
         (/
          (+ 1.0 (fmin alpha beta))
          (* (+ 2.0 (fmin alpha beta)) (+ 3.0 (fmin alpha beta))))
         t_5))))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	double t_2 = fmin(alpha, beta) + fmax(alpha, beta);
	double t_3 = t_2 + (2.0 * 1.0);
	double t_4 = ((((t_2 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_3) / t_3) / (t_3 + 1.0);
	double t_5 = t_0 - -2.0;
	double tmp;
	if (t_4 <= -5e-245) {
		tmp = t_1;
	} else if (t_4 <= 1e-228) {
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * t_5);
	} else if (t_4 <= 4e-8) {
		tmp = t_1;
	} else {
		tmp = ((1.0 + fmin(alpha, beta)) / ((2.0 + fmin(alpha, beta)) * (3.0 + fmin(alpha, beta)))) / t_5;
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: t_5
    real(8) :: tmp
    t_0 = fmax(alpha, beta) + fmin(alpha, beta)
    t_1 = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    t_2 = fmin(alpha, beta) + fmax(alpha, beta)
    t_3 = t_2 + (2.0d0 * 1.0d0)
    t_4 = ((((t_2 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0d0) / t_3) / t_3) / (t_3 + 1.0d0)
    t_5 = t_0 - (-2.0d0)
    if (t_4 <= (-5d-245)) then
        tmp = t_1
    else if (t_4 <= 1d-228) then
        tmp = (fmin(alpha, beta) - (-1.0d0)) / ((t_0 - (-3.0d0)) * t_5)
    else if (t_4 <= 4d-8) then
        tmp = t_1
    else
        tmp = ((1.0d0 + fmin(alpha, beta)) / ((2.0d0 + fmin(alpha, beta)) * (3.0d0 + fmin(alpha, beta)))) / t_5
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double t_1 = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	double t_2 = fmin(alpha, beta) + fmax(alpha, beta);
	double t_3 = t_2 + (2.0 * 1.0);
	double t_4 = ((((t_2 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_3) / t_3) / (t_3 + 1.0);
	double t_5 = t_0 - -2.0;
	double tmp;
	if (t_4 <= -5e-245) {
		tmp = t_1;
	} else if (t_4 <= 1e-228) {
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * t_5);
	} else if (t_4 <= 4e-8) {
		tmp = t_1;
	} else {
		tmp = ((1.0 + fmin(alpha, beta)) / ((2.0 + fmin(alpha, beta)) * (3.0 + fmin(alpha, beta)))) / t_5;
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmax(alpha, beta) + fmin(alpha, beta)
	t_1 = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	t_2 = fmin(alpha, beta) + fmax(alpha, beta)
	t_3 = t_2 + (2.0 * 1.0)
	t_4 = ((((t_2 + (fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_3) / t_3) / (t_3 + 1.0)
	t_5 = t_0 - -2.0
	tmp = 0
	if t_4 <= -5e-245:
		tmp = t_1
	elif t_4 <= 1e-228:
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * t_5)
	elif t_4 <= 4e-8:
		tmp = t_1
	else:
		tmp = ((1.0 + fmin(alpha, beta)) / ((2.0 + fmin(alpha, beta)) * (3.0 + fmin(alpha, beta)))) / t_5
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	t_1 = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0))
	t_2 = Float64(fmin(alpha, beta) + fmax(alpha, beta))
	t_3 = Float64(t_2 + Float64(2.0 * 1.0))
	t_4 = Float64(Float64(Float64(Float64(Float64(t_2 + Float64(fmax(alpha, beta) * fmin(alpha, beta))) + 1.0) / t_3) / t_3) / Float64(t_3 + 1.0))
	t_5 = Float64(t_0 - -2.0)
	tmp = 0.0
	if (t_4 <= -5e-245)
		tmp = t_1;
	elseif (t_4 <= 1e-228)
		tmp = Float64(Float64(fmin(alpha, beta) - -1.0) / Float64(Float64(t_0 - -3.0) * t_5));
	elseif (t_4 <= 4e-8)
		tmp = t_1;
	else
		tmp = Float64(Float64(Float64(1.0 + fmin(alpha, beta)) / Float64(Float64(2.0 + fmin(alpha, beta)) * Float64(3.0 + fmin(alpha, beta)))) / t_5);
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = max(alpha, beta) + min(alpha, beta);
	t_1 = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	t_2 = min(alpha, beta) + max(alpha, beta);
	t_3 = t_2 + (2.0 * 1.0);
	t_4 = ((((t_2 + (max(alpha, beta) * min(alpha, beta))) + 1.0) / t_3) / t_3) / (t_3 + 1.0);
	t_5 = t_0 - -2.0;
	tmp = 0.0;
	if (t_4 <= -5e-245)
		tmp = t_1;
	elseif (t_4 <= 1e-228)
		tmp = (min(alpha, beta) - -1.0) / ((t_0 - -3.0) * t_5);
	elseif (t_4 <= 4e-8)
		tmp = t_1;
	else
		tmp = ((1.0 + min(alpha, beta)) / ((2.0 + min(alpha, beta)) * (3.0 + min(alpha, beta)))) / t_5;
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Min[alpha, beta], $MachinePrecision] + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[(t$95$2 + N[(N[Max[alpha, beta], $MachinePrecision] * N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$3), $MachinePrecision] / t$95$3), $MachinePrecision] / N[(t$95$3 + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$0 - -2.0), $MachinePrecision]}, If[LessEqual[t$95$4, -5e-245], t$95$1, If[LessEqual[t$95$4, 1e-228], N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[(N[(t$95$0 - -3.0), $MachinePrecision] * t$95$5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 4e-8], t$95$1, N[(N[(N[(1.0 + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(N[(2.0 + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] * N[(3.0 + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$5), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (/.f64 (/.f64 (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 beta alpha)) #s(literal 1 binary64)) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64))) < -4.9999999999999997e-245 or 1e-228 < (/.f64 (/.f64 (/.f64 (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 beta alpha)) #s(literal 1 binary64)) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64))) < 4.0000000000000001e-8

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -4.9999999999999997e-245 < (/.f64 (/.f64 (/.f64 (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 beta alpha)) #s(literal 1 binary64)) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64))) < 1e-228

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \color{blue}{\left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - \color{blue}{1}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-*.f64 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 34.1%

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      3. lift-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. associate-/l/ N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot \left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1\right)}} \]

      5. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot \left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1\right)}} \]

   6. Applied rewrites 55.0%

      \[\leadsto \color{blue}{\frac{\alpha - -1}{\left(\left(\beta + \alpha\right) - -3\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}} \]

   if 4.0000000000000001e-8 < (/.f64 (/.f64 (/.f64 (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 beta alpha)) #s(literal 1 binary64)) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64)))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 #s(literal 2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64)))

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-+.f64 77.2%

         \[\leadsto \frac{\frac{\frac{1 + \color{blue}{\beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 77.2%

      \[\leadsto \frac{\frac{\frac{\color{blue}{1 + \beta}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      2. mult-flip N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      3. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. associate-*l/ N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \]

      5. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{1 + \beta}{\left(\alpha + \beta\right) + 2 \cdot 1} \cdot \frac{1}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}} \]

   6. Applied rewrites 77.2%

      \[\leadsto \color{blue}{\frac{\frac{\beta - -1}{\left(\beta + \alpha\right) - -2} \cdot \frac{-1}{-3 - \left(\beta + \alpha\right)}}{\left(\beta + \alpha\right) - -2}} \]

   7. Taylor expanded in beta around 0

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(3 + \alpha\right)}}}{\left(\beta + \alpha\right) - -2} \]
   8. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\left(2 + \alpha\right) \cdot \left(3 + \alpha\right)}}}{\left(\beta + \alpha\right) - -2} \]

      2. lower-+.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\left(2 + \alpha\right)} \cdot \left(3 + \alpha\right)}}{\left(\beta + \alpha\right) - -2} \]

      3. lower-*.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \color{blue}{\left(3 + \alpha\right)}}}{\left(\beta + \alpha\right) - -2} \]

      4. lower-+.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(\color{blue}{3} + \alpha\right)}}{\left(\beta + \alpha\right) - -2} \]

      5. lower-+.f64 59.7%

         \[\leadsto \frac{\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(3 + \color{blue}{\alpha}\right)}}{\left(\beta + \alpha\right) - -2} \]

   9. Applied rewrites 59.7%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(3 + \alpha\right)}}}{\left(\beta + \alpha\right) - -2} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 11: 78.6% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{t\_0 - -2}}{t\_0 - -3}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta))))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (/ (/ (- (fmin alpha beta) -1.0) (- t_0 -2.0)) (- t_0 -3.0)))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / (t_0 - -2.0)) / (t_0 - -3.0);
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(alpha, beta) + fmin(alpha, beta)
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else
        tmp = ((fmin(alpha, beta) - (-1.0d0)) / (t_0 - (-2.0d0))) / (t_0 - (-3.0d0))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / (t_0 - -2.0)) / (t_0 - -3.0);
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmax(alpha, beta) + fmin(alpha, beta)
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	else:
		tmp = ((fmin(alpha, beta) - -1.0) / (t_0 - -2.0)) / (t_0 - -3.0)
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(Float64(Float64(fmin(alpha, beta) - -1.0) / Float64(t_0 - -2.0)) / Float64(t_0 - -3.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = max(alpha, beta) + min(alpha, beta);
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	else
		tmp = ((min(alpha, beta) - -1.0) / (t_0 - -2.0)) / (t_0 - -3.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[(t$95$0 - -2.0), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - -3.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \color{blue}{\left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - \color{blue}{1}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-*.f64 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 34.1%

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 34.1%

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

Alternative 12: 77.0% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\\ \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\left(t\_0 - -3\right) \cdot \left(t\_0 - -2\right)}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (let* ((t_0 (+ (fmax alpha beta) (fmin alpha beta))))
  (if (<= (fmin alpha beta) -0.102)
    (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
    (/ (- (fmin alpha beta) -1.0) (* (- t_0 -3.0) (- t_0 -2.0))))))

C

double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * (t_0 - -2.0));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(alpha, beta) + fmin(alpha, beta)
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else
        tmp = (fmin(alpha, beta) - (-1.0d0)) / ((t_0 - (-3.0d0)) * (t_0 - (-2.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double t_0 = fmax(alpha, beta) + fmin(alpha, beta);
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * (t_0 - -2.0));
	}
	return tmp;
}

Python

def code(alpha, beta):
	t_0 = fmax(alpha, beta) + fmin(alpha, beta)
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	else:
		tmp = (fmin(alpha, beta) - -1.0) / ((t_0 - -3.0) * (t_0 - -2.0))
	return tmp

Julia

function code(alpha, beta)
	t_0 = Float64(fmax(alpha, beta) + fmin(alpha, beta))
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(Float64(fmin(alpha, beta) - -1.0) / Float64(Float64(t_0 - -3.0) * Float64(t_0 - -2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	t_0 = max(alpha, beta) + min(alpha, beta);
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	else
		tmp = (min(alpha, beta) - -1.0) / ((t_0 - -3.0) * (t_0 - -2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := Block[{t$95$0 = N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[(N[(t$95$0 - -3.0), $MachinePrecision] * N[(t$95$0 - -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \color{blue}{\left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - \color{blue}{1}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-*.f64 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 34.1%

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1}} \]

      3. lift-/.f64 N/A

         \[\leadsto \frac{\color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      4. associate-/l/ N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot \left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1\right)}} \]

      5. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) \cdot \left(\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1\right)}} \]

   6. Applied rewrites 55.0%

      \[\leadsto \color{blue}{\frac{\alpha - -1}{\left(\left(\beta + \alpha\right) - -3\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 77.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(2 + \mathsf{max}\left(\alpha, \beta\right)\right) \cdot \left(3 + \mathsf{max}\left(\alpha, \beta\right)\right)}{\mathsf{min}\left(\alpha, \beta\right) - -1}}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (if (<= (fmin alpha beta) -0.102)
  (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
  (/
   1.0
   (/
    (* (+ 2.0 (fmax alpha beta)) (+ 3.0 (fmax alpha beta)))
    (- (fmin alpha beta) -1.0)))))

C

double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = 1.0 / (((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta))) / (fmin(alpha, beta) - -1.0));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: tmp
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else
        tmp = 1.0d0 / (((2.0d0 + fmax(alpha, beta)) * (3.0d0 + fmax(alpha, beta))) / (fmin(alpha, beta) - (-1.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = 1.0 / (((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta))) / (fmin(alpha, beta) - -1.0));
	}
	return tmp;
}

Python

def code(alpha, beta):
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	else:
		tmp = 1.0 / (((2.0 + fmax(alpha, beta)) * (3.0 + fmax(alpha, beta))) / (fmin(alpha, beta) - -1.0))
	return tmp

Julia

function code(alpha, beta)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(2.0 + fmax(alpha, beta)) * Float64(3.0 + fmax(alpha, beta))) / Float64(fmin(alpha, beta) - -1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	else
		tmp = 1.0 / (((2.0 + max(alpha, beta)) * (3.0 + max(alpha, beta))) / (min(alpha, beta) - -1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(N[(2.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] * N[(3.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around -inf

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \color{blue}{\left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower--.f64 N/A

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - \color{blue}{1}\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      3. lower-*.f64 34.1%

         \[\leadsto \frac{\frac{-1 \cdot \left(-1 \cdot \alpha - 1\right)}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 34.1%

      \[\leadsto \frac{\frac{\color{blue}{-1 \cdot \left(-1 \cdot \alpha - 1\right)}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 55.0%

      \[\leadsto \color{blue}{\frac{1}{\frac{\left(\left(\beta + \alpha\right) - -3\right) \cdot \left(\left(\beta + \alpha\right) - -2\right)}{\alpha - -1}}} \]

   7. Taylor expanded in alpha around 0

      \[\leadsto \frac{1}{\frac{\color{blue}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}}{\alpha - -1}} \]
   8. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \frac{1}{\frac{\left(2 + \beta\right) \cdot \color{blue}{\left(3 + \beta\right)}}{\alpha - -1}} \]

      2. lower-+.f64 N/A

         \[\leadsto \frac{1}{\frac{\left(2 + \beta\right) \cdot \left(\color{blue}{3} + \beta\right)}{\alpha - -1}} \]

      3. lower-+.f64 37.1%

         \[\leadsto \frac{1}{\frac{\left(2 + \beta\right) \cdot \left(3 + \color{blue}{\beta}\right)}{\alpha - -1}} \]

   9. Applied rewrites 37.1%

      \[\leadsto \frac{1}{\frac{\color{blue}{\left(2 + \beta\right) \cdot \left(3 + \beta\right)}}{\alpha - -1}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 75.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(\alpha, \beta\right) - -1}{\mathsf{max}\left(\alpha, \beta\right)}}{\left(\mathsf{max}\left(\alpha, \beta\right) + \mathsf{min}\left(\alpha, \beta\right)\right) - -3}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (if (<= (fmin alpha beta) -0.102)
  (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
  (/
   (/ (- (fmin alpha beta) -1.0) (fmax alpha beta))
   (- (+ (fmax alpha beta) (fmin alpha beta)) -3.0))))

C

double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)) / ((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0);
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: tmp
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else
        tmp = ((fmin(alpha, beta) - (-1.0d0)) / fmax(alpha, beta)) / ((fmax(alpha, beta) + fmin(alpha, beta)) - (-3.0d0))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)) / ((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0);
	}
	return tmp;
}

Python

def code(alpha, beta):
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	else:
		tmp = ((fmin(alpha, beta) - -1.0) / fmax(alpha, beta)) / ((fmax(alpha, beta) + fmin(alpha, beta)) - -3.0)
	return tmp

Julia

function code(alpha, beta)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(Float64(Float64(fmin(alpha, beta) - -1.0) / fmax(alpha, beta)) / Float64(Float64(fmax(alpha, beta) + fmin(alpha, beta)) - -3.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	else
		tmp = ((min(alpha, beta) - -1.0) / max(alpha, beta)) / ((max(alpha, beta) + min(alpha, beta)) - -3.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[alpha, beta], $MachinePrecision] - -1.0), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Max[alpha, beta], $MachinePrecision] + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] - -3.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   5. Step-by-step derivation

      1. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. metadata-eval 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   6. Applied rewrites 28.9%

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

Alternative 15: 75.0% accurate, 1.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(\alpha, \beta\right) \leq -0.102:\\ \;\;\;\;\frac{\frac{0}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + 0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{1 + \mathsf{min}\left(\alpha, \beta\right)}{\mathsf{max}\left(\alpha, \beta\right)}}{3 + \mathsf{max}\left(\alpha, \beta\right)}\\ \end{array} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (if (<= (fmin alpha beta) -0.102)
  (/ (/ 0.0 (fmax alpha beta)) (+ 3.0 0.0))
  (/
   (/ (+ 1.0 (fmin alpha beta)) (fmax alpha beta))
   (+ 3.0 (fmax alpha beta)))))

C

double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((1.0 + fmin(alpha, beta)) / fmax(alpha, beta)) / (3.0 + fmax(alpha, beta));
	}
	return tmp;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: tmp
    if (fmin(alpha, beta) <= (-0.102d0)) then
        tmp = (0.0d0 / fmax(alpha, beta)) / (3.0d0 + 0.0d0)
    else
        tmp = ((1.0d0 + fmin(alpha, beta)) / fmax(alpha, beta)) / (3.0d0 + fmax(alpha, beta))
    end if
    code = tmp
end function

Java

public static double code(double alpha, double beta) {
	double tmp;
	if (fmin(alpha, beta) <= -0.102) {
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0);
	} else {
		tmp = ((1.0 + fmin(alpha, beta)) / fmax(alpha, beta)) / (3.0 + fmax(alpha, beta));
	}
	return tmp;
}

Python

def code(alpha, beta):
	tmp = 0
	if fmin(alpha, beta) <= -0.102:
		tmp = (0.0 / fmax(alpha, beta)) / (3.0 + 0.0)
	else:
		tmp = ((1.0 + fmin(alpha, beta)) / fmax(alpha, beta)) / (3.0 + fmax(alpha, beta))
	return tmp

Julia

function code(alpha, beta)
	tmp = 0.0
	if (fmin(alpha, beta) <= -0.102)
		tmp = Float64(Float64(0.0 / fmax(alpha, beta)) / Float64(3.0 + 0.0));
	else
		tmp = Float64(Float64(Float64(1.0 + fmin(alpha, beta)) / fmax(alpha, beta)) / Float64(3.0 + fmax(alpha, beta)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(alpha, beta)
	tmp = 0.0;
	if (min(alpha, beta) <= -0.102)
		tmp = (0.0 / max(alpha, beta)) / (3.0 + 0.0);
	else
		tmp = ((1.0 + min(alpha, beta)) / max(alpha, beta)) / (3.0 + max(alpha, beta));
	end
	tmp_2 = tmp;
end

Wolfram

code[alpha_, beta_] := If[LessEqual[N[Min[alpha, beta], $MachinePrecision], -0.102], N[(N[(0.0 / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[Min[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision] / N[(3.0 + N[Max[alpha, beta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if alpha < -0.10199999999999999

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in beta around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
   6. Step-by-step derivation

      1. lower-+.f64 4.3%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

   7. Applied rewrites 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

   8. Taylor expanded in alpha around inf

      \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
   9. Step-by-step derivation

      1. lower-/.f64 14.4%

         \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

   10. Applied rewrites 14.4%

       \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

   11. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
   12. Step-by-step derivation

   13. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

   14. Taylor expanded in undef-var around zero

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
   15. Step-by-step derivation

   16. Applied rewrites 60.0%

       \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]

   if -0.10199999999999999 < alpha

   1. Initial program 70.1%

      \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. Taylor expanded in beta around inf

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
   3. Step-by-step derivation

      1. lower-/.f64 N/A

         \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

      2. lower-+.f64 28.9%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   4. Applied rewrites 28.9%

      \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   5. Taylor expanded in alpha around 0

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \beta}} \]
   6. Step-by-step derivation

      1. lower-+.f64 28.7%

         \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\beta}} \]

   7. Applied rewrites 28.7%

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

Alternative 16: 60.0% accurate, 4.5× speedup

Math

\[\frac{\frac{0}{\beta}}{3 + 0} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (/ (/ 0.0 beta) (+ 3.0 0.0)))

C

double code(double alpha, double beta) {
	return (0.0 / beta) / (3.0 + 0.0);
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    code = (0.0d0 / beta) / (3.0d0 + 0.0d0)
end function

Java

public static double code(double alpha, double beta) {
	return (0.0 / beta) / (3.0 + 0.0);
}

Python

def code(alpha, beta):
	return (0.0 / beta) / (3.0 + 0.0)

Julia

function code(alpha, beta)
	return Float64(Float64(0.0 / beta) / Float64(3.0 + 0.0))
end

MATLAB

function tmp = code(alpha, beta)
	tmp = (0.0 / beta) / (3.0 + 0.0);
end

Wolfram

code[alpha_, beta_] := N[(N[(0.0 / beta), $MachinePrecision] / N[(3.0 + 0.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 70.1%

   \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

2. Taylor expanded in beta around inf

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Step-by-step derivation

   1. lower-/.f64 N/A

      \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. lower-+.f64 28.9%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

4. Applied rewrites 28.9%

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

5. Taylor expanded in beta around 0

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
6. Step-by-step derivation

   1. lower-+.f64 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

7. Applied rewrites 4.3%

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

8. Taylor expanded in alpha around inf

   \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
9. Step-by-step derivation

   1. lower-/.f64 14.4%

      \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

10. Applied rewrites 14.4%

    \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

11. Taylor expanded in undef-var around zero

    \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]
12. Step-by-step derivation

13. Applied rewrites 60.0%

    \[\leadsto \frac{\frac{0}{\beta}}{3 + \alpha} \]

14. Taylor expanded in undef-var around zero

    \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
15. Step-by-step derivation

16. Applied rewrites 60.0%

    \[\leadsto \frac{\frac{0}{\beta}}{3 + 0} \]
17. Add Preprocessing

Alternative 17: 14.4% accurate, 4.5× speedup

Math

\[\frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (/ (/ alpha beta) (+ 3.0 alpha)))

C

double code(double alpha, double beta) {
	return (alpha / beta) / (3.0 + alpha);
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    code = (alpha / beta) / (3.0d0 + alpha)
end function

Java

public static double code(double alpha, double beta) {
	return (alpha / beta) / (3.0 + alpha);
}

Python

def code(alpha, beta):
	return (alpha / beta) / (3.0 + alpha)

Julia

function code(alpha, beta)
	return Float64(Float64(alpha / beta) / Float64(3.0 + alpha))
end

MATLAB

function tmp = code(alpha, beta)
	tmp = (alpha / beta) / (3.0 + alpha);
end

Wolfram

code[alpha_, beta_] := N[(N[(alpha / beta), $MachinePrecision] / N[(3.0 + alpha), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 70.1%

   \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

2. Taylor expanded in beta around inf

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Step-by-step derivation

   1. lower-/.f64 N/A

      \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. lower-+.f64 28.9%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

4. Applied rewrites 28.9%

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

5. Taylor expanded in beta around 0

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
6. Step-by-step derivation

   1. lower-+.f64 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

7. Applied rewrites 4.3%

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

8. Taylor expanded in alpha around inf

   \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
9. Step-by-step derivation

   1. lower-/.f64 14.4%

      \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

10. Applied rewrites 14.4%

    \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
11. Add Preprocessing

Alternative 18: 13.8% accurate, 5.9× speedup

Math

\[\frac{\frac{\alpha}{\beta}}{3} \]

FPCore

(FPCore (alpha beta)
  :precision binary64
  (/ (/ alpha beta) 3.0))

C

double code(double alpha, double beta) {
	return (alpha / beta) / 3.0;
}

Fortran

real(8) function code(alpha, beta)
use fmin_fmax_functions
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    code = (alpha / beta) / 3.0d0
end function

Java

public static double code(double alpha, double beta) {
	return (alpha / beta) / 3.0;
}

Python

def code(alpha, beta):
	return (alpha / beta) / 3.0

Julia

function code(alpha, beta)
	return Float64(Float64(alpha / beta) / 3.0)
end

MATLAB

function tmp = code(alpha, beta)
	tmp = (alpha / beta) / 3.0;
end

Wolfram

code[alpha_, beta_] := N[(N[(alpha / beta), $MachinePrecision] / 3.0), $MachinePrecision]

Derivation

1. Initial program 70.1%

   \[\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\alpha + \beta\right) + 2 \cdot 1}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

2. Taylor expanded in beta around inf

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]
3. Step-by-step derivation

   1. lower-/.f64 N/A

      \[\leadsto \frac{\frac{1 + \alpha}{\color{blue}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

   2. lower-+.f64 28.9%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

4. Applied rewrites 28.9%

   \[\leadsto \frac{\color{blue}{\frac{1 + \alpha}{\beta}}}{\left(\left(\alpha + \beta\right) + 2 \cdot 1\right) + 1} \]

5. Taylor expanded in beta around 0

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]
6. Step-by-step derivation

   1. lower-+.f64 4.3%

      \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{3 + \color{blue}{\alpha}} \]

7. Applied rewrites 4.3%

   \[\leadsto \frac{\frac{1 + \alpha}{\beta}}{\color{blue}{3 + \alpha}} \]

8. Taylor expanded in alpha around inf

   \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]
9. Step-by-step derivation

   1. lower-/.f64 14.4%

      \[\leadsto \frac{\frac{\alpha}{\beta}}{3 + \alpha} \]

10. Applied rewrites 14.4%

    \[\leadsto \frac{\frac{\alpha}{\color{blue}{\beta}}}{3 + \alpha} \]

11. Taylor expanded in alpha around 0

    \[\leadsto \frac{\frac{\alpha}{\beta}}{3} \]
12. Step-by-step derivation

13. Applied rewrites 13.8%

    \[\leadsto \frac{\frac{\alpha}{\beta}}{3} \]
14. Add Preprocessing

Reproduce

herbie shell --seed 2025313 -o setup:search
(FPCore (alpha beta)
  :name "Octave 3.8, jcobi/3"
  :precision binary64
  :pre (and (> alpha -1.0) (> beta -1.0))
  (/ (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) (+ (+ alpha beta) (* 2.0 1.0))) (+ (+ alpha beta) (* 2.0 1.0))) (+ (+ (+ alpha beta) (* 2.0 1.0)) 1.0)))