Data.Colour.RGB:hslsv from colour-2.3.3, C

Percentage Accurate: 100.0% → 100.0%

Time: 11.5s

Alternatives: 10

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{x - y}{2 - \left(x + y\right)} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (- 2.0 (+ x y))))

C

double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (2.0d0 - (x + y))
end function

Java

public static double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Python

def code(x, y):
	return (x - y) / (2.0 - (x + y))

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(2.0 - Float64(x + y)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (2.0 - (x + y));
end

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{2 - \left(x + y\right)} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (- 2.0 (+ x y))))

C

double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (2.0d0 - (x + y))
end function

Java

public static double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Python

def code(x, y):
	return (x - y) / (2.0 - (x + y))

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(2.0 - Float64(x + y)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (2.0 - (x + y));
end

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{2 - \left(x + y\right)} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (- x y) (- 2.0 (+ x y))))

C

double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x - y) / (2.0d0 - (x + y))
end function

Java

public static double code(double x, double y) {
	return (x - y) / (2.0 - (x + y));
}

Python

def code(x, y):
	return (x - y) / (2.0 - (x + y))

Julia

function code(x, y)
	return Float64(Float64(x - y) / Float64(2.0 - Float64(x + y)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x - y) / (2.0 - (x + y));
end

Wolfram

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

Derivation

1. Initial program 100.0%

   \[\frac{x - y}{2 - \left(x + y\right)} \]
2. Add Preprocessing

3. Final simplification 100.0%

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

Alternative 2: 63.0% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x - y\right) \cdot 0.5\\ t_1 := -1 + \frac{y}{x}\\ \mathbf{if}\;x \leq -1300000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -3.4 \cdot 10^{-118}:\\ \;\;\;\;1 - \frac{x}{y}\\ \mathbf{elif}\;x \leq -3 \cdot 10^{-239}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq -1.6 \cdot 10^{-280}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 2.05 \cdot 10^{-231}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 8.6 \cdot 10^{+15}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (* (- x y) 0.5)) (t_1 (+ -1.0 (/ y x))))
   (if (<= x -1300000000.0)
     t_1
     (if (<= x -3.4e-118)
       (- 1.0 (/ x y))
       (if (<= x -3e-239)
         t_0
         (if (<= x -1.6e-280)
           1.0
           (if (<= x 2.05e-231) t_0 (if (<= x 8.6e+15) 1.0 t_1))))))))

C

double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double t_1 = -1.0 + (y / x);
	double tmp;
	if (x <= -1300000000.0) {
		tmp = t_1;
	} else if (x <= -3.4e-118) {
		tmp = 1.0 - (x / y);
	} else if (x <= -3e-239) {
		tmp = t_0;
	} else if (x <= -1.6e-280) {
		tmp = 1.0;
	} else if (x <= 2.05e-231) {
		tmp = t_0;
	} else if (x <= 8.6e+15) {
		tmp = 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (x - y) * 0.5d0
    t_1 = (-1.0d0) + (y / x)
    if (x <= (-1300000000.0d0)) then
        tmp = t_1
    else if (x <= (-3.4d-118)) then
        tmp = 1.0d0 - (x / y)
    else if (x <= (-3d-239)) then
        tmp = t_0
    else if (x <= (-1.6d-280)) then
        tmp = 1.0d0
    else if (x <= 2.05d-231) then
        tmp = t_0
    else if (x <= 8.6d+15) then
        tmp = 1.0d0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double t_1 = -1.0 + (y / x);
	double tmp;
	if (x <= -1300000000.0) {
		tmp = t_1;
	} else if (x <= -3.4e-118) {
		tmp = 1.0 - (x / y);
	} else if (x <= -3e-239) {
		tmp = t_0;
	} else if (x <= -1.6e-280) {
		tmp = 1.0;
	} else if (x <= 2.05e-231) {
		tmp = t_0;
	} else if (x <= 8.6e+15) {
		tmp = 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = (x - y) * 0.5
	t_1 = -1.0 + (y / x)
	tmp = 0
	if x <= -1300000000.0:
		tmp = t_1
	elif x <= -3.4e-118:
		tmp = 1.0 - (x / y)
	elif x <= -3e-239:
		tmp = t_0
	elif x <= -1.6e-280:
		tmp = 1.0
	elif x <= 2.05e-231:
		tmp = t_0
	elif x <= 8.6e+15:
		tmp = 1.0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y)
	t_0 = Float64(Float64(x - y) * 0.5)
	t_1 = Float64(-1.0 + Float64(y / x))
	tmp = 0.0
	if (x <= -1300000000.0)
		tmp = t_1;
	elseif (x <= -3.4e-118)
		tmp = Float64(1.0 - Float64(x / y));
	elseif (x <= -3e-239)
		tmp = t_0;
	elseif (x <= -1.6e-280)
		tmp = 1.0;
	elseif (x <= 2.05e-231)
		tmp = t_0;
	elseif (x <= 8.6e+15)
		tmp = 1.0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = (x - y) * 0.5;
	t_1 = -1.0 + (y / x);
	tmp = 0.0;
	if (x <= -1300000000.0)
		tmp = t_1;
	elseif (x <= -3.4e-118)
		tmp = 1.0 - (x / y);
	elseif (x <= -3e-239)
		tmp = t_0;
	elseif (x <= -1.6e-280)
		tmp = 1.0;
	elseif (x <= 2.05e-231)
		tmp = t_0;
	elseif (x <= 8.6e+15)
		tmp = 1.0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[(x - y), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$1 = N[(-1.0 + N[(y / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1300000000.0], t$95$1, If[LessEqual[x, -3.4e-118], N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3e-239], t$95$0, If[LessEqual[x, -1.6e-280], 1.0, If[LessEqual[x, 2.05e-231], t$95$0, If[LessEqual[x, 8.6e+15], 1.0, t$95$1]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if x < -1.3e9 or 8.6e15 < x

   1. Initial program 100.0%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.7%

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

   4. Applied egg-rr 99.7%

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

   5. Taylor expanded in x around inf 83.5%

      \[\leadsto \color{blue}{\frac{-1}{x}} \cdot \left(x - y\right) \]

   6. Taylor expanded in x around 0 83.7%

      \[\leadsto \color{blue}{\frac{y}{x} - 1} \]

   if -1.3e9 < x < -3.39999999999999991e-118

   1. Initial program 99.9%

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

      1. div-sub 99.9%

         \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   4. Applied egg-rr 99.9%

      \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   5. Taylor expanded in y around inf 81.0%

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

      1. associate-*r/ 81.0%

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

      2. neg-mul-1 81.0%

         \[\leadsto \frac{\color{blue}{-x}}{y} - \frac{y}{2 - \left(x + y\right)} \]

   7. Simplified 81.0%

      \[\leadsto \color{blue}{\frac{-x}{y}} - \frac{y}{2 - \left(x + y\right)} \]

   8. Taylor expanded in y around inf 70.9%

      \[\leadsto \frac{-x}{y} - \color{blue}{-1} \]

   9. Taylor expanded in x around 0 70.9%

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

       1. mul-1-neg 70.9%

          \[\leadsto 1 + \color{blue}{\left(-\frac{x}{y}\right)} \]

       2. sub-neg 70.9%

          \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   11. Simplified 70.9%

       \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   if -3.39999999999999991e-118 < x < -2.9999999999999998e-239 or -1.6e-280 < x < 2.0500000000000001e-231

   1. Initial program 100.0%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.9%

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

   4. Applied egg-rr 99.9%

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

   5. Taylor expanded in x around 0 99.9%

      \[\leadsto \color{blue}{\frac{1}{2 - y}} \cdot \left(x - y\right) \]

   6. Taylor expanded in y around 0 66.7%

      \[\leadsto \color{blue}{0.5} \cdot \left(x - y\right) \]

   if -2.9999999999999998e-239 < x < -1.6e-280 or 2.0500000000000001e-231 < x < 8.6e15

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 63.2%

      \[\leadsto \color{blue}{1} \]
3. Recombined 4 regimes into one program.

4. Final simplification 73.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1300000000:\\ \;\;\;\;-1 + \frac{y}{x}\\ \mathbf{elif}\;x \leq -3.4 \cdot 10^{-118}:\\ \;\;\;\;1 - \frac{x}{y}\\ \mathbf{elif}\;x \leq -3 \cdot 10^{-239}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq -1.6 \cdot 10^{-280}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 2.05 \cdot 10^{-231}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq 8.6 \cdot 10^{+15}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1 + \frac{y}{x}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 71.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x - y\right) \cdot 0.5\\ t_1 := 1 - \frac{x}{y}\\ t_2 := \frac{x}{2 - x}\\ \mathbf{if}\;y \leq -3.8 \cdot 10^{+61}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-14}:\\ \;\;\;\;-1 + \frac{y}{x}\\ \mathbf{elif}\;y \leq -1.75 \cdot 10^{-140}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;y \leq 4.5 \cdot 10^{-97}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 2.7 \cdot 10^{-12}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;y \leq 4.7 \cdot 10^{+116}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (* (- x y) 0.5)) (t_1 (- 1.0 (/ x y))) (t_2 (/ x (- 2.0 x))))
   (if (<= y -3.8e+61)
     t_1
     (if (<= y -3.4e-14)
       (+ -1.0 (/ y x))
       (if (<= y -1.75e-140)
         t_0
         (if (<= y 4.5e-97)
           t_2
           (if (<= y 2.7e-12) t_0 (if (<= y 4.7e+116) t_2 t_1))))))))

C

double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double t_1 = 1.0 - (x / y);
	double t_2 = x / (2.0 - x);
	double tmp;
	if (y <= -3.8e+61) {
		tmp = t_1;
	} else if (y <= -3.4e-14) {
		tmp = -1.0 + (y / x);
	} else if (y <= -1.75e-140) {
		tmp = t_0;
	} else if (y <= 4.5e-97) {
		tmp = t_2;
	} else if (y <= 2.7e-12) {
		tmp = t_0;
	} else if (y <= 4.7e+116) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    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 = (x - y) * 0.5d0
    t_1 = 1.0d0 - (x / y)
    t_2 = x / (2.0d0 - x)
    if (y <= (-3.8d+61)) then
        tmp = t_1
    else if (y <= (-3.4d-14)) then
        tmp = (-1.0d0) + (y / x)
    else if (y <= (-1.75d-140)) then
        tmp = t_0
    else if (y <= 4.5d-97) then
        tmp = t_2
    else if (y <= 2.7d-12) then
        tmp = t_0
    else if (y <= 4.7d+116) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double t_1 = 1.0 - (x / y);
	double t_2 = x / (2.0 - x);
	double tmp;
	if (y <= -3.8e+61) {
		tmp = t_1;
	} else if (y <= -3.4e-14) {
		tmp = -1.0 + (y / x);
	} else if (y <= -1.75e-140) {
		tmp = t_0;
	} else if (y <= 4.5e-97) {
		tmp = t_2;
	} else if (y <= 2.7e-12) {
		tmp = t_0;
	} else if (y <= 4.7e+116) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = (x - y) * 0.5
	t_1 = 1.0 - (x / y)
	t_2 = x / (2.0 - x)
	tmp = 0
	if y <= -3.8e+61:
		tmp = t_1
	elif y <= -3.4e-14:
		tmp = -1.0 + (y / x)
	elif y <= -1.75e-140:
		tmp = t_0
	elif y <= 4.5e-97:
		tmp = t_2
	elif y <= 2.7e-12:
		tmp = t_0
	elif y <= 4.7e+116:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y)
	t_0 = Float64(Float64(x - y) * 0.5)
	t_1 = Float64(1.0 - Float64(x / y))
	t_2 = Float64(x / Float64(2.0 - x))
	tmp = 0.0
	if (y <= -3.8e+61)
		tmp = t_1;
	elseif (y <= -3.4e-14)
		tmp = Float64(-1.0 + Float64(y / x));
	elseif (y <= -1.75e-140)
		tmp = t_0;
	elseif (y <= 4.5e-97)
		tmp = t_2;
	elseif (y <= 2.7e-12)
		tmp = t_0;
	elseif (y <= 4.7e+116)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = (x - y) * 0.5;
	t_1 = 1.0 - (x / y);
	t_2 = x / (2.0 - x);
	tmp = 0.0;
	if (y <= -3.8e+61)
		tmp = t_1;
	elseif (y <= -3.4e-14)
		tmp = -1.0 + (y / x);
	elseif (y <= -1.75e-140)
		tmp = t_0;
	elseif (y <= 4.5e-97)
		tmp = t_2;
	elseif (y <= 2.7e-12)
		tmp = t_0;
	elseif (y <= 4.7e+116)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[(x - y), $MachinePrecision] * 0.5), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(2.0 - x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.8e+61], t$95$1, If[LessEqual[y, -3.4e-14], N[(-1.0 + N[(y / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.75e-140], t$95$0, If[LessEqual[y, 4.5e-97], t$95$2, If[LessEqual[y, 2.7e-12], t$95$0, If[LessEqual[y, 4.7e+116], t$95$2, t$95$1]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -3.79999999999999995e61 or 4.7000000000000003e116 < y

   1. Initial program 100.0%

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

      1. div-sub 100.0%

         \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   4. Applied egg-rr 100.0%

      \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   5. Taylor expanded in y around inf 85.7%

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

      1. associate-*r/ 85.7%

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

      2. neg-mul-1 85.7%

         \[\leadsto \frac{\color{blue}{-x}}{y} - \frac{y}{2 - \left(x + y\right)} \]

   7. Simplified 85.7%

      \[\leadsto \color{blue}{\frac{-x}{y}} - \frac{y}{2 - \left(x + y\right)} \]

   8. Taylor expanded in y around inf 85.3%

      \[\leadsto \frac{-x}{y} - \color{blue}{-1} \]

   9. Taylor expanded in x around 0 85.3%

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

       1. mul-1-neg 85.3%

          \[\leadsto 1 + \color{blue}{\left(-\frac{x}{y}\right)} \]

       2. sub-neg 85.3%

          \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   11. Simplified 85.3%

       \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   if -3.79999999999999995e61 < y < -3.40000000000000003e-14

   1. Initial program 99.8%

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

      1. clear-num 99.8%

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

      2. associate-/r/ 99.7%

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

   4. Applied egg-rr 99.7%

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

   5. Taylor expanded in x around inf 70.6%

      \[\leadsto \color{blue}{\frac{-1}{x}} \cdot \left(x - y\right) \]

   6. Taylor expanded in x around 0 70.6%

      \[\leadsto \color{blue}{\frac{y}{x} - 1} \]

   if -3.40000000000000003e-14 < y < -1.7499999999999999e-140 or 4.5000000000000001e-97 < y < 2.6999999999999998e-12

   1. Initial program 100.0%

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

      1. clear-num 99.7%

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

      2. associate-/r/ 100.0%

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

   4. Applied egg-rr 100.0%

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

   5. Taylor expanded in x around 0 72.3%

      \[\leadsto \color{blue}{\frac{1}{2 - y}} \cdot \left(x - y\right) \]

   6. Taylor expanded in y around 0 71.6%

      \[\leadsto \color{blue}{0.5} \cdot \left(x - y\right) \]

   if -1.7499999999999999e-140 < y < 4.5000000000000001e-97 or 2.6999999999999998e-12 < y < 4.7000000000000003e116

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 74.3%

      \[\leadsto \color{blue}{\frac{x}{2 - x}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 77.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -3.8 \cdot 10^{+61}:\\ \;\;\;\;1 - \frac{x}{y}\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-14}:\\ \;\;\;\;-1 + \frac{y}{x}\\ \mathbf{elif}\;y \leq -1.75 \cdot 10^{-140}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;y \leq 4.5 \cdot 10^{-97}:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;y \leq 2.7 \cdot 10^{-12}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;y \leq 4.7 \cdot 10^{+116}:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{else}:\\ \;\;\;\;1 - \frac{x}{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 62.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x - y\right) \cdot 0.5\\ \mathbf{if}\;x \leq -530000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq -1.1 \cdot 10^{-117}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq -6.5 \cdot 10^{-242}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq -9.6 \cdot 10^{-285}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-231}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 3.2 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (* (- x y) 0.5)))
   (if (<= x -530000000.0)
     -1.0
     (if (<= x -1.1e-117)
       1.0
       (if (<= x -6.5e-242)
         t_0
         (if (<= x -9.6e-285)
           1.0
           (if (<= x 1.7e-231) t_0 (if (<= x 3.2e+16) 1.0 -1.0))))))))

C

double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double tmp;
	if (x <= -530000000.0) {
		tmp = -1.0;
	} else if (x <= -1.1e-117) {
		tmp = 1.0;
	} else if (x <= -6.5e-242) {
		tmp = t_0;
	} else if (x <= -9.6e-285) {
		tmp = 1.0;
	} else if (x <= 1.7e-231) {
		tmp = t_0;
	} else if (x <= 3.2e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x - y) * 0.5d0
    if (x <= (-530000000.0d0)) then
        tmp = -1.0d0
    else if (x <= (-1.1d-117)) then
        tmp = 1.0d0
    else if (x <= (-6.5d-242)) then
        tmp = t_0
    else if (x <= (-9.6d-285)) then
        tmp = 1.0d0
    else if (x <= 1.7d-231) then
        tmp = t_0
    else if (x <= 3.2d+16) then
        tmp = 1.0d0
    else
        tmp = -1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double tmp;
	if (x <= -530000000.0) {
		tmp = -1.0;
	} else if (x <= -1.1e-117) {
		tmp = 1.0;
	} else if (x <= -6.5e-242) {
		tmp = t_0;
	} else if (x <= -9.6e-285) {
		tmp = 1.0;
	} else if (x <= 1.7e-231) {
		tmp = t_0;
	} else if (x <= 3.2e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = (x - y) * 0.5
	tmp = 0
	if x <= -530000000.0:
		tmp = -1.0
	elif x <= -1.1e-117:
		tmp = 1.0
	elif x <= -6.5e-242:
		tmp = t_0
	elif x <= -9.6e-285:
		tmp = 1.0
	elif x <= 1.7e-231:
		tmp = t_0
	elif x <= 3.2e+16:
		tmp = 1.0
	else:
		tmp = -1.0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(Float64(x - y) * 0.5)
	tmp = 0.0
	if (x <= -530000000.0)
		tmp = -1.0;
	elseif (x <= -1.1e-117)
		tmp = 1.0;
	elseif (x <= -6.5e-242)
		tmp = t_0;
	elseif (x <= -9.6e-285)
		tmp = 1.0;
	elseif (x <= 1.7e-231)
		tmp = t_0;
	elseif (x <= 3.2e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = (x - y) * 0.5;
	tmp = 0.0;
	if (x <= -530000000.0)
		tmp = -1.0;
	elseif (x <= -1.1e-117)
		tmp = 1.0;
	elseif (x <= -6.5e-242)
		tmp = t_0;
	elseif (x <= -9.6e-285)
		tmp = 1.0;
	elseif (x <= 1.7e-231)
		tmp = t_0;
	elseif (x <= 3.2e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[(x - y), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[x, -530000000.0], -1.0, If[LessEqual[x, -1.1e-117], 1.0, If[LessEqual[x, -6.5e-242], t$95$0, If[LessEqual[x, -9.6e-285], 1.0, If[LessEqual[x, 1.7e-231], t$95$0, If[LessEqual[x, 3.2e+16], 1.0, -1.0]]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -5.3e8 or 3.2e16 < x

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 83.4%

      \[\leadsto \color{blue}{-1} \]

   if -5.3e8 < x < -1.1000000000000001e-117 or -6.4999999999999998e-242 < x < -9.6000000000000001e-285 or 1.7e-231 < x < 3.2e16

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 65.7%

      \[\leadsto \color{blue}{1} \]

   if -1.1000000000000001e-117 < x < -6.4999999999999998e-242 or -9.6000000000000001e-285 < x < 1.7e-231

   1. Initial program 100.0%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.9%

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

   4. Applied egg-rr 99.9%

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

   5. Taylor expanded in x around 0 99.9%

      \[\leadsto \color{blue}{\frac{1}{2 - y}} \cdot \left(x - y\right) \]

   6. Taylor expanded in y around 0 66.7%

      \[\leadsto \color{blue}{0.5} \cdot \left(x - y\right) \]
3. Recombined 3 regimes into one program.

4. Final simplification 73.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -530000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq -1.1 \cdot 10^{-117}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq -6.5 \cdot 10^{-242}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq -9.6 \cdot 10^{-285}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-231}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq 3.2 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 62.6% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x - y\right) \cdot 0.5\\ \mathbf{if}\;x \leq -950000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq -3.6 \cdot 10^{-119}:\\ \;\;\;\;1 - \frac{x}{y}\\ \mathbf{elif}\;x \leq -6.6 \cdot 10^{-239}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq -9 \cdot 10^{-285}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 1.18 \cdot 10^{-231}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 7.5 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (* (- x y) 0.5)))
   (if (<= x -950000000.0)
     -1.0
     (if (<= x -3.6e-119)
       (- 1.0 (/ x y))
       (if (<= x -6.6e-239)
         t_0
         (if (<= x -9e-285)
           1.0
           (if (<= x 1.18e-231) t_0 (if (<= x 7.5e+16) 1.0 -1.0))))))))

C

double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double tmp;
	if (x <= -950000000.0) {
		tmp = -1.0;
	} else if (x <= -3.6e-119) {
		tmp = 1.0 - (x / y);
	} else if (x <= -6.6e-239) {
		tmp = t_0;
	} else if (x <= -9e-285) {
		tmp = 1.0;
	} else if (x <= 1.18e-231) {
		tmp = t_0;
	} else if (x <= 7.5e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x - y) * 0.5d0
    if (x <= (-950000000.0d0)) then
        tmp = -1.0d0
    else if (x <= (-3.6d-119)) then
        tmp = 1.0d0 - (x / y)
    else if (x <= (-6.6d-239)) then
        tmp = t_0
    else if (x <= (-9d-285)) then
        tmp = 1.0d0
    else if (x <= 1.18d-231) then
        tmp = t_0
    else if (x <= 7.5d+16) then
        tmp = 1.0d0
    else
        tmp = -1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = (x - y) * 0.5;
	double tmp;
	if (x <= -950000000.0) {
		tmp = -1.0;
	} else if (x <= -3.6e-119) {
		tmp = 1.0 - (x / y);
	} else if (x <= -6.6e-239) {
		tmp = t_0;
	} else if (x <= -9e-285) {
		tmp = 1.0;
	} else if (x <= 1.18e-231) {
		tmp = t_0;
	} else if (x <= 7.5e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = (x - y) * 0.5
	tmp = 0
	if x <= -950000000.0:
		tmp = -1.0
	elif x <= -3.6e-119:
		tmp = 1.0 - (x / y)
	elif x <= -6.6e-239:
		tmp = t_0
	elif x <= -9e-285:
		tmp = 1.0
	elif x <= 1.18e-231:
		tmp = t_0
	elif x <= 7.5e+16:
		tmp = 1.0
	else:
		tmp = -1.0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(Float64(x - y) * 0.5)
	tmp = 0.0
	if (x <= -950000000.0)
		tmp = -1.0;
	elseif (x <= -3.6e-119)
		tmp = Float64(1.0 - Float64(x / y));
	elseif (x <= -6.6e-239)
		tmp = t_0;
	elseif (x <= -9e-285)
		tmp = 1.0;
	elseif (x <= 1.18e-231)
		tmp = t_0;
	elseif (x <= 7.5e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = (x - y) * 0.5;
	tmp = 0.0;
	if (x <= -950000000.0)
		tmp = -1.0;
	elseif (x <= -3.6e-119)
		tmp = 1.0 - (x / y);
	elseif (x <= -6.6e-239)
		tmp = t_0;
	elseif (x <= -9e-285)
		tmp = 1.0;
	elseif (x <= 1.18e-231)
		tmp = t_0;
	elseif (x <= 7.5e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[(x - y), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[x, -950000000.0], -1.0, If[LessEqual[x, -3.6e-119], N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.6e-239], t$95$0, If[LessEqual[x, -9e-285], 1.0, If[LessEqual[x, 1.18e-231], t$95$0, If[LessEqual[x, 7.5e+16], 1.0, -1.0]]]]]]]

Derivation

1. Split input into 4 regimes

2. if x < -9.5e8 or 7.5e16 < x

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 83.4%

      \[\leadsto \color{blue}{-1} \]

   if -9.5e8 < x < -3.6e-119

   1. Initial program 99.9%

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

      1. div-sub 99.9%

         \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   4. Applied egg-rr 99.9%

      \[\leadsto \color{blue}{\frac{x}{2 - \left(x + y\right)} - \frac{y}{2 - \left(x + y\right)}} \]

   5. Taylor expanded in y around inf 81.0%

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

      1. associate-*r/ 81.0%

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

      2. neg-mul-1 81.0%

         \[\leadsto \frac{\color{blue}{-x}}{y} - \frac{y}{2 - \left(x + y\right)} \]

   7. Simplified 81.0%

      \[\leadsto \color{blue}{\frac{-x}{y}} - \frac{y}{2 - \left(x + y\right)} \]

   8. Taylor expanded in y around inf 70.9%

      \[\leadsto \frac{-x}{y} - \color{blue}{-1} \]

   9. Taylor expanded in x around 0 70.9%

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

       1. mul-1-neg 70.9%

          \[\leadsto 1 + \color{blue}{\left(-\frac{x}{y}\right)} \]

       2. sub-neg 70.9%

          \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   11. Simplified 70.9%

       \[\leadsto \color{blue}{1 - \frac{x}{y}} \]

   if -3.6e-119 < x < -6.5999999999999999e-239 or -9.0000000000000005e-285 < x < 1.18000000000000003e-231

   1. Initial program 100.0%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.9%

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

   4. Applied egg-rr 99.9%

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

   5. Taylor expanded in x around 0 99.9%

      \[\leadsto \color{blue}{\frac{1}{2 - y}} \cdot \left(x - y\right) \]

   6. Taylor expanded in y around 0 66.7%

      \[\leadsto \color{blue}{0.5} \cdot \left(x - y\right) \]

   if -6.5999999999999999e-239 < x < -9.0000000000000005e-285 or 1.18000000000000003e-231 < x < 7.5e16

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 63.2%

      \[\leadsto \color{blue}{1} \]
3. Recombined 4 regimes into one program.

4. Final simplification 73.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -950000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq -3.6 \cdot 10^{-119}:\\ \;\;\;\;1 - \frac{x}{y}\\ \mathbf{elif}\;x \leq -6.6 \cdot 10^{-239}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq -9 \cdot 10^{-285}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 1.18 \cdot 10^{-231}:\\ \;\;\;\;\left(x - y\right) \cdot 0.5\\ \mathbf{elif}\;x \leq 7.5 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 73.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x}{2 - x}\\ t_1 := \frac{-y}{2 - y}\\ \mathbf{if}\;x \leq -120000000:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 2.9 \cdot 10^{-58}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 3.05 \cdot 10^{+38}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 4.1 \cdot 10^{+89}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{\frac{x}{x - y}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ x (- 2.0 x))) (t_1 (/ (- y) (- 2.0 y))))
   (if (<= x -120000000.0)
     t_0
     (if (<= x 2.9e-58)
       t_1
       (if (<= x 3.05e+38)
         t_0
         (if (<= x 4.1e+89) t_1 (/ -1.0 (/ x (- x y)))))))))

C

double code(double x, double y) {
	double t_0 = x / (2.0 - x);
	double t_1 = -y / (2.0 - y);
	double tmp;
	if (x <= -120000000.0) {
		tmp = t_0;
	} else if (x <= 2.9e-58) {
		tmp = t_1;
	} else if (x <= 3.05e+38) {
		tmp = t_0;
	} else if (x <= 4.1e+89) {
		tmp = t_1;
	} else {
		tmp = -1.0 / (x / (x - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x / (2.0d0 - x)
    t_1 = -y / (2.0d0 - y)
    if (x <= (-120000000.0d0)) then
        tmp = t_0
    else if (x <= 2.9d-58) then
        tmp = t_1
    else if (x <= 3.05d+38) then
        tmp = t_0
    else if (x <= 4.1d+89) then
        tmp = t_1
    else
        tmp = (-1.0d0) / (x / (x - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = x / (2.0 - x);
	double t_1 = -y / (2.0 - y);
	double tmp;
	if (x <= -120000000.0) {
		tmp = t_0;
	} else if (x <= 2.9e-58) {
		tmp = t_1;
	} else if (x <= 3.05e+38) {
		tmp = t_0;
	} else if (x <= 4.1e+89) {
		tmp = t_1;
	} else {
		tmp = -1.0 / (x / (x - y));
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = x / (2.0 - x)
	t_1 = -y / (2.0 - y)
	tmp = 0
	if x <= -120000000.0:
		tmp = t_0
	elif x <= 2.9e-58:
		tmp = t_1
	elif x <= 3.05e+38:
		tmp = t_0
	elif x <= 4.1e+89:
		tmp = t_1
	else:
		tmp = -1.0 / (x / (x - y))
	return tmp

Julia

function code(x, y)
	t_0 = Float64(x / Float64(2.0 - x))
	t_1 = Float64(Float64(-y) / Float64(2.0 - y))
	tmp = 0.0
	if (x <= -120000000.0)
		tmp = t_0;
	elseif (x <= 2.9e-58)
		tmp = t_1;
	elseif (x <= 3.05e+38)
		tmp = t_0;
	elseif (x <= 4.1e+89)
		tmp = t_1;
	else
		tmp = Float64(-1.0 / Float64(x / Float64(x - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = x / (2.0 - x);
	t_1 = -y / (2.0 - y);
	tmp = 0.0;
	if (x <= -120000000.0)
		tmp = t_0;
	elseif (x <= 2.9e-58)
		tmp = t_1;
	elseif (x <= 3.05e+38)
		tmp = t_0;
	elseif (x <= 4.1e+89)
		tmp = t_1;
	else
		tmp = -1.0 / (x / (x - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(x / N[(2.0 - x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[((-y) / N[(2.0 - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -120000000.0], t$95$0, If[LessEqual[x, 2.9e-58], t$95$1, If[LessEqual[x, 3.05e+38], t$95$0, If[LessEqual[x, 4.1e+89], t$95$1, N[(-1.0 / N[(x / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.2e8 or 2.8999999999999999e-58 < x < 3.05e38

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 81.0%

      \[\leadsto \color{blue}{\frac{x}{2 - x}} \]

   if -1.2e8 < x < 2.8999999999999999e-58 or 3.05e38 < x < 4.09999999999999985e89

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 84.1%

      \[\leadsto \color{blue}{-1 \cdot \frac{y}{2 - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg 84.1%

         \[\leadsto \color{blue}{-\frac{y}{2 - y}} \]

      2. distribute-neg-frac 84.1%

         \[\leadsto \color{blue}{\frac{-y}{2 - y}} \]

   5. Simplified 84.1%

      \[\leadsto \color{blue}{\frac{-y}{2 - y}} \]

   if 4.09999999999999985e89 < x

   1. Initial program 99.9%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.7%

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

   4. Applied egg-rr 99.7%

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

   5. Taylor expanded in x around inf 88.5%

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

      1. associate-*l/ 88.7%

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(x - y\right)}{x}} \]

      2. associate-/l* 88.7%

         \[\leadsto \color{blue}{\frac{-1}{\frac{x}{x - y}}} \]

   7. Applied egg-rr 88.7%

      \[\leadsto \color{blue}{\frac{-1}{\frac{x}{x - y}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 83.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -120000000:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 2.9 \cdot 10^{-58}:\\ \;\;\;\;\frac{-y}{2 - y}\\ \mathbf{elif}\;x \leq 3.05 \cdot 10^{+38}:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 4.1 \cdot 10^{+89}:\\ \;\;\;\;\frac{-y}{2 - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{\frac{x}{x - y}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 73.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x}{2 - x}\\ t_1 := \frac{-y}{2 - y}\\ \mathbf{if}\;x \leq -530000000:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-58}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 3.1 \cdot 10^{+39}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 2.5 \cdot 10^{+88}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;-1 + \frac{y}{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ x (- 2.0 x))) (t_1 (/ (- y) (- 2.0 y))))
   (if (<= x -530000000.0)
     t_0
     (if (<= x 1.55e-58)
       t_1
       (if (<= x 3.1e+39) t_0 (if (<= x 2.5e+88) t_1 (+ -1.0 (/ y x))))))))

C

double code(double x, double y) {
	double t_0 = x / (2.0 - x);
	double t_1 = -y / (2.0 - y);
	double tmp;
	if (x <= -530000000.0) {
		tmp = t_0;
	} else if (x <= 1.55e-58) {
		tmp = t_1;
	} else if (x <= 3.1e+39) {
		tmp = t_0;
	} else if (x <= 2.5e+88) {
		tmp = t_1;
	} else {
		tmp = -1.0 + (y / x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x / (2.0d0 - x)
    t_1 = -y / (2.0d0 - y)
    if (x <= (-530000000.0d0)) then
        tmp = t_0
    else if (x <= 1.55d-58) then
        tmp = t_1
    else if (x <= 3.1d+39) then
        tmp = t_0
    else if (x <= 2.5d+88) then
        tmp = t_1
    else
        tmp = (-1.0d0) + (y / x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = x / (2.0 - x);
	double t_1 = -y / (2.0 - y);
	double tmp;
	if (x <= -530000000.0) {
		tmp = t_0;
	} else if (x <= 1.55e-58) {
		tmp = t_1;
	} else if (x <= 3.1e+39) {
		tmp = t_0;
	} else if (x <= 2.5e+88) {
		tmp = t_1;
	} else {
		tmp = -1.0 + (y / x);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = x / (2.0 - x)
	t_1 = -y / (2.0 - y)
	tmp = 0
	if x <= -530000000.0:
		tmp = t_0
	elif x <= 1.55e-58:
		tmp = t_1
	elif x <= 3.1e+39:
		tmp = t_0
	elif x <= 2.5e+88:
		tmp = t_1
	else:
		tmp = -1.0 + (y / x)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(x / Float64(2.0 - x))
	t_1 = Float64(Float64(-y) / Float64(2.0 - y))
	tmp = 0.0
	if (x <= -530000000.0)
		tmp = t_0;
	elseif (x <= 1.55e-58)
		tmp = t_1;
	elseif (x <= 3.1e+39)
		tmp = t_0;
	elseif (x <= 2.5e+88)
		tmp = t_1;
	else
		tmp = Float64(-1.0 + Float64(y / x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = x / (2.0 - x);
	t_1 = -y / (2.0 - y);
	tmp = 0.0;
	if (x <= -530000000.0)
		tmp = t_0;
	elseif (x <= 1.55e-58)
		tmp = t_1;
	elseif (x <= 3.1e+39)
		tmp = t_0;
	elseif (x <= 2.5e+88)
		tmp = t_1;
	else
		tmp = -1.0 + (y / x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(x / N[(2.0 - x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[((-y) / N[(2.0 - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -530000000.0], t$95$0, If[LessEqual[x, 1.55e-58], t$95$1, If[LessEqual[x, 3.1e+39], t$95$0, If[LessEqual[x, 2.5e+88], t$95$1, N[(-1.0 + N[(y / x), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -5.3e8 or 1.55e-58 < x < 3.1000000000000003e39

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 81.0%

      \[\leadsto \color{blue}{\frac{x}{2 - x}} \]

   if -5.3e8 < x < 1.55e-58 or 3.1000000000000003e39 < x < 2.49999999999999999e88

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 84.1%

      \[\leadsto \color{blue}{-1 \cdot \frac{y}{2 - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg 84.1%

         \[\leadsto \color{blue}{-\frac{y}{2 - y}} \]

      2. distribute-neg-frac 84.1%

         \[\leadsto \color{blue}{\frac{-y}{2 - y}} \]

   5. Simplified 84.1%

      \[\leadsto \color{blue}{\frac{-y}{2 - y}} \]

   if 2.49999999999999999e88 < x

   1. Initial program 99.9%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.7%

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

   4. Applied egg-rr 99.7%

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

   5. Taylor expanded in x around inf 88.5%

      \[\leadsto \color{blue}{\frac{-1}{x}} \cdot \left(x - y\right) \]

   6. Taylor expanded in x around 0 88.7%

      \[\leadsto \color{blue}{\frac{y}{x} - 1} \]
3. Recombined 3 regimes into one program.

4. Final simplification 83.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -530000000:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-58}:\\ \;\;\;\;\frac{-y}{2 - y}\\ \mathbf{elif}\;x \leq 3.1 \cdot 10^{+39}:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 2.5 \cdot 10^{+88}:\\ \;\;\;\;\frac{-y}{2 - y}\\ \mathbf{else}:\\ \;\;\;\;-1 + \frac{y}{x}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 87.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -32000000:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{+16}:\\ \;\;\;\;\frac{x - y}{2 - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{\frac{x}{x - y}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -32000000.0)
   (/ x (- 2.0 x))
   (if (<= x 1.55e+16) (/ (- x y) (- 2.0 y)) (/ -1.0 (/ x (- x y))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -32000000.0) {
		tmp = x / (2.0 - x);
	} else if (x <= 1.55e+16) {
		tmp = (x - y) / (2.0 - y);
	} else {
		tmp = -1.0 / (x / (x - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-32000000.0d0)) then
        tmp = x / (2.0d0 - x)
    else if (x <= 1.55d+16) then
        tmp = (x - y) / (2.0d0 - y)
    else
        tmp = (-1.0d0) / (x / (x - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -32000000.0) {
		tmp = x / (2.0 - x);
	} else if (x <= 1.55e+16) {
		tmp = (x - y) / (2.0 - y);
	} else {
		tmp = -1.0 / (x / (x - y));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -32000000.0:
		tmp = x / (2.0 - x)
	elif x <= 1.55e+16:
		tmp = (x - y) / (2.0 - y)
	else:
		tmp = -1.0 / (x / (x - y))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -32000000.0)
		tmp = Float64(x / Float64(2.0 - x));
	elseif (x <= 1.55e+16)
		tmp = Float64(Float64(x - y) / Float64(2.0 - y));
	else
		tmp = Float64(-1.0 / Float64(x / Float64(x - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -32000000.0)
		tmp = x / (2.0 - x);
	elseif (x <= 1.55e+16)
		tmp = (x - y) / (2.0 - y);
	else
		tmp = -1.0 / (x / (x - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -32000000.0], N[(x / N[(2.0 - x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.55e+16], N[(N[(x - y), $MachinePrecision] / N[(2.0 - y), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(x / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.2e7

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 87.0%

      \[\leadsto \color{blue}{\frac{x}{2 - x}} \]

   if -3.2e7 < x < 1.55e16

   1. Initial program 100.0%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.8%

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

   4. Applied egg-rr 99.8%

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

   5. Taylor expanded in x around 0 98.3%

      \[\leadsto \color{blue}{\frac{1}{2 - y}} \cdot \left(x - y\right) \]

   6. Taylor expanded in x around 0 98.5%

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

      1. +-commutative 98.5%

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

      2. mul-1-neg 98.5%

         \[\leadsto \frac{x}{2 - y} + \color{blue}{\left(-\frac{y}{2 - y}\right)} \]

      3. sub-neg 98.5%

         \[\leadsto \color{blue}{\frac{x}{2 - y} - \frac{y}{2 - y}} \]

      4. div-sub 98.5%

         \[\leadsto \color{blue}{\frac{x - y}{2 - y}} \]

   8. Simplified 98.5%

      \[\leadsto \color{blue}{\frac{x - y}{2 - y}} \]

   if 1.55e16 < x

   1. Initial program 99.9%

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

      1. clear-num 99.9%

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

      2. associate-/r/ 99.7%

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

   4. Applied egg-rr 99.7%

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

   5. Taylor expanded in x around inf 80.8%

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

      1. associate-*l/ 81.0%

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(x - y\right)}{x}} \]

      2. associate-/l* 81.0%

         \[\leadsto \color{blue}{\frac{-1}{\frac{x}{x - y}}} \]

   7. Applied egg-rr 81.0%

      \[\leadsto \color{blue}{\frac{-1}{\frac{x}{x - y}}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 92.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -32000000:\\ \;\;\;\;\frac{x}{2 - x}\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{+16}:\\ \;\;\;\;\frac{x - y}{2 - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{\frac{x}{x - y}}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 62.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1650000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq 3 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -1650000000.0) -1.0 (if (<= x 3e+16) 1.0 -1.0)))

C

double code(double x, double y) {
	double tmp;
	if (x <= -1650000000.0) {
		tmp = -1.0;
	} else if (x <= 3e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-1650000000.0d0)) then
        tmp = -1.0d0
    else if (x <= 3d+16) then
        tmp = 1.0d0
    else
        tmp = -1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -1650000000.0) {
		tmp = -1.0;
	} else if (x <= 3e+16) {
		tmp = 1.0;
	} else {
		tmp = -1.0;
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -1650000000.0:
		tmp = -1.0
	elif x <= 3e+16:
		tmp = 1.0
	else:
		tmp = -1.0
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -1650000000.0)
		tmp = -1.0;
	elseif (x <= 3e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -1650000000.0)
		tmp = -1.0;
	elseif (x <= 3e+16)
		tmp = 1.0;
	else
		tmp = -1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -1650000000.0], -1.0, If[LessEqual[x, 3e+16], 1.0, -1.0]]

Derivation

1. Split input into 2 regimes

2. if x < -1.65e9 or 3e16 < x

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 83.4%

      \[\leadsto \color{blue}{-1} \]

   if -1.65e9 < x < 3e16

   1. Initial program 100.0%

      \[\frac{x - y}{2 - \left(x + y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 54.9%

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

4. Final simplification 67.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1650000000:\\ \;\;\;\;-1\\ \mathbf{elif}\;x \leq 3 \cdot 10^{+16}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;-1\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 37.8% accurate, 9.0× speedup

Math

\[\begin{array}{l} \\ -1 \end{array} \]

FPCore

(FPCore (x y) :precision binary64 -1.0)

C

double code(double x, double y) {
	return -1.0;
}

Fortran

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

Java

public static double code(double x, double y) {
	return -1.0;
}

Python

def code(x, y):
	return -1.0

Julia

function code(x, y)
	return -1.0
end

MATLAB

function tmp = code(x, y)
	tmp = -1.0;
end

Wolfram

code[x_, y_] := -1.0

Derivation

1. Initial program 100.0%

   \[\frac{x - y}{2 - \left(x + y\right)} \]
2. Add Preprocessing

3. Taylor expanded in x around inf 36.9%

   \[\leadsto \color{blue}{-1} \]

4. Final simplification 36.9%

   \[\leadsto -1 \]
5. Add Preprocessing

Developer target: 100.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 - \left(x + y\right)\\ \frac{x}{t_0} - \frac{y}{t_0} \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (- 2.0 (+ x y)))) (- (/ x t_0) (/ y t_0))))

C

double code(double x, double y) {
	double t_0 = 2.0 - (x + y);
	return (x / t_0) - (y / t_0);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    t_0 = 2.0d0 - (x + y)
    code = (x / t_0) - (y / t_0)
end function

Java

public static double code(double x, double y) {
	double t_0 = 2.0 - (x + y);
	return (x / t_0) - (y / t_0);
}

Python

def code(x, y):
	t_0 = 2.0 - (x + y)
	return (x / t_0) - (y / t_0)

Julia

function code(x, y)
	t_0 = Float64(2.0 - Float64(x + y))
	return Float64(Float64(x / t_0) - Float64(y / t_0))
end

MATLAB

function tmp = code(x, y)
	t_0 = 2.0 - (x + y);
	tmp = (x / t_0) - (y / t_0);
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(2.0 - N[(x + y), $MachinePrecision]), $MachinePrecision]}, N[(N[(x / t$95$0), $MachinePrecision] - N[(y / t$95$0), $MachinePrecision]), $MachinePrecision]]

Reproduce

herbie shell --seed 2024018 
(FPCore (x y)
  :name "Data.Colour.RGB:hslsv from colour-2.3.3, C"
  :precision binary64

  :herbie-target
  (- (/ x (- 2.0 (+ x y))) (/ y (- 2.0 (+ x y))))

  (/ (- x y) (- 2.0 (+ x y))))