Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A

Percentage Accurate: 69.5% → 99.8%

Time: 3.0s

Alternatives: 21

Speedup: 0.9×

Specification

Math

\[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))

C

double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function

Java

public static double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Python

def code(x, y):
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))

Julia

function code(x, y)
	return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
end

Wolfram

code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	(x * y) / (((x + y) * (x + y)) * ((x + y) + (1)))
END code

Initial Program: 69.5% accurate, 1.0× speedup

Math

\[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))

C

double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function

Java

public static double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Python

def code(x, y):
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))

Julia

function code(x, y)
	return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
end

Wolfram

code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	(x * y) / (((x + y) * (x + y)) * ((x + y) + (1)))
END code

Alternative 1: 99.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \frac{\frac{\mathsf{min}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{max}\left(x, y\right)}{1 + t\_0}}{t\_0} \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))))
  (/ (* (/ (fmin x y) t_0) (/ (fmax x y) (+ 1.0 t_0))) t_0)))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	return ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + t_0))) / t_0;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    t_0 = fmax(x, y) + fmin(x, y)
    code = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0d0 + t_0))) / t_0
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	return ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + t_0))) / t_0;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	return ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + t_0))) / t_0

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	return Float64(Float64(Float64(fmin(x, y) / t_0) * Float64(fmax(x, y) / Float64(1.0 + t_0))) / t_0)
end

MATLAB

function tmp = code(x, y)
	t_0 = max(x, y) + min(x, y);
	tmp = ((min(x, y) / t_0) * (max(x, y) / (1.0 + t_0))) / t_0;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[Min[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
	((tmp_2 / t_0) * (tmp_3 / ((1) + t_0))) / t_0
END code

Derivation

1. Initial program 69.5%

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

3. Applied rewrites 99.8%

   \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]
4. Add Preprocessing

Alternative 2: 99.8% accurate, 0.9× speedup

Math

\[\frac{\frac{x}{\left(y + x\right) + 1}}{y + x} \cdot \frac{y}{y + x} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (* (/ (/ x (+ (+ y x) 1.0)) (+ y x)) (/ y (+ y x))))

C

double code(double x, double y) {
	return ((x / ((y + x) + 1.0)) / (y + x)) * (y / (y + x));
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = ((x / ((y + x) + 1.0d0)) / (y + x)) * (y / (y + x))
end function

Java

public static double code(double x, double y) {
	return ((x / ((y + x) + 1.0)) / (y + x)) * (y / (y + x));
}

Python

def code(x, y):
	return ((x / ((y + x) + 1.0)) / (y + x)) * (y / (y + x))

Julia

function code(x, y)
	return Float64(Float64(Float64(x / Float64(Float64(y + x) + 1.0)) / Float64(y + x)) * Float64(y / Float64(y + x)))
end

MATLAB

function tmp = code(x, y)
	tmp = ((x / ((y + x) + 1.0)) / (y + x)) * (y / (y + x));
end

Wolfram

code[x_, y_] := N[(N[(N[(x / N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	((x / ((y + x) + (1))) / (y + x)) * (y / (y + x))
END code

Derivation

1. Initial program 69.5%

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

3. Applied rewrites 94.1%

   \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]
4. Step-by-step derivation

5. Applied rewrites 99.8%

   \[\leadsto \frac{\frac{x}{\left(y + x\right) + 1}}{y + x} \cdot \frac{y}{y + x} \]
6. Add Preprocessing

Alternative 3: 95.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ t_1 := \mathsf{min}\left(x, y\right) + \mathsf{max}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -4.832418080427271 \cdot 10^{+92}:\\ \;\;\;\;\frac{1 + -2 \cdot \frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}}{\mathsf{min}\left(x, y\right)} \cdot \frac{\mathsf{max}\left(x, y\right)}{t\_0}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -0.00035595720551977547:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{\left(t\_1 \cdot t\_1\right) \cdot \left(t\_1 + 1\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{t\_0}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y)))
       (t_1 (+ (fmin x y) (fmax x y))))
  (if (<= (fmin x y) -4.832418080427271e+92)
    (*
     (/ (+ 1.0 (* -2.0 (/ (fmax x y) (fmin x y)))) (fmin x y))
     (/ (fmax x y) t_0))
    (if (<= (fmin x y) -0.00035595720551977547)
      (/ (* (fmin x y) (fmax x y)) (* (* t_1 t_1) (+ t_1 1.0)))
      (/
       (* (/ (fmin x y) t_0) (/ (fmax x y) (+ 1.0 (fmax x y))))
       t_0)))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmin(x, y) + fmax(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.00035595720551977547) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (t_1 + 1.0));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    t_1 = fmin(x, y) + fmax(x, y)
    if (fmin(x, y) <= (-4.832418080427271d+92)) then
        tmp = ((1.0d0 + ((-2.0d0) * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
    else if (fmin(x, y) <= (-0.00035595720551977547d0)) then
        tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (t_1 + 1.0d0))
    else
        tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0d0 + fmax(x, y)))) / t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmin(x, y) + fmax(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.00035595720551977547) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (t_1 + 1.0));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	t_1 = fmin(x, y) + fmax(x, y)
	tmp = 0
	if fmin(x, y) <= -4.832418080427271e+92:
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
	elif fmin(x, y) <= -0.00035595720551977547:
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (t_1 + 1.0))
	else:
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	t_1 = Float64(fmin(x, y) + fmax(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -4.832418080427271e+92)
		tmp = Float64(Float64(Float64(1.0 + Float64(-2.0 * Float64(fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * Float64(fmax(x, y) / t_0));
	elseif (fmin(x, y) <= -0.00035595720551977547)
		tmp = Float64(Float64(fmin(x, y) * fmax(x, y)) / Float64(Float64(t_1 * t_1) * Float64(t_1 + 1.0)));
	else
		tmp = Float64(Float64(Float64(fmin(x, y) / t_0) * Float64(fmax(x, y) / Float64(1.0 + fmax(x, y)))) / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	t_1 = min(x, y) + max(x, y);
	tmp = 0.0;
	if (min(x, y) <= -4.832418080427271e+92)
		tmp = ((1.0 + (-2.0 * (max(x, y) / min(x, y)))) / min(x, y)) * (max(x, y) / t_0);
	elseif (min(x, y) <= -0.00035595720551977547)
		tmp = (min(x, y) * max(x, y)) / ((t_1 * t_1) * (t_1 + 1.0));
	else
		tmp = ((min(x, y) / t_0) * (max(x, y) / (1.0 + max(x, y)))) / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Min[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -4.832418080427271e+92], N[(N[(N[(1.0 + N[(-2.0 * N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -0.00035595720551977547], N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$1 * t$95$1), $MachinePrecision] * N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_1 = (tmp_2 + tmp_3) IN
			LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_13 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_17 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_18 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_19 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_20 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_21 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_22 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_16 = IF (tmp_17 <= (-3559572055197754675108512412151640091906301677227020263671875e-64)) THEN ((tmp_18 * tmp_19) / ((t_1 * t_1) * (t_1 + (1)))) ELSE (((tmp_20 / t_0) * (tmp_21 / ((1) + tmp_22))) / t_0) ENDIF IN
			LET tmp_8 = IF (tmp_9 <= (-483241808042727103589791072807956016134958690907829703685124163374201508985742814929148182528)) THEN ((((1) + ((-2) * (tmp_10 / tmp_11))) / tmp_12) * (tmp_13 / t_0)) ELSE tmp_16 ENDIF IN
	tmp_8
END code

Derivation

1. Split input into 3 regimes

2. if x < -4.832418080427271e92

   1. Initial program 69.5%

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

   3. Applied rewrites 94.1%

      \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]

   4. Taylor expanded in x around inf

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.9%

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]

   7. Taylor expanded in y around inf

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]
   8. Step-by-step derivation

   9. Applied rewrites 38.0%

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]

   if -4.832418080427271e92 < x < -3.5595720551977547e-4

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   if -3.5595720551977547e-4 < x

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 94.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -1.2284272272279392 \cdot 10^{+53}:\\ \;\;\;\;\frac{1 + -2 \cdot \frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}}{\mathsf{min}\left(x, y\right)} \cdot \frac{\mathsf{max}\left(x, y\right)}{t\_0}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -0.00035595720551977547:\\ \;\;\;\;\mathsf{min}\left(x, y\right) \cdot \frac{\mathsf{max}\left(x, y\right)}{\left(1 + t\_0\right) \cdot \left(t\_0 \cdot t\_0\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{t\_0}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))))
  (if (<= (fmin x y) -1.2284272272279392e+53)
    (*
     (/ (+ 1.0 (* -2.0 (/ (fmax x y) (fmin x y)))) (fmin x y))
     (/ (fmax x y) t_0))
    (if (<= (fmin x y) -0.00035595720551977547)
      (* (fmin x y) (/ (fmax x y) (* (+ 1.0 t_0) (* t_0 t_0))))
      (/
       (* (/ (fmin x y) t_0) (/ (fmax x y) (+ 1.0 (fmax x y))))
       t_0)))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -1.2284272272279392e+53) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.00035595720551977547) {
		tmp = fmin(x, y) * (fmax(x, y) / ((1.0 + t_0) * (t_0 * t_0)));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    if (fmin(x, y) <= (-1.2284272272279392d+53)) then
        tmp = ((1.0d0 + ((-2.0d0) * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
    else if (fmin(x, y) <= (-0.00035595720551977547d0)) then
        tmp = fmin(x, y) * (fmax(x, y) / ((1.0d0 + t_0) * (t_0 * t_0)))
    else
        tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0d0 + fmax(x, y)))) / t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -1.2284272272279392e+53) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.00035595720551977547) {
		tmp = fmin(x, y) * (fmax(x, y) / ((1.0 + t_0) * (t_0 * t_0)));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmin(x, y) <= -1.2284272272279392e+53:
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
	elif fmin(x, y) <= -0.00035595720551977547:
		tmp = fmin(x, y) * (fmax(x, y) / ((1.0 + t_0) * (t_0 * t_0)))
	else:
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -1.2284272272279392e+53)
		tmp = Float64(Float64(Float64(1.0 + Float64(-2.0 * Float64(fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * Float64(fmax(x, y) / t_0));
	elseif (fmin(x, y) <= -0.00035595720551977547)
		tmp = Float64(fmin(x, y) * Float64(fmax(x, y) / Float64(Float64(1.0 + t_0) * Float64(t_0 * t_0))));
	else
		tmp = Float64(Float64(Float64(fmin(x, y) / t_0) * Float64(fmax(x, y) / Float64(1.0 + fmax(x, y)))) / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (min(x, y) <= -1.2284272272279392e+53)
		tmp = ((1.0 + (-2.0 * (max(x, y) / min(x, y)))) / min(x, y)) * (max(x, y) / t_0);
	elseif (min(x, y) <= -0.00035595720551977547)
		tmp = min(x, y) * (max(x, y) / ((1.0 + t_0) * (t_0 * t_0)));
	else
		tmp = ((min(x, y) / t_0) * (max(x, y) / (1.0 + max(x, y)))) / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -1.2284272272279392e+53], N[(N[(N[(1.0 + N[(-2.0 * N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -0.00035595720551977547], N[(N[Min[x, y], $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(N[(1.0 + t$95$0), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_15 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_16 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_17 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_18 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_19 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_20 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_14 = IF (tmp_15 <= (-3559572055197754675108512412151640091906301677227020263671875e-64)) THEN (tmp_16 * (tmp_17 / (((1) + t_0) * (t_0 * t_0)))) ELSE (((tmp_18 / t_0) * (tmp_19 / ((1) + tmp_20))) / t_0) ENDIF IN
		LET tmp_6 = IF (tmp_7 <= (-122842722722793915309060656456844327352598161686265856)) THEN ((((1) + ((-2) * (tmp_8 / tmp_9))) / tmp_10) * (tmp_11 / t_0)) ELSE tmp_14 ENDIF IN
	tmp_6
END code

Derivation

1. Split input into 3 regimes

2. if x < -1.2284272272279392e53

   1. Initial program 69.5%

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

   3. Applied rewrites 94.1%

      \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]

   4. Taylor expanded in x around inf

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.9%

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]

   7. Taylor expanded in y around inf

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]
   8. Step-by-step derivation

   9. Applied rewrites 38.0%

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]

   if -1.2284272272279392e53 < x < -3.5595720551977547e-4

   1. Initial program 69.5%

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

   3. Applied rewrites 83.0%

      \[\leadsto x \cdot \frac{y}{\left(1 + \left(y + x\right)\right) \cdot \left(\left(y + x\right) \cdot \left(y + x\right)\right)} \]

   if -3.5595720551977547e-4 < x

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 94.3% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ t_1 := \frac{\mathsf{max}\left(x, y\right)}{t\_0}\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -2.063735682786578 \cdot 10^{+104}:\\ \;\;\;\;\frac{1 + -2 \cdot \frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}}{\mathsf{min}\left(x, y\right)} \cdot t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{\left(1 + t\_0\right) \cdot t\_0} \cdot t\_1\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))) (t_1 (/ (fmax x y) t_0)))
  (if (<= (fmin x y) -2.063735682786578e+104)
    (* (/ (+ 1.0 (* -2.0 (/ (fmax x y) (fmin x y)))) (fmin x y)) t_1)
    (* (/ (fmin x y) (* (+ 1.0 t_0) t_0)) t_1))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmax(x, y) / t_0;
	double tmp;
	if (fmin(x, y) <= -2.063735682786578e+104) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * t_1;
	} else {
		tmp = (fmin(x, y) / ((1.0 + t_0) * t_0)) * t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    t_1 = fmax(x, y) / t_0
    if (fmin(x, y) <= (-2.063735682786578d+104)) then
        tmp = ((1.0d0 + ((-2.0d0) * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * t_1
    else
        tmp = (fmin(x, y) / ((1.0d0 + t_0) * t_0)) * t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmax(x, y) / t_0;
	double tmp;
	if (fmin(x, y) <= -2.063735682786578e+104) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * t_1;
	} else {
		tmp = (fmin(x, y) / ((1.0 + t_0) * t_0)) * t_1;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	t_1 = fmax(x, y) / t_0
	tmp = 0
	if fmin(x, y) <= -2.063735682786578e+104:
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * t_1
	else:
		tmp = (fmin(x, y) / ((1.0 + t_0) * t_0)) * t_1
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	t_1 = Float64(fmax(x, y) / t_0)
	tmp = 0.0
	if (fmin(x, y) <= -2.063735682786578e+104)
		tmp = Float64(Float64(Float64(1.0 + Float64(-2.0 * Float64(fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * t_1);
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(Float64(1.0 + t_0) * t_0)) * t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	t_1 = max(x, y) / t_0;
	tmp = 0.0;
	if (min(x, y) <= -2.063735682786578e+104)
		tmp = ((1.0 + (-2.0 * (max(x, y) / min(x, y)))) / min(x, y)) * t_1;
	else
		tmp = (min(x, y) / ((1.0 + t_0) * t_0)) * t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -2.063735682786578e+104], N[(N[(N[(1.0 + N[(-2.0 * N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(N[(1.0 + t$95$0), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_1 = (tmp_2 / t_0) IN
			LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_6 = IF (tmp_7 <= (-206373568278657785519738576409250383628800139267543487699446927265062332726966809518658833468763037237248)) THEN ((((1) + ((-2) * (tmp_8 / tmp_9))) / tmp_10) * t_1) ELSE ((tmp_11 / (((1) + t_0) * t_0)) * t_1) ENDIF IN
	tmp_6
END code

Derivation

1. Split input into 2 regimes

2. if x < -2.0637356827865779e104

   1. Initial program 69.5%

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

   3. Applied rewrites 94.1%

      \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]

   4. Taylor expanded in x around inf

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.9%

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]

   7. Taylor expanded in y around inf

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]
   8. Step-by-step derivation

   9. Applied rewrites 38.0%

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]

   if -2.0637356827865779e104 < x

   1. Initial program 69.5%

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

   3. Applied rewrites 94.1%

      \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 93.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ t_1 := \mathsf{min}\left(x, y\right) + \mathsf{max}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -4.832418080427271 \cdot 10^{+92}:\\ \;\;\;\;\frac{1 + -2 \cdot \frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}}{\mathsf{min}\left(x, y\right)} \cdot \frac{\mathsf{max}\left(x, y\right)}{t\_0}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -0.0006779981040265665:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{\left(t\_1 \cdot t\_1\right) \cdot \left(1 + \mathsf{min}\left(x, y\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{t\_0}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y)))
       (t_1 (+ (fmin x y) (fmax x y))))
  (if (<= (fmin x y) -4.832418080427271e+92)
    (*
     (/ (+ 1.0 (* -2.0 (/ (fmax x y) (fmin x y)))) (fmin x y))
     (/ (fmax x y) t_0))
    (if (<= (fmin x y) -0.0006779981040265665)
      (/ (* (fmin x y) (fmax x y)) (* (* t_1 t_1) (+ 1.0 (fmin x y))))
      (/
       (* (/ (fmin x y) t_0) (/ (fmax x y) (+ 1.0 (fmax x y))))
       t_0)))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmin(x, y) + fmax(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (1.0 + fmin(x, y)));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    t_1 = fmin(x, y) + fmax(x, y)
    if (fmin(x, y) <= (-4.832418080427271d+92)) then
        tmp = ((1.0d0 + ((-2.0d0) * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
    else if (fmin(x, y) <= (-0.0006779981040265665d0)) then
        tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (1.0d0 + fmin(x, y)))
    else
        tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0d0 + fmax(x, y)))) / t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double t_1 = fmin(x, y) + fmax(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0);
	} else if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (1.0 + fmin(x, y)));
	} else {
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	t_1 = fmin(x, y) + fmax(x, y)
	tmp = 0
	if fmin(x, y) <= -4.832418080427271e+92:
		tmp = ((1.0 + (-2.0 * (fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * (fmax(x, y) / t_0)
	elif fmin(x, y) <= -0.0006779981040265665:
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_1 * t_1) * (1.0 + fmin(x, y)))
	else:
		tmp = ((fmin(x, y) / t_0) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	t_1 = Float64(fmin(x, y) + fmax(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -4.832418080427271e+92)
		tmp = Float64(Float64(Float64(1.0 + Float64(-2.0 * Float64(fmax(x, y) / fmin(x, y)))) / fmin(x, y)) * Float64(fmax(x, y) / t_0));
	elseif (fmin(x, y) <= -0.0006779981040265665)
		tmp = Float64(Float64(fmin(x, y) * fmax(x, y)) / Float64(Float64(t_1 * t_1) * Float64(1.0 + fmin(x, y))));
	else
		tmp = Float64(Float64(Float64(fmin(x, y) / t_0) * Float64(fmax(x, y) / Float64(1.0 + fmax(x, y)))) / t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	t_1 = min(x, y) + max(x, y);
	tmp = 0.0;
	if (min(x, y) <= -4.832418080427271e+92)
		tmp = ((1.0 + (-2.0 * (max(x, y) / min(x, y)))) / min(x, y)) * (max(x, y) / t_0);
	elseif (min(x, y) <= -0.0006779981040265665)
		tmp = (min(x, y) * max(x, y)) / ((t_1 * t_1) * (1.0 + min(x, y)));
	else
		tmp = ((min(x, y) / t_0) * (max(x, y) / (1.0 + max(x, y)))) / t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Min[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -4.832418080427271e+92], N[(N[(N[(1.0 + N[(-2.0 * N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -0.0006779981040265665], N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$1 * t$95$1), $MachinePrecision] * N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_1 = (tmp_2 + tmp_3) IN
			LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_13 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_18 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_19 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_20 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_21 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_22 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_23 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_24 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_17 = IF (tmp_18 <= (-677998104026566517955887380963986288406886160373687744140625e-63)) THEN ((tmp_19 * tmp_20) / ((t_1 * t_1) * ((1) + tmp_21))) ELSE (((tmp_22 / t_0) * (tmp_23 / ((1) + tmp_24))) / t_0) ENDIF IN
			LET tmp_8 = IF (tmp_9 <= (-483241808042727103589791072807956016134958690907829703685124163374201508985742814929148182528)) THEN ((((1) + ((-2) * (tmp_10 / tmp_11))) / tmp_12) * (tmp_13 / t_0)) ELSE tmp_17 ENDIF IN
	tmp_8
END code

Derivation

1. Split input into 3 regimes

2. if x < -4.832418080427271e92

   1. Initial program 69.5%

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

   3. Applied rewrites 94.1%

      \[\leadsto \frac{x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)} \cdot \frac{y}{y + x} \]

   4. Taylor expanded in x around inf

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.9%

      \[\leadsto \frac{1 + -1 \cdot \frac{1 + 2 \cdot y}{x}}{x} \cdot \frac{y}{y + x} \]

   7. Taylor expanded in y around inf

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]
   8. Step-by-step derivation

   9. Applied rewrites 38.0%

      \[\leadsto \frac{1 + -2 \cdot \frac{y}{x}}{x} \cdot \frac{y}{y + x} \]

   if -4.832418080427271e92 < x < -6.7799810402656652e-4

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]

   if -6.7799810402656652e-4 < x

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 93.5% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(x, y\right) + \mathsf{max}\left(x, y\right)\\ t_1 := 1 + \mathsf{min}\left(x, y\right)\\ t_2 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -4.832418080427271 \cdot 10^{+92}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{t\_1}}{t\_2}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -0.0006779981040265665:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{\left(t\_0 \cdot t\_0\right) \cdot t\_1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{t\_2} \cdot \frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{t\_2}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmin x y) (fmax x y)))
       (t_1 (+ 1.0 (fmin x y)))
       (t_2 (+ (fmax x y) (fmin x y))))
  (if (<= (fmin x y) -4.832418080427271e+92)
    (/ (/ (fmax x y) t_1) t_2)
    (if (<= (fmin x y) -0.0006779981040265665)
      (/ (* (fmin x y) (fmax x y)) (* (* t_0 t_0) t_1))
      (/
       (* (/ (fmin x y) t_2) (/ (fmax x y) (+ 1.0 (fmax x y))))
       t_2)))))

C

double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else {
		tmp = ((fmin(x, y) / t_2) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = fmin(x, y) + fmax(x, y)
    t_1 = 1.0d0 + fmin(x, y)
    t_2 = fmax(x, y) + fmin(x, y)
    if (fmin(x, y) <= (-4.832418080427271d+92)) then
        tmp = (fmax(x, y) / t_1) / t_2
    else if (fmin(x, y) <= (-0.0006779981040265665d0)) then
        tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
    else
        tmp = ((fmin(x, y) / t_2) * (fmax(x, y) / (1.0d0 + fmax(x, y)))) / t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else {
		tmp = ((fmin(x, y) / t_2) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_2;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmin(x, y) + fmax(x, y)
	t_1 = 1.0 + fmin(x, y)
	t_2 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmin(x, y) <= -4.832418080427271e+92:
		tmp = (fmax(x, y) / t_1) / t_2
	elif fmin(x, y) <= -0.0006779981040265665:
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
	else:
		tmp = ((fmin(x, y) / t_2) * (fmax(x, y) / (1.0 + fmax(x, y)))) / t_2
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmin(x, y) + fmax(x, y))
	t_1 = Float64(1.0 + fmin(x, y))
	t_2 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -4.832418080427271e+92)
		tmp = Float64(Float64(fmax(x, y) / t_1) / t_2);
	elseif (fmin(x, y) <= -0.0006779981040265665)
		tmp = Float64(Float64(fmin(x, y) * fmax(x, y)) / Float64(Float64(t_0 * t_0) * t_1));
	else
		tmp = Float64(Float64(Float64(fmin(x, y) / t_2) * Float64(fmax(x, y) / Float64(1.0 + fmax(x, y)))) / t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = min(x, y) + max(x, y);
	t_1 = 1.0 + min(x, y);
	t_2 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (min(x, y) <= -4.832418080427271e+92)
		tmp = (max(x, y) / t_1) / t_2;
	elseif (min(x, y) <= -0.0006779981040265665)
		tmp = (min(x, y) * max(x, y)) / ((t_0 * t_0) * t_1);
	else
		tmp = ((min(x, y) / t_2) * (max(x, y) / (1.0 + max(x, y)))) / t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Min[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -4.832418080427271e+92], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -0.0006779981040265665], N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Min[x, y], $MachinePrecision] / t$95$2), $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET t_1 = ((1) + tmp_2) IN
			LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_4 = IF (x < y) THEN x ELSE y ENDIF IN
			LET t_2 = (tmp_3 + tmp_4) IN
				LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_13 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_14 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_15 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_16 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_17 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_11 = IF (tmp_12 <= (-677998104026566517955887380963986288406886160373687744140625e-63)) THEN ((tmp_13 * tmp_14) / ((t_0 * t_0) * t_1)) ELSE (((tmp_15 / t_2) * (tmp_16 / ((1) + tmp_17))) / t_2) ENDIF IN
				LET tmp_6 = IF (tmp_7 <= (-483241808042727103589791072807956016134958690907829703685124163374201508985742814929148182528)) THEN ((tmp_8 / t_1) / t_2) ELSE tmp_11 ENDIF IN
	tmp_6
END code

Derivation

1. Split input into 3 regimes

2. if x < -4.832418080427271e92

   1. Initial program 69.5%

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

   3. Applied rewrites 74.3%

      \[\leadsto \frac{\frac{y \cdot x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.6%

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]

   if -4.832418080427271e92 < x < -6.7799810402656652e-4

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]

   if -6.7799810402656652e-4 < x

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 93.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(x, y\right) + \mathsf{max}\left(x, y\right)\\ t_1 := 1 + \mathsf{min}\left(x, y\right)\\ t_2 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -4.832418080427271 \cdot 10^{+92}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{t\_1}}{t\_2}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -5.6621694200838834 \cdot 10^{-37}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{\left(t\_0 \cdot t\_0\right) \cdot t\_1}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -2.943723238997568 \cdot 10^{-233}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{t\_2} \cdot \frac{\mathsf{min}\left(x, y\right)}{t\_2 \cdot 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmin x y) (fmax x y)))
       (t_1 (+ 1.0 (fmin x y)))
       (t_2 (+ (fmax x y) (fmin x y))))
  (if (<= (fmin x y) -4.832418080427271e+92)
    (/ (/ (fmax x y) t_1) t_2)
    (if (<= (fmin x y) -5.6621694200838834e-37)
      (/ (* (fmin x y) (fmax x y)) (* (* t_0 t_0) t_1))
      (if (<= (fmin x y) -2.943723238997568e-233)
        (* (/ (fmax x y) t_2) (/ (fmin x y) (* t_2 1.0)))
        (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y)))))))

C

double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -5.6621694200838834e-37) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * 1.0));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = fmin(x, y) + fmax(x, y)
    t_1 = 1.0d0 + fmin(x, y)
    t_2 = fmax(x, y) + fmin(x, y)
    if (fmin(x, y) <= (-4.832418080427271d+92)) then
        tmp = (fmax(x, y) / t_1) / t_2
    else if (fmin(x, y) <= (-5.6621694200838834d-37)) then
        tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
    else if (fmin(x, y) <= (-2.943723238997568d-233)) then
        tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * 1.0d0))
    else
        tmp = (fmin(x, y) / (1.0d0 + fmax(x, y))) / fmax(x, y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -5.6621694200838834e-37) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * 1.0));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmin(x, y) + fmax(x, y)
	t_1 = 1.0 + fmin(x, y)
	t_2 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmin(x, y) <= -4.832418080427271e+92:
		tmp = (fmax(x, y) / t_1) / t_2
	elif fmin(x, y) <= -5.6621694200838834e-37:
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
	elif fmin(x, y) <= -2.943723238997568e-233:
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * 1.0))
	else:
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmin(x, y) + fmax(x, y))
	t_1 = Float64(1.0 + fmin(x, y))
	t_2 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -4.832418080427271e+92)
		tmp = Float64(Float64(fmax(x, y) / t_1) / t_2);
	elseif (fmin(x, y) <= -5.6621694200838834e-37)
		tmp = Float64(Float64(fmin(x, y) * fmax(x, y)) / Float64(Float64(t_0 * t_0) * t_1));
	elseif (fmin(x, y) <= -2.943723238997568e-233)
		tmp = Float64(Float64(fmax(x, y) / t_2) * Float64(fmin(x, y) / Float64(t_2 * 1.0)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = min(x, y) + max(x, y);
	t_1 = 1.0 + min(x, y);
	t_2 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (min(x, y) <= -4.832418080427271e+92)
		tmp = (max(x, y) / t_1) / t_2;
	elseif (min(x, y) <= -5.6621694200838834e-37)
		tmp = (min(x, y) * max(x, y)) / ((t_0 * t_0) * t_1);
	elseif (min(x, y) <= -2.943723238997568e-233)
		tmp = (max(x, y) / t_2) * (min(x, y) / (t_2 * 1.0));
	else
		tmp = (min(x, y) / (1.0 + max(x, y))) / max(x, y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Min[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -4.832418080427271e+92], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -5.6621694200838834e-37], N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -2.943723238997568e-233], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$2), $MachinePrecision] * N[(N[Min[x, y], $MachinePrecision] / N[(t$95$2 * 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET t_1 = ((1) + tmp_2) IN
			LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_4 = IF (x < y) THEN x ELSE y ENDIF IN
			LET t_2 = (tmp_3 + tmp_4) IN
				LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_13 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_14 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_18 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_19 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_20 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_21 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_22 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_23 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_17 = IF (tmp_18 <= (-29437232389975679817471620374825575281835272629403159291902728104514996288633937583980764683839746185840355405783133179655426703125548734368937712704729003603273088964630288897455413702595423994734578258604454717401772405417431626420738050615627531772538912679018735146694529866610446338057090750780058325113433447355216521304507853419201146922495203007503697167910869302228226431849943726580425298621213791183669160522480943971623899086048018865213585806784185798551520503427286629607129990155825377555763076181557262796264909702881301562902852789519424214770282333120121620595455169677734375e-825)) THEN ((tmp_19 / t_2) * (tmp_20 / (t_2 * (1)))) ELSE ((tmp_21 / ((1) + tmp_22)) / tmp_23) ENDIF IN
				LET tmp_11 = IF (tmp_12 <= (-56621694200838834317338517880335262404079887943758423343748178264706560066602814940479906406453104728004888102077529765665531158447265625e-173)) THEN ((tmp_13 * tmp_14) / ((t_0 * t_0) * t_1)) ELSE tmp_17 ENDIF IN
				LET tmp_6 = IF (tmp_7 <= (-483241808042727103589791072807956016134958690907829703685124163374201508985742814929148182528)) THEN ((tmp_8 / t_1) / t_2) ELSE tmp_11 ENDIF IN
	tmp_6
END code

Derivation

1. Split input into 4 regimes

2. if x < -4.832418080427271e92

   1. Initial program 69.5%

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

   3. Applied rewrites 74.3%

      \[\leadsto \frac{\frac{y \cdot x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.6%

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]

   if -4.832418080427271e92 < x < -5.6621694200838834e-37

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]

   if -5.6621694200838834e-37 < x < -2.943723238997568e-233

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 76.6%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot \left(1 + x\right)} \]

   7. Taylor expanded in x around 0

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot 1} \]
   8. Step-by-step derivation

   9. Applied rewrites 51.8%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot 1} \]

   if -2.943723238997568e-233 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 9: 91.8% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{min}\left(x, y\right) + \mathsf{max}\left(x, y\right)\\ t_1 := 1 + \mathsf{min}\left(x, y\right)\\ t_2 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -4.832418080427271 \cdot 10^{+92}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{t\_1}}{t\_2}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -5.6621694200838834 \cdot 10^{-37}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{\left(t\_0 \cdot t\_0\right) \cdot t\_1}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -2.943723238997568 \cdot 10^{-233}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{t\_2} \cdot \frac{\mathsf{min}\left(x, y\right)}{t\_2 \cdot t\_1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmin x y) (fmax x y)))
       (t_1 (+ 1.0 (fmin x y)))
       (t_2 (+ (fmax x y) (fmin x y))))
  (if (<= (fmin x y) -4.832418080427271e+92)
    (/ (/ (fmax x y) t_1) t_2)
    (if (<= (fmin x y) -5.6621694200838834e-37)
      (/ (* (fmin x y) (fmax x y)) (* (* t_0 t_0) t_1))
      (if (<= (fmin x y) -2.943723238997568e-233)
        (* (/ (fmax x y) t_2) (/ (fmin x y) (* t_2 t_1)))
        (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y)))))))

C

double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -5.6621694200838834e-37) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * t_1));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = fmin(x, y) + fmax(x, y)
    t_1 = 1.0d0 + fmin(x, y)
    t_2 = fmax(x, y) + fmin(x, y)
    if (fmin(x, y) <= (-4.832418080427271d+92)) then
        tmp = (fmax(x, y) / t_1) / t_2
    else if (fmin(x, y) <= (-5.6621694200838834d-37)) then
        tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
    else if (fmin(x, y) <= (-2.943723238997568d-233)) then
        tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * t_1))
    else
        tmp = (fmin(x, y) / (1.0d0 + fmax(x, y))) / fmax(x, y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmin(x, y) + fmax(x, y);
	double t_1 = 1.0 + fmin(x, y);
	double t_2 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -4.832418080427271e+92) {
		tmp = (fmax(x, y) / t_1) / t_2;
	} else if (fmin(x, y) <= -5.6621694200838834e-37) {
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1);
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * t_1));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmin(x, y) + fmax(x, y)
	t_1 = 1.0 + fmin(x, y)
	t_2 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmin(x, y) <= -4.832418080427271e+92:
		tmp = (fmax(x, y) / t_1) / t_2
	elif fmin(x, y) <= -5.6621694200838834e-37:
		tmp = (fmin(x, y) * fmax(x, y)) / ((t_0 * t_0) * t_1)
	elif fmin(x, y) <= -2.943723238997568e-233:
		tmp = (fmax(x, y) / t_2) * (fmin(x, y) / (t_2 * t_1))
	else:
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmin(x, y) + fmax(x, y))
	t_1 = Float64(1.0 + fmin(x, y))
	t_2 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -4.832418080427271e+92)
		tmp = Float64(Float64(fmax(x, y) / t_1) / t_2);
	elseif (fmin(x, y) <= -5.6621694200838834e-37)
		tmp = Float64(Float64(fmin(x, y) * fmax(x, y)) / Float64(Float64(t_0 * t_0) * t_1));
	elseif (fmin(x, y) <= -2.943723238997568e-233)
		tmp = Float64(Float64(fmax(x, y) / t_2) * Float64(fmin(x, y) / Float64(t_2 * t_1)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = min(x, y) + max(x, y);
	t_1 = 1.0 + min(x, y);
	t_2 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (min(x, y) <= -4.832418080427271e+92)
		tmp = (max(x, y) / t_1) / t_2;
	elseif (min(x, y) <= -5.6621694200838834e-37)
		tmp = (min(x, y) * max(x, y)) / ((t_0 * t_0) * t_1);
	elseif (min(x, y) <= -2.943723238997568e-233)
		tmp = (max(x, y) / t_2) * (min(x, y) / (t_2 * t_1));
	else
		tmp = (min(x, y) / (1.0 + max(x, y))) / max(x, y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Min[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -4.832418080427271e+92], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -5.6621694200838834e-37], N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -2.943723238997568e-233], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$2), $MachinePrecision] * N[(N[Min[x, y], $MachinePrecision] / N[(t$95$2 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
		LET t_1 = ((1) + tmp_2) IN
			LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_4 = IF (x < y) THEN x ELSE y ENDIF IN
			LET t_2 = (tmp_3 + tmp_4) IN
				LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_13 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_14 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_18 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_19 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_20 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_21 = IF (x < y) THEN x ELSE y ENDIF IN
				LET tmp_22 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_23 = IF (x > y) THEN x ELSE y ENDIF IN
				LET tmp_17 = IF (tmp_18 <= (-29437232389975679817471620374825575281835272629403159291902728104514996288633937583980764683839746185840355405783133179655426703125548734368937712704729003603273088964630288897455413702595423994734578258604454717401772405417431626420738050615627531772538912679018735146694529866610446338057090750780058325113433447355216521304507853419201146922495203007503697167910869302228226431849943726580425298621213791183669160522480943971623899086048018865213585806784185798551520503427286629607129990155825377555763076181557262796264909702881301562902852789519424214770282333120121620595455169677734375e-825)) THEN ((tmp_19 / t_2) * (tmp_20 / (t_2 * t_1))) ELSE ((tmp_21 / ((1) + tmp_22)) / tmp_23) ENDIF IN
				LET tmp_11 = IF (tmp_12 <= (-56621694200838834317338517880335262404079887943758423343748178264706560066602814940479906406453104728004888102077529765665531158447265625e-173)) THEN ((tmp_13 * tmp_14) / ((t_0 * t_0) * t_1)) ELSE tmp_17 ENDIF IN
				LET tmp_6 = IF (tmp_7 <= (-483241808042727103589791072807956016134958690907829703685124163374201508985742814929148182528)) THEN ((tmp_8 / t_1) / t_2) ELSE tmp_11 ENDIF IN
	tmp_6
END code

Derivation

1. Split input into 4 regimes

2. if x < -4.832418080427271e92

   1. Initial program 69.5%

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

   3. Applied rewrites 74.3%

      \[\leadsto \frac{\frac{y \cdot x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.6%

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]

   if -4.832418080427271e92 < x < -5.6621694200838834e-37

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]

   if -5.6621694200838834e-37 < x < -2.943723238997568e-233

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 76.6%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot \left(1 + x\right)} \]

   if -2.943723238997568e-233 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 10: 87.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{max}\left(x, y\right) \leq 5289.429093451547:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{t\_0}}{\mathsf{min}\left(x, y\right) - -1} \cdot \frac{\mathsf{min}\left(x, y\right)}{t\_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)} \cdot \mathsf{min}\left(x, y\right)}{t\_0 \cdot t\_0}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))))
  (if (<= (fmax x y) 5289.429093451547)
    (* (/ (/ (fmax x y) t_0) (- (fmin x y) -1.0)) (/ (fmin x y) t_0))
    (/ (* (/ (fmax x y) (+ 1.0 (fmax x y))) (fmin x y)) (* t_0 t_0)))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmax(x, y) <= 5289.429093451547) {
		tmp = ((fmax(x, y) / t_0) / (fmin(x, y) - -1.0)) * (fmin(x, y) / t_0);
	} else {
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    if (fmax(x, y) <= 5289.429093451547d0) then
        tmp = ((fmax(x, y) / t_0) / (fmin(x, y) - (-1.0d0))) * (fmin(x, y) / t_0)
    else
        tmp = ((fmax(x, y) / (1.0d0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmax(x, y) <= 5289.429093451547) {
		tmp = ((fmax(x, y) / t_0) / (fmin(x, y) - -1.0)) * (fmin(x, y) / t_0);
	} else {
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmax(x, y) <= 5289.429093451547:
		tmp = ((fmax(x, y) / t_0) / (fmin(x, y) - -1.0)) * (fmin(x, y) / t_0)
	else:
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmax(x, y) <= 5289.429093451547)
		tmp = Float64(Float64(Float64(fmax(x, y) / t_0) / Float64(fmin(x, y) - -1.0)) * Float64(fmin(x, y) / t_0));
	else
		tmp = Float64(Float64(Float64(fmax(x, y) / Float64(1.0 + fmax(x, y))) * fmin(x, y)) / Float64(t_0 * t_0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (max(x, y) <= 5289.429093451547)
		tmp = ((max(x, y) / t_0) / (min(x, y) - -1.0)) * (min(x, y) / t_0);
	else
		tmp = ((max(x, y) / (1.0 + max(x, y))) * min(x, y)) / (t_0 * t_0);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Max[x, y], $MachinePrecision], 5289.429093451547], N[(N[(N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] / N[(N[Min[x, y], $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Min[x, y], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (tmp_6 <= (5289429093451546577853150665760040283203125e-39)) THEN (((tmp_7 / t_0) / (tmp_8 - (-1))) * (tmp_9 / t_0)) ELSE (((tmp_10 / ((1) + tmp_11)) * tmp_12) / (t_0 * t_0)) ENDIF IN
	tmp_5
END code

Derivation

1. Split input into 2 regimes

2. if y < 5289.4290934515466

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 76.6%

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

   8. Applied rewrites 75.4%

      \[\leadsto \frac{\frac{y}{y + x}}{x - -1} \cdot \frac{x}{y + x} \]

   if 5289.4290934515466 < y

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   7. Step-by-step derivation

   8. Applied rewrites 70.6%

      \[\leadsto \frac{\frac{y}{1 + y} \cdot x}{\left(y + x\right) \cdot \left(y + x\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 87.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{max}\left(x, y\right) \leq 18215.542799214112:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{min}\left(x, y\right)}{t\_0 \cdot \left(1 + \mathsf{min}\left(x, y\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)} \cdot \mathsf{min}\left(x, y\right)}{t\_0 \cdot t\_0}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))))
  (if (<= (fmax x y) 18215.542799214112)
    (* (/ (fmax x y) t_0) (/ (fmin x y) (* t_0 (+ 1.0 (fmin x y)))))
    (/ (* (/ (fmax x y) (+ 1.0 (fmax x y))) (fmin x y)) (* t_0 t_0)))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmax(x, y) <= 18215.542799214112) {
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * (1.0 + fmin(x, y))));
	} else {
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    if (fmax(x, y) <= 18215.542799214112d0) then
        tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * (1.0d0 + fmin(x, y))))
    else
        tmp = ((fmax(x, y) / (1.0d0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmax(x, y) <= 18215.542799214112) {
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * (1.0 + fmin(x, y))));
	} else {
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmax(x, y) <= 18215.542799214112:
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * (1.0 + fmin(x, y))))
	else:
		tmp = ((fmax(x, y) / (1.0 + fmax(x, y))) * fmin(x, y)) / (t_0 * t_0)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmax(x, y) <= 18215.542799214112)
		tmp = Float64(Float64(fmax(x, y) / t_0) * Float64(fmin(x, y) / Float64(t_0 * Float64(1.0 + fmin(x, y)))));
	else
		tmp = Float64(Float64(Float64(fmax(x, y) / Float64(1.0 + fmax(x, y))) * fmin(x, y)) / Float64(t_0 * t_0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (max(x, y) <= 18215.542799214112)
		tmp = (max(x, y) / t_0) * (min(x, y) / (t_0 * (1.0 + min(x, y))));
	else
		tmp = ((max(x, y) / (1.0 + max(x, y))) * min(x, y)) / (t_0 * t_0);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Max[x, y], $MachinePrecision], 18215.542799214112], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Min[x, y], $MachinePrecision] / N[(t$95$0 * N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (tmp_6 <= (182155427992141121649183332920074462890625e-37)) THEN ((tmp_7 / t_0) * (tmp_8 / (t_0 * ((1) + tmp_9)))) ELSE (((tmp_10 / ((1) + tmp_11)) * tmp_12) / (t_0 * t_0)) ENDIF IN
	tmp_5
END code

Derivation

1. Split input into 2 regimes

2. if y < 18215.542799214112

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 76.6%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot \left(1 + x\right)} \]

   if 18215.542799214112 < y

   1. Initial program 69.5%

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

   3. Applied rewrites 99.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in x around 0

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 75.8%

      \[\leadsto \frac{\frac{x}{y + x} \cdot \frac{y}{1 + y}}{y + x} \]
   7. Step-by-step derivation

   8. Applied rewrites 70.6%

      \[\leadsto \frac{\frac{y}{1 + y} \cdot x}{\left(y + x\right) \cdot \left(y + x\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 86.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_0 := \mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)\\ \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -0.0006779981040265665:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{min}\left(x, y\right)}}{t\_0}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -2.943723238997568 \cdot 10^{-233}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{t\_0} \cdot \frac{\mathsf{min}\left(x, y\right)}{t\_0 \cdot 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (+ (fmax x y) (fmin x y))))
  (if (<= (fmin x y) -0.0006779981040265665)
    (/ (/ (fmax x y) (+ 1.0 (fmin x y))) t_0)
    (if (<= (fmin x y) -2.943723238997568e-233)
      (* (/ (fmax x y) t_0) (/ (fmin x y) (* t_0 1.0)))
      (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y))))))

C

double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / t_0;
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * 1.0));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = fmax(x, y) + fmin(x, y)
    if (fmin(x, y) <= (-0.0006779981040265665d0)) then
        tmp = (fmax(x, y) / (1.0d0 + fmin(x, y))) / t_0
    else if (fmin(x, y) <= (-2.943723238997568d-233)) then
        tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * 1.0d0))
    else
        tmp = (fmin(x, y) / (1.0d0 + fmax(x, y))) / fmax(x, y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = fmax(x, y) + fmin(x, y);
	double tmp;
	if (fmin(x, y) <= -0.0006779981040265665) {
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / t_0;
	} else if (fmin(x, y) <= -2.943723238997568e-233) {
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * 1.0));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = fmax(x, y) + fmin(x, y)
	tmp = 0
	if fmin(x, y) <= -0.0006779981040265665:
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / t_0
	elif fmin(x, y) <= -2.943723238997568e-233:
		tmp = (fmax(x, y) / t_0) * (fmin(x, y) / (t_0 * 1.0))
	else:
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(fmax(x, y) + fmin(x, y))
	tmp = 0.0
	if (fmin(x, y) <= -0.0006779981040265665)
		tmp = Float64(Float64(fmax(x, y) / Float64(1.0 + fmin(x, y))) / t_0);
	elseif (fmin(x, y) <= -2.943723238997568e-233)
		tmp = Float64(Float64(fmax(x, y) / t_0) * Float64(fmin(x, y) / Float64(t_0 * 1.0)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = max(x, y) + min(x, y);
	tmp = 0.0;
	if (min(x, y) <= -0.0006779981040265665)
		tmp = (max(x, y) / (1.0 + min(x, y))) / t_0;
	elseif (min(x, y) <= -2.943723238997568e-233)
		tmp = (max(x, y) / t_0) * (min(x, y) / (t_0 * 1.0));
	else
		tmp = (min(x, y) / (1.0 + max(x, y))) / max(x, y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Min[x, y], $MachinePrecision], -0.0006779981040265665], N[(N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -2.943723238997568e-233], N[(N[(N[Max[x, y], $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Min[x, y], $MachinePrecision] / N[(t$95$0 * 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_0 = (tmp + tmp_1) IN
		LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_11 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_12 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_13 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_14 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_15 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_16 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_10 = IF (tmp_11 <= (-29437232389975679817471620374825575281835272629403159291902728104514996288633937583980764683839746185840355405783133179655426703125548734368937712704729003603273088964630288897455413702595423994734578258604454717401772405417431626420738050615627531772538912679018735146694529866610446338057090750780058325113433447355216521304507853419201146922495203007503697167910869302228226431849943726580425298621213791183669160522480943971623899086048018865213585806784185798551520503427286629607129990155825377555763076181557262796264909702881301562902852789519424214770282333120121620595455169677734375e-825)) THEN ((tmp_12 / t_0) * (tmp_13 / (t_0 * (1)))) ELSE ((tmp_14 / ((1) + tmp_15)) / tmp_16) ENDIF IN
		LET tmp_4 = IF (tmp_5 <= (-677998104026566517955887380963986288406886160373687744140625e-63)) THEN ((tmp_6 / ((1) + tmp_7)) / t_0) ELSE tmp_10 ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 3 regimes

2. if x < -6.7799810402656652e-4

   1. Initial program 69.5%

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

   3. Applied rewrites 74.3%

      \[\leadsto \frac{\frac{y \cdot x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.6%

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]

   if -6.7799810402656652e-4 < x < -2.943723238997568e-233

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 59.4%

      \[\leadsto \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 76.6%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot \left(1 + x\right)} \]

   7. Taylor expanded in x around 0

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot 1} \]
   8. Step-by-step derivation

   9. Applied rewrites 51.8%

      \[\leadsto \frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot 1} \]

   if -2.943723238997568e-233 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 13: 82.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -1.3482985076248934 \cdot 10^{-142}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{1 + \mathsf{min}\left(x, y\right)}}{\mathsf{max}\left(x, y\right) + \mathsf{min}\left(x, y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmin x y) -1.3482985076248934e-142)
  (/ (/ (fmax x y) (+ 1.0 (fmin x y))) (+ (fmax x y) (fmin x y)))
  (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y))))

C

double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / (fmax(x, y) + fmin(x, y));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (fmin(x, y) <= (-1.3482985076248934d-142)) then
        tmp = (fmax(x, y) / (1.0d0 + fmin(x, y))) / (fmax(x, y) + fmin(x, y))
    else
        tmp = (fmin(x, y) / (1.0d0 + fmax(x, y))) / fmax(x, y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / (fmax(x, y) + fmin(x, y));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if fmin(x, y) <= -1.3482985076248934e-142:
		tmp = (fmax(x, y) / (1.0 + fmin(x, y))) / (fmax(x, y) + fmin(x, y))
	else:
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (fmin(x, y) <= -1.3482985076248934e-142)
		tmp = Float64(Float64(fmax(x, y) / Float64(1.0 + fmin(x, y))) / Float64(fmax(x, y) + fmin(x, y)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (min(x, y) <= -1.3482985076248934e-142)
		tmp = (max(x, y) / (1.0 + min(x, y))) / (max(x, y) + min(x, y));
	else
		tmp = (min(x, y) / (1.0 + max(x, y))) / max(x, y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[N[Min[x, y], $MachinePrecision], -1.3482985076248934e-142], N[(N[(N[Max[x, y], $MachinePrecision] / N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Max[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_12 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_4 = IF (tmp_5 <= (-13482985076248933994375866967332925390428330676968730966443854002205855324050903946840969945407644961340629859896190416222921261219339892339120995941273411311408363821701136839568487662014930782308637526586203412982048230344459800019730904769927104623543829331813234722921263499373675320360744770696086816869704000845701744755631646137646940421250807418118711211718618869781494140625e-524)) THEN ((tmp_6 / ((1) + tmp_7)) / (tmp_8 + tmp_9)) ELSE ((tmp_10 / ((1) + tmp_11)) / tmp_12) ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 2 regimes

2. if x < -1.3482985076248934e-142

   1. Initial program 69.5%

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

   3. Applied rewrites 74.3%

      \[\leadsto \frac{\frac{y \cdot x}{\left(1 + \left(y + x\right)\right) \cdot \left(y + x\right)}}{y + x} \]

   4. Taylor expanded in y around 0

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.6%

      \[\leadsto \frac{\frac{y}{1 + x}}{y + x} \]

   if -1.3482985076248934e-142 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 82.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -1.3482985076248934 \cdot 10^{-142}:\\ \;\;\;\;\frac{\frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}}{1 + \mathsf{min}\left(x, y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmin x y) -1.3482985076248934e-142)
  (/ (/ (fmax x y) (fmin x y)) (+ 1.0 (fmin x y)))
  (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y))))

C

double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = (fmax(x, y) / fmin(x, y)) / (1.0 + fmin(x, y));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (fmin(x, y) <= (-1.3482985076248934d-142)) then
        tmp = (fmax(x, y) / fmin(x, y)) / (1.0d0 + fmin(x, y))
    else
        tmp = (fmin(x, y) / (1.0d0 + fmax(x, y))) / fmax(x, y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = (fmax(x, y) / fmin(x, y)) / (1.0 + fmin(x, y));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if fmin(x, y) <= -1.3482985076248934e-142:
		tmp = (fmax(x, y) / fmin(x, y)) / (1.0 + fmin(x, y))
	else:
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (fmin(x, y) <= -1.3482985076248934e-142)
		tmp = Float64(Float64(fmax(x, y) / fmin(x, y)) / Float64(1.0 + fmin(x, y)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (min(x, y) <= -1.3482985076248934e-142)
		tmp = (max(x, y) / min(x, y)) / (1.0 + min(x, y));
	else
		tmp = (min(x, y) / (1.0 + max(x, y))) / max(x, y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[N[Min[x, y], $MachinePrecision], -1.3482985076248934e-142], N[(N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_4 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_5 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_9 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_3 = IF (tmp_4 <= (-13482985076248933994375866967332925390428330676968730966443854002205855324050903946840969945407644961340629859896190416222921261219339892339120995941273411311408363821701136839568487662014930782308637526586203412982048230344459800019730904769927104623543829331813234722921263499373675320360744770696086816869704000845701744755631646137646940421250807418118711211718618869781494140625e-524)) THEN ((tmp_5 / tmp_6) / ((1) + tmp_7)) ELSE ((tmp_8 / ((1) + tmp_9)) / tmp_10) ENDIF IN
	tmp_3
END code

Derivation

1. Split input into 2 regimes

2. if x < -1.3482985076248934e-142

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.1%

      \[\leadsto \frac{\frac{y}{x}}{1 + x} \]

   if -1.3482985076248934e-142 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 15: 80.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -1.3482985076248934 \cdot 10^{-142}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{\mathsf{fma}\left(\mathsf{min}\left(x, y\right), \mathsf{min}\left(x, y\right), \mathsf{min}\left(x, y\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\mathsf{min}\left(x, y\right)}{1 + \mathsf{max}\left(x, y\right)}}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmin x y) -1.3482985076248934e-142)
  (/ (fmax x y) (fma (fmin x y) (fmin x y) (fmin x y)))
  (/ (/ (fmin x y) (+ 1.0 (fmax x y))) (fmax x y))))

C

double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = fmax(x, y) / fma(fmin(x, y), fmin(x, y), fmin(x, y));
	} else {
		tmp = (fmin(x, y) / (1.0 + fmax(x, y))) / fmax(x, y);
	}
	return tmp;
}

Julia

function code(x, y)
	tmp = 0.0
	if (fmin(x, y) <= -1.3482985076248934e-142)
		tmp = Float64(fmax(x, y) / fma(fmin(x, y), fmin(x, y), fmin(x, y)));
	else
		tmp = Float64(Float64(fmin(x, y) / Float64(1.0 + fmax(x, y))) / fmax(x, y));
	end
	return tmp
end

Wolfram

code[x_, y_] := If[LessEqual[N[Min[x, y], $MachinePrecision], -1.3482985076248934e-142], N[(N[Max[x, y], $MachinePrecision] / N[(N[Min[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / N[(1.0 + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_12 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_4 = IF (tmp_5 <= (-13482985076248933994375866967332925390428330676968730966443854002205855324050903946840969945407644961340629859896190416222921261219339892339120995941273411311408363821701136839568487662014930782308637526586203412982048230344459800019730904769927104623543829331813234722921263499373675320360744770696086816869704000845701744755631646137646940421250807418118711211718618869781494140625e-524)) THEN (tmp_6 / ((tmp_7 * tmp_8) + tmp_9)) ELSE ((tmp_10 / ((1) + tmp_11)) / tmp_12) ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 2 regimes

2. if x < -1.3482985076248934e-142

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.3%

      \[\leadsto \frac{y}{\mathsf{fma}\left(x, x, x\right)} \]

   if -1.3482985076248934e-142 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 50.7%

      \[\leadsto \frac{\frac{x}{1 + y}}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 16: 79.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -1.3482985076248934 \cdot 10^{-142}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{\mathsf{fma}\left(\mathsf{min}\left(x, y\right), \mathsf{min}\left(x, y\right), \mathsf{min}\left(x, y\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{\mathsf{fma}\left(\mathsf{max}\left(x, y\right), \mathsf{max}\left(x, y\right), \mathsf{max}\left(x, y\right)\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmin x y) -1.3482985076248934e-142)
  (/ (fmax x y) (fma (fmin x y) (fmin x y) (fmin x y)))
  (/ (fmin x y) (fma (fmax x y) (fmax x y) (fmax x y)))))

C

double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = fmax(x, y) / fma(fmin(x, y), fmin(x, y), fmin(x, y));
	} else {
		tmp = fmin(x, y) / fma(fmax(x, y), fmax(x, y), fmax(x, y));
	}
	return tmp;
}

Julia

function code(x, y)
	tmp = 0.0
	if (fmin(x, y) <= -1.3482985076248934e-142)
		tmp = Float64(fmax(x, y) / fma(fmin(x, y), fmin(x, y), fmin(x, y)));
	else
		tmp = Float64(fmin(x, y) / fma(fmax(x, y), fmax(x, y), fmax(x, y)));
	end
	return tmp
end

Wolfram

code[x_, y_] := If[LessEqual[N[Min[x, y], $MachinePrecision], -1.3482985076248934e-142], N[(N[Max[x, y], $MachinePrecision] / N[(N[Min[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision] + N[Min[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Min[x, y], $MachinePrecision] / N[(N[Max[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_12 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_13 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_4 = IF (tmp_5 <= (-13482985076248933994375866967332925390428330676968730966443854002205855324050903946840969945407644961340629859896190416222921261219339892339120995941273411311408363821701136839568487662014930782308637526586203412982048230344459800019730904769927104623543829331813234722921263499373675320360744770696086816869704000845701744755631646137646940421250807418118711211718618869781494140625e-524)) THEN (tmp_6 / ((tmp_7 * tmp_8) + tmp_9)) ELSE (tmp_10 / ((tmp_11 * tmp_12) + tmp_13)) ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 2 regimes

2. if x < -1.3482985076248934e-142

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.3%

      \[\leadsto \frac{y}{\mathsf{fma}\left(x, x, x\right)} \]

   if -1.3482985076248934e-142 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.2%

      \[\leadsto \frac{x}{\mathsf{fma}\left(y, y, y\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 72.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{min}\left(x, y\right) \leq -0.0007051836170957891:\\ \;\;\;\;0 \cdot \frac{1}{\mathsf{max}\left(x, y\right)}\\ \mathbf{elif}\;\mathsf{min}\left(x, y\right) \leq -1.3482985076248934 \cdot 10^{-142}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{\mathsf{fma}\left(\mathsf{max}\left(x, y\right), \mathsf{max}\left(x, y\right), \mathsf{max}\left(x, y\right)\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmin x y) -0.0007051836170957891)
  (* 0.0 (/ 1.0 (fmax x y)))
  (if (<= (fmin x y) -1.3482985076248934e-142)
    (/ (fmax x y) (fmin x y))
    (/ (fmin x y) (fma (fmax x y) (fmax x y) (fmax x y))))))

C

double code(double x, double y) {
	double tmp;
	if (fmin(x, y) <= -0.0007051836170957891) {
		tmp = 0.0 * (1.0 / fmax(x, y));
	} else if (fmin(x, y) <= -1.3482985076248934e-142) {
		tmp = fmax(x, y) / fmin(x, y);
	} else {
		tmp = fmin(x, y) / fma(fmax(x, y), fmax(x, y), fmax(x, y));
	}
	return tmp;
}

Julia

function code(x, y)
	tmp = 0.0
	if (fmin(x, y) <= -0.0007051836170957891)
		tmp = Float64(0.0 * Float64(1.0 / fmax(x, y)));
	elseif (fmin(x, y) <= -1.3482985076248934e-142)
		tmp = Float64(fmax(x, y) / fmin(x, y));
	else
		tmp = Float64(fmin(x, y) / fma(fmax(x, y), fmax(x, y), fmax(x, y)));
	end
	return tmp
end

Wolfram

code[x_, y_] := If[LessEqual[N[Min[x, y], $MachinePrecision], -0.0007051836170957891], N[(0.0 * N[(1.0 / N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Min[x, y], $MachinePrecision], -1.3482985076248934e-142], N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision], N[(N[Min[x, y], $MachinePrecision] / N[(N[Max[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision] + N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_2 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_10 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_12 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_13 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (tmp_7 <= (-13482985076248933994375866967332925390428330676968730966443854002205855324050903946840969945407644961340629859896190416222921261219339892339120995941273411311408363821701136839568487662014930782308637526586203412982048230344459800019730904769927104623543829331813234722921263499373675320360744770696086816869704000845701744755631646137646940421250807418118711211718618869781494140625e-524)) THEN (tmp_8 / tmp_9) ELSE (tmp_10 / ((tmp_11 * tmp_12) + tmp_13)) ENDIF IN
	LET tmp_1 = IF (tmp_2 <= (-705183617095789141808459543625531296129338443279266357421875e-63)) THEN ((0) * ((1) / tmp_3)) ELSE tmp_6 ENDIF IN
	tmp_1
END code

Derivation

1. Split input into 3 regimes

2. if x < -7.0518361709578914e-4

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]

   10. Taylor expanded in undef-var around zero

       \[\leadsto 0 \cdot \frac{1}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 52.5%

       \[\leadsto 0 \cdot \frac{1}{y} \]

   if -7.0518361709578914e-4 < x < -1.3482985076248934e-142

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]

   5. Taylor expanded in x around 0

      \[\leadsto \frac{y}{x} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.7%

      \[\leadsto \frac{y}{x} \]

   if -1.3482985076248934e-142 < x

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.2%

      \[\leadsto \frac{x}{\mathsf{fma}\left(y, y, y\right)} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 18: 64.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_0 := \frac{1}{\mathsf{max}\left(x, y\right)}\\ t_1 := 0 \cdot t\_0\\ \mathbf{if}\;\mathsf{max}\left(x, y\right) \leq -3.3571943007747935 \cdot 10^{-86}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;\mathsf{max}\left(x, y\right) \leq 1.254631388733572 \cdot 10^{-124}:\\ \;\;\;\;\frac{1}{\frac{\mathsf{min}\left(x, y\right)}{\mathsf{max}\left(x, y\right)}}\\ \mathbf{elif}\;\mathsf{max}\left(x, y\right) \leq 0.6197206676123611:\\ \;\;\;\;\mathsf{min}\left(x, y\right) \cdot t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (/ 1.0 (fmax x y))) (t_1 (* 0.0 t_0)))
  (if (<= (fmax x y) -3.3571943007747935e-86)
    t_1
    (if (<= (fmax x y) 1.254631388733572e-124)
      (/ 1.0 (/ (fmin x y) (fmax x y)))
      (if (<= (fmax x y) 0.6197206676123611)
        (* (fmin x y) t_0)
        t_1)))))

C

double code(double x, double y) {
	double t_0 = 1.0 / fmax(x, y);
	double t_1 = 0.0 * t_0;
	double tmp;
	if (fmax(x, y) <= -3.3571943007747935e-86) {
		tmp = t_1;
	} else if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = 1.0 / (fmin(x, y) / fmax(x, y));
	} else if (fmax(x, y) <= 0.6197206676123611) {
		tmp = fmin(x, y) * t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 1.0d0 / fmax(x, y)
    t_1 = 0.0d0 * t_0
    if (fmax(x, y) <= (-3.3571943007747935d-86)) then
        tmp = t_1
    else if (fmax(x, y) <= 1.254631388733572d-124) then
        tmp = 1.0d0 / (fmin(x, y) / fmax(x, y))
    else if (fmax(x, y) <= 0.6197206676123611d0) then
        tmp = fmin(x, y) * t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = 1.0 / fmax(x, y);
	double t_1 = 0.0 * t_0;
	double tmp;
	if (fmax(x, y) <= -3.3571943007747935e-86) {
		tmp = t_1;
	} else if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = 1.0 / (fmin(x, y) / fmax(x, y));
	} else if (fmax(x, y) <= 0.6197206676123611) {
		tmp = fmin(x, y) * t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = 1.0 / fmax(x, y)
	t_1 = 0.0 * t_0
	tmp = 0
	if fmax(x, y) <= -3.3571943007747935e-86:
		tmp = t_1
	elif fmax(x, y) <= 1.254631388733572e-124:
		tmp = 1.0 / (fmin(x, y) / fmax(x, y))
	elif fmax(x, y) <= 0.6197206676123611:
		tmp = fmin(x, y) * t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y)
	t_0 = Float64(1.0 / fmax(x, y))
	t_1 = Float64(0.0 * t_0)
	tmp = 0.0
	if (fmax(x, y) <= -3.3571943007747935e-86)
		tmp = t_1;
	elseif (fmax(x, y) <= 1.254631388733572e-124)
		tmp = Float64(1.0 / Float64(fmin(x, y) / fmax(x, y)));
	elseif (fmax(x, y) <= 0.6197206676123611)
		tmp = Float64(fmin(x, y) * t_0);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = 1.0 / max(x, y);
	t_1 = 0.0 * t_0;
	tmp = 0.0;
	if (max(x, y) <= -3.3571943007747935e-86)
		tmp = t_1;
	elseif (max(x, y) <= 1.254631388733572e-124)
		tmp = 1.0 / (min(x, y) / max(x, y));
	elseif (max(x, y) <= 0.6197206676123611)
		tmp = min(x, y) * t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.0 * t$95$0), $MachinePrecision]}, If[LessEqual[N[Max[x, y], $MachinePrecision], -3.3571943007747935e-86], t$95$1, If[LessEqual[N[Max[x, y], $MachinePrecision], 1.254631388733572e-124], N[(1.0 / N[(N[Min[x, y], $MachinePrecision] / N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Max[x, y], $MachinePrecision], 0.6197206676123611], N[(N[Min[x, y], $MachinePrecision] * t$95$0), $MachinePrecision], t$95$1]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_0 = ((1) / tmp) IN
		LET t_1 = ((0) * t_0) IN
			LET tmp_2 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_8 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (tmp_11 <= (61972066761236110910004981633392162621021270751953125e-53)) THEN (tmp_12 * t_0) ELSE t_1 ENDIF IN
			LET tmp_5 = IF (tmp_6 <= (12546313887335719745117480601769394163187756847250827276375715713252583350273421014627226154745389743363104605466579425030030765716859587082669226447431878323708894959117727895743295499192005217510846170104817527761339001684910251417472091505563429060965406119003179846658584475993113463413553988604932920569723364678793586790561676025390625e-464)) THEN ((1) / (tmp_7 / tmp_8)) ELSE tmp_10 ENDIF IN
			LET tmp_1 = IF (tmp_2 <= (-33571943007747935222802248250673927323586746469800687763669554393409360199794196677220844345737110825629844051863940368569182479154109825464793894832463917917862574292324033951418029775475921730823130161776323733546778527170317829586565494537353515625e-336)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_1
END code

Derivation

1. Split input into 3 regimes

2. if y < -3.3571943007747935e-86 or 0.61972066761236111 < y

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]

   10. Taylor expanded in undef-var around zero

       \[\leadsto 0 \cdot \frac{1}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 52.5%

       \[\leadsto 0 \cdot \frac{1}{y} \]

   if -3.3571943007747935e-86 < y < 1.254631388733572e-124

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]

   5. Taylor expanded in x around 0

      \[\leadsto \frac{y}{x} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.7%

      \[\leadsto \frac{y}{x} \]
   8. Step-by-step derivation

   9. Applied rewrites 27.2%

      \[\leadsto \frac{1}{\frac{x}{y}} \]

   if 1.254631388733572e-124 < y < 0.61972066761236111

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 19: 63.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_0 := \frac{1}{\mathsf{max}\left(x, y\right)}\\ t_1 := 0 \cdot t\_0\\ \mathbf{if}\;\mathsf{max}\left(x, y\right) \leq -3.3571943007747935 \cdot 10^{-86}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;\mathsf{max}\left(x, y\right) \leq 1.254631388733572 \cdot 10^{-124}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}\\ \mathbf{elif}\;\mathsf{max}\left(x, y\right) \leq 0.6197206676123611:\\ \;\;\;\;\mathsf{min}\left(x, y\right) \cdot t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (let* ((t_0 (/ 1.0 (fmax x y))) (t_1 (* 0.0 t_0)))
  (if (<= (fmax x y) -3.3571943007747935e-86)
    t_1
    (if (<= (fmax x y) 1.254631388733572e-124)
      (/ (fmax x y) (fmin x y))
      (if (<= (fmax x y) 0.6197206676123611)
        (* (fmin x y) t_0)
        t_1)))))

C

double code(double x, double y) {
	double t_0 = 1.0 / fmax(x, y);
	double t_1 = 0.0 * t_0;
	double tmp;
	if (fmax(x, y) <= -3.3571943007747935e-86) {
		tmp = t_1;
	} else if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = fmax(x, y) / fmin(x, y);
	} else if (fmax(x, y) <= 0.6197206676123611) {
		tmp = fmin(x, y) * t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 1.0d0 / fmax(x, y)
    t_1 = 0.0d0 * t_0
    if (fmax(x, y) <= (-3.3571943007747935d-86)) then
        tmp = t_1
    else if (fmax(x, y) <= 1.254631388733572d-124) then
        tmp = fmax(x, y) / fmin(x, y)
    else if (fmax(x, y) <= 0.6197206676123611d0) then
        tmp = fmin(x, y) * t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = 1.0 / fmax(x, y);
	double t_1 = 0.0 * t_0;
	double tmp;
	if (fmax(x, y) <= -3.3571943007747935e-86) {
		tmp = t_1;
	} else if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = fmax(x, y) / fmin(x, y);
	} else if (fmax(x, y) <= 0.6197206676123611) {
		tmp = fmin(x, y) * t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = 1.0 / fmax(x, y)
	t_1 = 0.0 * t_0
	tmp = 0
	if fmax(x, y) <= -3.3571943007747935e-86:
		tmp = t_1
	elif fmax(x, y) <= 1.254631388733572e-124:
		tmp = fmax(x, y) / fmin(x, y)
	elif fmax(x, y) <= 0.6197206676123611:
		tmp = fmin(x, y) * t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y)
	t_0 = Float64(1.0 / fmax(x, y))
	t_1 = Float64(0.0 * t_0)
	tmp = 0.0
	if (fmax(x, y) <= -3.3571943007747935e-86)
		tmp = t_1;
	elseif (fmax(x, y) <= 1.254631388733572e-124)
		tmp = Float64(fmax(x, y) / fmin(x, y));
	elseif (fmax(x, y) <= 0.6197206676123611)
		tmp = Float64(fmin(x, y) * t_0);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = 1.0 / max(x, y);
	t_1 = 0.0 * t_0;
	tmp = 0.0;
	if (max(x, y) <= -3.3571943007747935e-86)
		tmp = t_1;
	elseif (max(x, y) <= 1.254631388733572e-124)
		tmp = max(x, y) / min(x, y);
	elseif (max(x, y) <= 0.6197206676123611)
		tmp = min(x, y) * t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.0 * t$95$0), $MachinePrecision]}, If[LessEqual[N[Max[x, y], $MachinePrecision], -3.3571943007747935e-86], t$95$1, If[LessEqual[N[Max[x, y], $MachinePrecision], 1.254631388733572e-124], N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Max[x, y], $MachinePrecision], 0.6197206676123611], N[(N[Min[x, y], $MachinePrecision] * t$95$0), $MachinePrecision], t$95$1]]]]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_0 = ((1) / tmp) IN
		LET t_1 = ((0) * t_0) IN
			LET tmp_2 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_7 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (tmp_11 <= (61972066761236110910004981633392162621021270751953125e-53)) THEN (tmp_12 * t_0) ELSE t_1 ENDIF IN
			LET tmp_5 = IF (tmp_6 <= (12546313887335719745117480601769394163187756847250827276375715713252583350273421014627226154745389743363104605466579425030030765716859587082669226447431878323708894959117727895743295499192005217510846170104817527761339001684910251417472091505563429060965406119003179846658584475993113463413553988604932920569723364678793586790561676025390625e-464)) THEN (tmp_7 / tmp_8) ELSE tmp_10 ENDIF IN
			LET tmp_1 = IF (tmp_2 <= (-33571943007747935222802248250673927323586746469800687763669554393409360199794196677220844345737110825629844051863940368569182479154109825464793894832463917917862574292324033951418029775475921730823130161776323733546778527170317829586565494537353515625e-336)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_1
END code

Derivation

1. Split input into 3 regimes

2. if y < -3.3571943007747935e-86 or 0.61972066761236111 < y

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]

   10. Taylor expanded in undef-var around zero

       \[\leadsto 0 \cdot \frac{1}{y} \]
   11. Step-by-step derivation

   12. Applied rewrites 52.5%

       \[\leadsto 0 \cdot \frac{1}{y} \]

   if -3.3571943007747935e-86 < y < 1.254631388733572e-124

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]

   5. Taylor expanded in x around 0

      \[\leadsto \frac{y}{x} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.7%

      \[\leadsto \frac{y}{x} \]

   if 1.254631388733572e-124 < y < 0.61972066761236111

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 20: 44.9% accurate, 1.2× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\mathsf{max}\left(x, y\right) \leq 1.254631388733572 \cdot 10^{-124}:\\ \;\;\;\;\frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{min}\left(x, y\right) \cdot \frac{1}{\mathsf{max}\left(x, y\right)}\\ \end{array} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (if (<= (fmax x y) 1.254631388733572e-124)
  (/ (fmax x y) (fmin x y))
  (* (fmin x y) (/ 1.0 (fmax x y)))))

C

double code(double x, double y) {
	double tmp;
	if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = fmax(x, y) / fmin(x, y);
	} else {
		tmp = fmin(x, y) * (1.0 / fmax(x, y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (fmax(x, y) <= 1.254631388733572d-124) then
        tmp = fmax(x, y) / fmin(x, y)
    else
        tmp = fmin(x, y) * (1.0d0 / fmax(x, y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (fmax(x, y) <= 1.254631388733572e-124) {
		tmp = fmax(x, y) / fmin(x, y);
	} else {
		tmp = fmin(x, y) * (1.0 / fmax(x, y));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if fmax(x, y) <= 1.254631388733572e-124:
		tmp = fmax(x, y) / fmin(x, y)
	else:
		tmp = fmin(x, y) * (1.0 / fmax(x, y))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (fmax(x, y) <= 1.254631388733572e-124)
		tmp = Float64(fmax(x, y) / fmin(x, y));
	else
		tmp = Float64(fmin(x, y) * Float64(1.0 / fmax(x, y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (max(x, y) <= 1.254631388733572e-124)
		tmp = max(x, y) / min(x, y);
	else
		tmp = min(x, y) * (1.0 / max(x, y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[N[Max[x, y], $MachinePrecision], 1.254631388733572e-124], N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision], N[(N[Min[x, y], $MachinePrecision] * N[(1.0 / N[Max[x, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_4 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_6 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_7 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_2 = IF (tmp_3 <= (12546313887335719745117480601769394163187756847250827276375715713252583350273421014627226154745389743363104605466579425030030765716859587082669226447431878323708894959117727895743295499192005217510846170104817527761339001684910251417472091505563429060965406119003179846658584475993113463413553988604932920569723364678793586790561676025390625e-464)) THEN (tmp_4 / tmp_5) ELSE (tmp_6 * ((1) / tmp_7)) ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if y < 1.254631388733572e-124

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in y around 0

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.3%

      \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]

   5. Taylor expanded in x around 0

      \[\leadsto \frac{y}{x} \]
   6. Step-by-step derivation

   7. Applied rewrites 26.7%

      \[\leadsto \frac{y}{x} \]

   if 1.254631388733572e-124 < y

   1. Initial program 69.5%

      \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

   2. Taylor expanded in x around 0

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.2%

      \[\leadsto \frac{x}{y \cdot \left(1 + y\right)} \]
   5. Step-by-step derivation

   6. Applied rewrites 49.1%

      \[\leadsto x \cdot \frac{1}{\mathsf{fma}\left(y, y, y\right)} \]

   7. Taylor expanded in y around 0

      \[\leadsto x \cdot \frac{1}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 26.8%

      \[\leadsto x \cdot \frac{1}{y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 21: 26.4% accurate, 2.2× speedup

Math

\[\frac{\mathsf{max}\left(x, y\right)}{\mathsf{min}\left(x, y\right)} \]

FPCore

(FPCore (x y)
  :precision binary64
  :pre TRUE
  (/ (fmax x y) (fmin x y)))

C

double code(double x, double y) {
	return fmax(x, y) / fmin(x, y);
}

Fortran

real(8) function code(x, y)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = fmax(x, y) / fmin(x, y)
end function

Java

public static double code(double x, double y) {
	return fmax(x, y) / fmin(x, y);
}

Python

def code(x, y):
	return fmax(x, y) / fmin(x, y)

Julia

function code(x, y)
	return Float64(fmax(x, y) / fmin(x, y))
end

MATLAB

function tmp = code(x, y)
	tmp = max(x, y) / min(x, y);
end

Wolfram

code[x_, y_] := N[(N[Max[x, y], $MachinePrecision] / N[Min[x, y], $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y):
	x in [-inf, +inf],
	y in [-inf, +inf]
code: THEORY
BEGIN
f(x, y: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	tmp / tmp_1
END code

Derivation

1. Initial program 69.5%

   \[\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \]

2. Taylor expanded in y around 0

   \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]
3. Step-by-step derivation

4. Applied rewrites 49.3%

   \[\leadsto \frac{y}{x \cdot \left(1 + x\right)} \]

5. Taylor expanded in x around 0

   \[\leadsto \frac{y}{x} \]
6. Step-by-step derivation

7. Applied rewrites 26.7%

   \[\leadsto \frac{y}{x} \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y)
  :name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A"
  :precision binary64
  (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))