Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 67.0% → 91.3%

Time: 17.1s

Alternatives: 19

Speedup: 0.6×

Specification

Math

\[\begin{array}{l} \\ \frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}

Python

def code(x, y, z, t, a, b):
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)))

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))))
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 67.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
}

Python

def code(x, y, z, t, a, b):
	return ((x * y) + (z * (t - a))) / (y + (z * (b - y)))

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))))
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 91.3% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ t_2 := y + z \cdot \left(b - y\right)\\ t_3 := \mathsf{fma}\left(x, y, t\_1\right)\\ t_4 := \frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y}\\ t_5 := \frac{t - a}{b - y}\\ t_6 := \left(t\_5 + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \mathbf{if}\;t\_4 \leq -\infty:\\ \;\;\;\;t\_5\\ \mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-267}:\\ \;\;\;\;\frac{t\_3}{t\_2}\\ \mathbf{elif}\;t\_4 \leq 0:\\ \;\;\;\;t\_6\\ \mathbf{elif}\;t\_4 \leq 10^{+299}:\\ \;\;\;\;\frac{t\_3}{\mathsf{fma}\left(z, b - y, y\right)}\\ \mathbf{elif}\;t\_4 \leq \infty:\\ \;\;\;\;x \cdot \left(\frac{y}{t\_2} + \frac{t\_1}{x \cdot t\_2}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_6\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- t a)))
        (t_2 (+ y (* z (- b y))))
        (t_3 (fma x y t_1))
        (t_4 (/ (- (* z (- a t)) (* x y)) (- (* z (- y b)) y)))
        (t_5 (/ (- t a) (- b y)))
        (t_6
         (+
          (+ t_5 (* (/ y z) (/ x (- b y))))
          (* (/ y z) (/ (- a t) (pow (- b y) 2.0))))))
   (if (<= t_4 (- INFINITY))
     t_5
     (if (<= t_4 -2e-267)
       (/ t_3 t_2)
       (if (<= t_4 0.0)
         t_6
         (if (<= t_4 1e+299)
           (/ t_3 (fma z (- b y) y))
           (if (<= t_4 INFINITY)
             (* x (+ (/ y t_2) (/ t_1 (* x t_2))))
             t_6)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double t_2 = y + (z * (b - y));
	double t_3 = fma(x, y, t_1);
	double t_4 = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y);
	double t_5 = (t - a) / (b - y);
	double t_6 = (t_5 + ((y / z) * (x / (b - y)))) + ((y / z) * ((a - t) / pow((b - y), 2.0)));
	double tmp;
	if (t_4 <= -((double) INFINITY)) {
		tmp = t_5;
	} else if (t_4 <= -2e-267) {
		tmp = t_3 / t_2;
	} else if (t_4 <= 0.0) {
		tmp = t_6;
	} else if (t_4 <= 1e+299) {
		tmp = t_3 / fma(z, (b - y), y);
	} else if (t_4 <= ((double) INFINITY)) {
		tmp = x * ((y / t_2) + (t_1 / (x * t_2)));
	} else {
		tmp = t_6;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	t_2 = Float64(y + Float64(z * Float64(b - y)))
	t_3 = fma(x, y, t_1)
	t_4 = Float64(Float64(Float64(z * Float64(a - t)) - Float64(x * y)) / Float64(Float64(z * Float64(y - b)) - y))
	t_5 = Float64(Float64(t - a) / Float64(b - y))
	t_6 = Float64(Float64(t_5 + Float64(Float64(y / z) * Float64(x / Float64(b - y)))) + Float64(Float64(y / z) * Float64(Float64(a - t) / (Float64(b - y) ^ 2.0))))
	tmp = 0.0
	if (t_4 <= Float64(-Inf))
		tmp = t_5;
	elseif (t_4 <= -2e-267)
		tmp = Float64(t_3 / t_2);
	elseif (t_4 <= 0.0)
		tmp = t_6;
	elseif (t_4 <= 1e+299)
		tmp = Float64(t_3 / fma(z, Float64(b - y), y));
	elseif (t_4 <= Inf)
		tmp = Float64(x * Float64(Float64(y / t_2) + Float64(t_1 / Float64(x * t_2))));
	else
		tmp = t_6;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x * y + t$95$1), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(z * N[(a - t), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision] / N[(N[(z * N[(y - b), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(t$95$5 + N[(N[(y / z), $MachinePrecision] * N[(x / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(y / z), $MachinePrecision] * N[(N[(a - t), $MachinePrecision] / N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, (-Infinity)], t$95$5, If[LessEqual[t$95$4, -2e-267], N[(t$95$3 / t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 0.0], t$95$6, If[LessEqual[t$95$4, 1e+299], N[(t$95$3 / N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(x * N[(N[(y / t$95$2), $MachinePrecision] + N[(t$95$1 / N[(x * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$6]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -inf.0

   1. Initial program 41.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 80.6%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -2e-267

   1. Initial program 99.5%

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

      1. fma-define 99.5%

         \[\leadsto \frac{\color{blue}{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}}{y + z \cdot \left(b - y\right)} \]

   3. Simplified 99.5%

      \[\leadsto \color{blue}{\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{y + z \cdot \left(b - y\right)}} \]
   4. Add Preprocessing

   if -2e-267 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 0.0 or +inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y))))

   1. Initial program 9.2%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 52.3%

      \[\leadsto \color{blue}{\left(\frac{t}{b - y} + \frac{x \cdot y}{z \cdot \left(b - y\right)}\right) - \left(\frac{a}{b - y} + \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}}\right)} \]
   4. Step-by-step derivation

      1. associate--r+ 52.3%

         \[\leadsto \color{blue}{\left(\left(\frac{t}{b - y} + \frac{x \cdot y}{z \cdot \left(b - y\right)}\right) - \frac{a}{b - y}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}}} \]

      2. +-commutative 52.3%

         \[\leadsto \left(\color{blue}{\left(\frac{x \cdot y}{z \cdot \left(b - y\right)} + \frac{t}{b - y}\right)} - \frac{a}{b - y}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      3. associate--l+ 52.3%

         \[\leadsto \color{blue}{\left(\frac{x \cdot y}{z \cdot \left(b - y\right)} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right)} - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      4. *-commutative 52.3%

         \[\leadsto \left(\frac{\color{blue}{y \cdot x}}{z \cdot \left(b - y\right)} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      5. times-frac 62.6%

         \[\leadsto \left(\color{blue}{\frac{y}{z} \cdot \frac{x}{b - y}} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      6. div-sub 62.6%

         \[\leadsto \left(\frac{y}{z} \cdot \frac{x}{b - y} + \color{blue}{\frac{t - a}{b - y}}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      7. times-frac 99.8%

         \[\leadsto \left(\frac{y}{z} \cdot \frac{x}{b - y} + \frac{t - a}{b - y}\right) - \color{blue}{\frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}} \]

   5. Simplified 99.8%

      \[\leadsto \color{blue}{\left(\frac{y}{z} \cdot \frac{x}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}} \]

   if 0.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 1.0000000000000001e299

   1. Initial program 99.7%

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

      1. fma-define 99.7%

         \[\leadsto \frac{\color{blue}{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}}{y + z \cdot \left(b - y\right)} \]

      2. +-commutative 99.7%

         \[\leadsto \frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{\color{blue}{z \cdot \left(b - y\right) + y}} \]

      3. fma-define 99.7%

         \[\leadsto \frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{\color{blue}{\mathsf{fma}\left(z, b - y, y\right)}} \]

   3. Simplified 99.7%

      \[\leadsto \color{blue}{\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{\mathsf{fma}\left(z, b - y, y\right)}} \]
   4. Add Preprocessing

   if 1.0000000000000001e299 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < +inf.0

   1. Initial program 29.5%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 72.6%

      \[\leadsto \color{blue}{x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)} \]
3. Recombined 5 regimes into one program.

4. Final simplification 94.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq -\infty:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq -2 \cdot 10^{-267}:\\ \;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq 0:\\ \;\;\;\;\left(\frac{t - a}{b - y} + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq 10^{+299}:\\ \;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{\mathsf{fma}\left(z, b - y, y\right)}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq \infty:\\ \;\;\;\;x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;\left(\frac{t - a}{b - y} + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 91.3% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ t_2 := y + z \cdot \left(b - y\right)\\ t_3 := \frac{\mathsf{fma}\left(x, y, t\_1\right)}{t\_2}\\ t_4 := \frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y}\\ t_5 := \frac{t - a}{b - y}\\ t_6 := \left(t\_5 + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \mathbf{if}\;t\_4 \leq -\infty:\\ \;\;\;\;t\_5\\ \mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-267}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_4 \leq 0:\\ \;\;\;\;t\_6\\ \mathbf{elif}\;t\_4 \leq 10^{+299}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_4 \leq \infty:\\ \;\;\;\;x \cdot \left(\frac{y}{t\_2} + \frac{t\_1}{x \cdot t\_2}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_6\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- t a)))
        (t_2 (+ y (* z (- b y))))
        (t_3 (/ (fma x y t_1) t_2))
        (t_4 (/ (- (* z (- a t)) (* x y)) (- (* z (- y b)) y)))
        (t_5 (/ (- t a) (- b y)))
        (t_6
         (+
          (+ t_5 (* (/ y z) (/ x (- b y))))
          (* (/ y z) (/ (- a t) (pow (- b y) 2.0))))))
   (if (<= t_4 (- INFINITY))
     t_5
     (if (<= t_4 -2e-267)
       t_3
       (if (<= t_4 0.0)
         t_6
         (if (<= t_4 1e+299)
           t_3
           (if (<= t_4 INFINITY)
             (* x (+ (/ y t_2) (/ t_1 (* x t_2))))
             t_6)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double t_2 = y + (z * (b - y));
	double t_3 = fma(x, y, t_1) / t_2;
	double t_4 = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y);
	double t_5 = (t - a) / (b - y);
	double t_6 = (t_5 + ((y / z) * (x / (b - y)))) + ((y / z) * ((a - t) / pow((b - y), 2.0)));
	double tmp;
	if (t_4 <= -((double) INFINITY)) {
		tmp = t_5;
	} else if (t_4 <= -2e-267) {
		tmp = t_3;
	} else if (t_4 <= 0.0) {
		tmp = t_6;
	} else if (t_4 <= 1e+299) {
		tmp = t_3;
	} else if (t_4 <= ((double) INFINITY)) {
		tmp = x * ((y / t_2) + (t_1 / (x * t_2)));
	} else {
		tmp = t_6;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	t_2 = Float64(y + Float64(z * Float64(b - y)))
	t_3 = Float64(fma(x, y, t_1) / t_2)
	t_4 = Float64(Float64(Float64(z * Float64(a - t)) - Float64(x * y)) / Float64(Float64(z * Float64(y - b)) - y))
	t_5 = Float64(Float64(t - a) / Float64(b - y))
	t_6 = Float64(Float64(t_5 + Float64(Float64(y / z) * Float64(x / Float64(b - y)))) + Float64(Float64(y / z) * Float64(Float64(a - t) / (Float64(b - y) ^ 2.0))))
	tmp = 0.0
	if (t_4 <= Float64(-Inf))
		tmp = t_5;
	elseif (t_4 <= -2e-267)
		tmp = t_3;
	elseif (t_4 <= 0.0)
		tmp = t_6;
	elseif (t_4 <= 1e+299)
		tmp = t_3;
	elseif (t_4 <= Inf)
		tmp = Float64(x * Float64(Float64(y / t_2) + Float64(t_1 / Float64(x * t_2))));
	else
		tmp = t_6;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x * y + t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(z * N[(a - t), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision] / N[(N[(z * N[(y - b), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(t$95$5 + N[(N[(y / z), $MachinePrecision] * N[(x / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(y / z), $MachinePrecision] * N[(N[(a - t), $MachinePrecision] / N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, (-Infinity)], t$95$5, If[LessEqual[t$95$4, -2e-267], t$95$3, If[LessEqual[t$95$4, 0.0], t$95$6, If[LessEqual[t$95$4, 1e+299], t$95$3, If[LessEqual[t$95$4, Infinity], N[(x * N[(N[(y / t$95$2), $MachinePrecision] + N[(t$95$1 / N[(x * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$6]]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -inf.0

   1. Initial program 41.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 80.6%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -2e-267 or 0.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 1.0000000000000001e299

   1. Initial program 99.6%

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

      1. fma-define 99.6%

         \[\leadsto \frac{\color{blue}{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}}{y + z \cdot \left(b - y\right)} \]

   3. Simplified 99.6%

      \[\leadsto \color{blue}{\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{y + z \cdot \left(b - y\right)}} \]
   4. Add Preprocessing

   if -2e-267 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 0.0 or +inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y))))

   1. Initial program 9.2%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 52.3%

      \[\leadsto \color{blue}{\left(\frac{t}{b - y} + \frac{x \cdot y}{z \cdot \left(b - y\right)}\right) - \left(\frac{a}{b - y} + \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}}\right)} \]
   4. Step-by-step derivation

      1. associate--r+ 52.3%

         \[\leadsto \color{blue}{\left(\left(\frac{t}{b - y} + \frac{x \cdot y}{z \cdot \left(b - y\right)}\right) - \frac{a}{b - y}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}}} \]

      2. +-commutative 52.3%

         \[\leadsto \left(\color{blue}{\left(\frac{x \cdot y}{z \cdot \left(b - y\right)} + \frac{t}{b - y}\right)} - \frac{a}{b - y}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      3. associate--l+ 52.3%

         \[\leadsto \color{blue}{\left(\frac{x \cdot y}{z \cdot \left(b - y\right)} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right)} - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      4. *-commutative 52.3%

         \[\leadsto \left(\frac{\color{blue}{y \cdot x}}{z \cdot \left(b - y\right)} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      5. times-frac 62.6%

         \[\leadsto \left(\color{blue}{\frac{y}{z} \cdot \frac{x}{b - y}} + \left(\frac{t}{b - y} - \frac{a}{b - y}\right)\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      6. div-sub 62.6%

         \[\leadsto \left(\frac{y}{z} \cdot \frac{x}{b - y} + \color{blue}{\frac{t - a}{b - y}}\right) - \frac{y \cdot \left(t - a\right)}{z \cdot {\left(b - y\right)}^{2}} \]

      7. times-frac 99.8%

         \[\leadsto \left(\frac{y}{z} \cdot \frac{x}{b - y} + \frac{t - a}{b - y}\right) - \color{blue}{\frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}} \]

   5. Simplified 99.8%

      \[\leadsto \color{blue}{\left(\frac{y}{z} \cdot \frac{x}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}} \]

   if 1.0000000000000001e299 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < +inf.0

   1. Initial program 29.5%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 72.6%

      \[\leadsto \color{blue}{x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)} \]
3. Recombined 4 regimes into one program.

4. Final simplification 94.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq -\infty:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq -2 \cdot 10^{-267}:\\ \;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq 0:\\ \;\;\;\;\left(\frac{t - a}{b - y} + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq 10^{+299}:\\ \;\;\;\;\frac{\mathsf{fma}\left(x, y, z \cdot \left(t - a\right)\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y} \leq \infty:\\ \;\;\;\;x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;\left(\frac{t - a}{b - y} + \frac{y}{z} \cdot \frac{x}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 84.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ \mathbf{if}\;z \leq -2.15 \cdot 10^{+105} \lor \neg \left(z \leq 0.027\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(\frac{y}{t\_1} + \frac{z \cdot \left(t - a\right)}{x \cdot t\_1}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y)))))
   (if (or (<= z -2.15e+105) (not (<= z 0.027)))
     (/ (- t a) (- b y))
     (* x (+ (/ y t_1) (/ (* z (- t a)) (* x t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double tmp;
	if ((z <= -2.15e+105) || !(z <= 0.027)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x * ((y / t_1) + ((z * (t - a)) / (x * t_1)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = y + (z * (b - y))
    if ((z <= (-2.15d+105)) .or. (.not. (z <= 0.027d0))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x * ((y / t_1) + ((z * (t - a)) / (x * t_1)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double tmp;
	if ((z <= -2.15e+105) || !(z <= 0.027)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x * ((y / t_1) + ((z * (t - a)) / (x * t_1)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	tmp = 0
	if (z <= -2.15e+105) or not (z <= 0.027):
		tmp = (t - a) / (b - y)
	else:
		tmp = x * ((y / t_1) + ((z * (t - a)) / (x * t_1)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	tmp = 0.0
	if ((z <= -2.15e+105) || !(z <= 0.027))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x * Float64(Float64(y / t_1) + Float64(Float64(z * Float64(t - a)) / Float64(x * t_1))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	tmp = 0.0;
	if ((z <= -2.15e+105) || ~((z <= 0.027)))
		tmp = (t - a) / (b - y);
	else
		tmp = x * ((y / t_1) + ((z * (t - a)) / (x * t_1)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[z, -2.15e+105], N[Not[LessEqual[z, 0.027]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y / t$95$1), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(x * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -2.1500000000000001e105 or 0.0269999999999999997 < z

   1. Initial program 44.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 84.9%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -2.1500000000000001e105 < z < 0.0269999999999999997

   1. Initial program 84.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 89.6%

      \[\leadsto \color{blue}{x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 87.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.15 \cdot 10^{+105} \lor \neg \left(z \leq 0.027\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 52.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -2.55 \cdot 10^{+14}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-62}:\\ \;\;\;\;\frac{a}{y - b}\\ \mathbf{elif}\;y \leq -8.2 \cdot 10^{-72}:\\ \;\;\;\;\frac{x \cdot y}{y}\\ \mathbf{elif}\;y \leq 3.9 \cdot 10^{-30}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;y \leq 4.5 \cdot 10^{+200} \lor \neg \left(y \leq 2.5 \cdot 10^{+220}\right):\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{a - t}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ x (- 1.0 z))))
   (if (<= y -2.55e+14)
     t_1
     (if (<= y -3.4e-62)
       (/ a (- y b))
       (if (<= y -8.2e-72)
         (/ (* x y) y)
         (if (<= y 3.9e-30)
           (/ (- t a) b)
           (if (or (<= y 4.5e+200) (not (<= y 2.5e+220)))
             t_1
             (/ (- a t) y))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -2.55e+14) {
		tmp = t_1;
	} else if (y <= -3.4e-62) {
		tmp = a / (y - b);
	} else if (y <= -8.2e-72) {
		tmp = (x * y) / y;
	} else if (y <= 3.9e-30) {
		tmp = (t - a) / b;
	} else if ((y <= 4.5e+200) || !(y <= 2.5e+220)) {
		tmp = t_1;
	} else {
		tmp = (a - t) / y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (1.0d0 - z)
    if (y <= (-2.55d+14)) then
        tmp = t_1
    else if (y <= (-3.4d-62)) then
        tmp = a / (y - b)
    else if (y <= (-8.2d-72)) then
        tmp = (x * y) / y
    else if (y <= 3.9d-30) then
        tmp = (t - a) / b
    else if ((y <= 4.5d+200) .or. (.not. (y <= 2.5d+220))) then
        tmp = t_1
    else
        tmp = (a - t) / y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -2.55e+14) {
		tmp = t_1;
	} else if (y <= -3.4e-62) {
		tmp = a / (y - b);
	} else if (y <= -8.2e-72) {
		tmp = (x * y) / y;
	} else if (y <= 3.9e-30) {
		tmp = (t - a) / b;
	} else if ((y <= 4.5e+200) || !(y <= 2.5e+220)) {
		tmp = t_1;
	} else {
		tmp = (a - t) / y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (1.0 - z)
	tmp = 0
	if y <= -2.55e+14:
		tmp = t_1
	elif y <= -3.4e-62:
		tmp = a / (y - b)
	elif y <= -8.2e-72:
		tmp = (x * y) / y
	elif y <= 3.9e-30:
		tmp = (t - a) / b
	elif (y <= 4.5e+200) or not (y <= 2.5e+220):
		tmp = t_1
	else:
		tmp = (a - t) / y
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -2.55e+14)
		tmp = t_1;
	elseif (y <= -3.4e-62)
		tmp = Float64(a / Float64(y - b));
	elseif (y <= -8.2e-72)
		tmp = Float64(Float64(x * y) / y);
	elseif (y <= 3.9e-30)
		tmp = Float64(Float64(t - a) / b);
	elseif ((y <= 4.5e+200) || !(y <= 2.5e+220))
		tmp = t_1;
	else
		tmp = Float64(Float64(a - t) / y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -2.55e+14)
		tmp = t_1;
	elseif (y <= -3.4e-62)
		tmp = a / (y - b);
	elseif (y <= -8.2e-72)
		tmp = (x * y) / y;
	elseif (y <= 3.9e-30)
		tmp = (t - a) / b;
	elseif ((y <= 4.5e+200) || ~((y <= 2.5e+220)))
		tmp = t_1;
	else
		tmp = (a - t) / y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.55e+14], t$95$1, If[LessEqual[y, -3.4e-62], N[(a / N[(y - b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -8.2e-72], N[(N[(x * y), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 3.9e-30], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[Or[LessEqual[y, 4.5e+200], N[Not[LessEqual[y, 2.5e+220]], $MachinePrecision]], t$95$1, N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if y < -2.55e14 or 3.9000000000000003e-30 < y < 4.49999999999999969e200 or 2.5000000000000001e220 < y

   1. Initial program 50.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 55.9%

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

      1. mul-1-neg 55.9%

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

      2. unsub-neg 55.9%

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

   5. Simplified 55.9%

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

   if -2.55e14 < y < -3.39999999999999988e-62

   1. Initial program 71.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 53.5%

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

      1. +-commutative 53.5%

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

      2. mul-1-neg 53.5%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 53.5%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 53.5%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 53.5%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 53.5%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in z around inf 52.0%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b - y}} \]
   7. Step-by-step derivation

      1. associate-*r/ 52.0%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b - y}} \]

      2. mul-1-neg 52.0%

         \[\leadsto \frac{\color{blue}{-a}}{b - y} \]

   8. Simplified 52.0%

      \[\leadsto \color{blue}{\frac{-a}{b - y}} \]

   if -3.39999999999999988e-62 < y < -8.20000000000000007e-72

   1. Initial program 69.7%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 67.2%

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

      1. *-commutative 67.2%

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

   5. Simplified 67.2%

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

   6. Taylor expanded in z around 0 67.2%

      \[\leadsto \frac{y \cdot x}{\color{blue}{y}} \]

   if -8.20000000000000007e-72 < y < 3.9000000000000003e-30

   1. Initial program 82.9%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 67.9%

      \[\leadsto \color{blue}{\frac{t - a}{b}} \]

   if 4.49999999999999969e200 < y < 2.5000000000000001e220

   1. Initial program 46.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 63.1%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   4. Taylor expanded in b around 0 63.1%

      \[\leadsto \color{blue}{-1 \cdot \frac{t - a}{y}} \]
   5. Step-by-step derivation

      1. associate-*r/ 63.1%

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

      2. mul-1-neg 63.1%

         \[\leadsto \frac{\color{blue}{-\left(t - a\right)}}{y} \]

   6. Simplified 63.1%

      \[\leadsto \color{blue}{\frac{-\left(t - a\right)}{y}} \]
3. Recombined 5 regimes into one program.

4. Final simplification 61.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2.55 \cdot 10^{+14}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-62}:\\ \;\;\;\;\frac{a}{y - b}\\ \mathbf{elif}\;y \leq -8.2 \cdot 10^{-72}:\\ \;\;\;\;\frac{x \cdot y}{y}\\ \mathbf{elif}\;y \leq 3.9 \cdot 10^{-30}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;y \leq 4.5 \cdot 10^{+200} \lor \neg \left(y \leq 2.5 \cdot 10^{+220}\right):\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;\frac{a - t}{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 71.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x \cdot y - z \cdot a}{y + z \cdot \left(b - y\right)}\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5.8 \cdot 10^{-49}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{-183}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2 \cdot 10^{-233}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 0.027:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- (* x y) (* z a)) (+ y (* z (- b y)))))
        (t_2 (/ (- t a) (- b y))))
   (if (<= z -5.8e-49)
     t_2
     (if (<= z -2.1e-183)
       t_1
       (if (<= z 2e-233) (/ x (- 1.0 z)) (if (<= z 0.027) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x * y) - (z * a)) / (y + (z * (b - y)));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.8e-49) {
		tmp = t_2;
	} else if (z <= -2.1e-183) {
		tmp = t_1;
	} else if (z <= 2e-233) {
		tmp = x / (1.0 - z);
	} else if (z <= 0.027) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((x * y) - (z * a)) / (y + (z * (b - y)))
    t_2 = (t - a) / (b - y)
    if (z <= (-5.8d-49)) then
        tmp = t_2
    else if (z <= (-2.1d-183)) then
        tmp = t_1
    else if (z <= 2d-233) then
        tmp = x / (1.0d0 - z)
    else if (z <= 0.027d0) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x * y) - (z * a)) / (y + (z * (b - y)));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.8e-49) {
		tmp = t_2;
	} else if (z <= -2.1e-183) {
		tmp = t_1;
	} else if (z <= 2e-233) {
		tmp = x / (1.0 - z);
	} else if (z <= 0.027) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = ((x * y) - (z * a)) / (y + (z * (b - y)))
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -5.8e-49:
		tmp = t_2
	elif z <= -2.1e-183:
		tmp = t_1
	elif z <= 2e-233:
		tmp = x / (1.0 - z)
	elif z <= 0.027:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(Float64(x * y) - Float64(z * a)) / Float64(y + Float64(z * Float64(b - y))))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5.8e-49)
		tmp = t_2;
	elseif (z <= -2.1e-183)
		tmp = t_1;
	elseif (z <= 2e-233)
		tmp = Float64(x / Float64(1.0 - z));
	elseif (z <= 0.027)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = ((x * y) - (z * a)) / (y + (z * (b - y)));
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -5.8e-49)
		tmp = t_2;
	elseif (z <= -2.1e-183)
		tmp = t_1;
	elseif (z <= 2e-233)
		tmp = x / (1.0 - z);
	elseif (z <= 0.027)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x * y), $MachinePrecision] - N[(z * a), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.8e-49], t$95$2, If[LessEqual[z, -2.1e-183], t$95$1, If[LessEqual[z, 2e-233], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.027], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -5.8e-49 or 0.0269999999999999997 < z

   1. Initial program 51.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 80.3%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -5.8e-49 < z < -2.1000000000000002e-183 or 1.99999999999999992e-233 < z < 0.0269999999999999997

   1. Initial program 93.5%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 73.2%

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

      1. +-commutative 73.2%

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

      2. mul-1-neg 73.2%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 73.2%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 73.2%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 73.2%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 73.2%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   if -2.1000000000000002e-183 < z < 1.99999999999999992e-233

   1. Initial program 76.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 76.8%

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

      1. mul-1-neg 76.8%

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

      2. unsub-neg 76.8%

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

   5. Simplified 76.8%

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

4. Final simplification 78.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5.8 \cdot 10^{-49}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{-183}:\\ \;\;\;\;\frac{x \cdot y - z \cdot a}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;z \leq 2 \cdot 10^{-233}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 0.027:\\ \;\;\;\;\frac{x \cdot y - z \cdot a}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 68.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -2.1 \cdot 10^{-52}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -6.8 \cdot 10^{-191}:\\ \;\;\;\;\frac{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}{y}\\ \mathbf{elif}\;z \leq 7 \cdot 10^{-227}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 8.6 \cdot 10^{-20}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + x \cdot y}{y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -2.1e-52)
     t_1
     (if (<= z -6.8e-191)
       (/ (* y (+ x (* z (/ (- t a) y)))) y)
       (if (<= z 7e-227)
         (/ x (- 1.0 z))
         (if (<= z 8.6e-20) (/ (+ (* z (- t a)) (* x y)) y) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -2.1e-52) {
		tmp = t_1;
	} else if (z <= -6.8e-191) {
		tmp = (y * (x + (z * ((t - a) / y)))) / y;
	} else if (z <= 7e-227) {
		tmp = x / (1.0 - z);
	} else if (z <= 8.6e-20) {
		tmp = ((z * (t - a)) + (x * y)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-2.1d-52)) then
        tmp = t_1
    else if (z <= (-6.8d-191)) then
        tmp = (y * (x + (z * ((t - a) / y)))) / y
    else if (z <= 7d-227) then
        tmp = x / (1.0d0 - z)
    else if (z <= 8.6d-20) then
        tmp = ((z * (t - a)) + (x * y)) / y
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -2.1e-52) {
		tmp = t_1;
	} else if (z <= -6.8e-191) {
		tmp = (y * (x + (z * ((t - a) / y)))) / y;
	} else if (z <= 7e-227) {
		tmp = x / (1.0 - z);
	} else if (z <= 8.6e-20) {
		tmp = ((z * (t - a)) + (x * y)) / y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -2.1e-52:
		tmp = t_1
	elif z <= -6.8e-191:
		tmp = (y * (x + (z * ((t - a) / y)))) / y
	elif z <= 7e-227:
		tmp = x / (1.0 - z)
	elif z <= 8.6e-20:
		tmp = ((z * (t - a)) + (x * y)) / y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -2.1e-52)
		tmp = t_1;
	elseif (z <= -6.8e-191)
		tmp = Float64(Float64(y * Float64(x + Float64(z * Float64(Float64(t - a) / y)))) / y);
	elseif (z <= 7e-227)
		tmp = Float64(x / Float64(1.0 - z));
	elseif (z <= 8.6e-20)
		tmp = Float64(Float64(Float64(z * Float64(t - a)) + Float64(x * y)) / y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -2.1e-52)
		tmp = t_1;
	elseif (z <= -6.8e-191)
		tmp = (y * (x + (z * ((t - a) / y)))) / y;
	elseif (z <= 7e-227)
		tmp = x / (1.0 - z);
	elseif (z <= 8.6e-20)
		tmp = ((z * (t - a)) + (x * y)) / y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.1e-52], t$95$1, If[LessEqual[z, -6.8e-191], N[(N[(y * N[(x + N[(z * N[(N[(t - a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[z, 7e-227], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.6e-20], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -2.0999999999999999e-52 or 8.60000000000000022e-20 < z

   1. Initial program 52.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 79.2%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -2.0999999999999999e-52 < z < -6.79999999999999988e-191

   1. Initial program 90.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 86.3%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + \frac{z \cdot \left(t - a\right)}{y}\right)}}{y + z \cdot \left(b - y\right)} \]
   4. Step-by-step derivation

      1. associate-/l* 81.9%

         \[\leadsto \frac{y \cdot \left(x + \color{blue}{z \cdot \frac{t - a}{y}}\right)}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 81.9%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in z around 0 77.0%

      \[\leadsto \frac{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}{\color{blue}{y}} \]

   if -6.79999999999999988e-191 < z < 7.0000000000000002e-227

   1. Initial program 75.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 78.1%

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

      1. mul-1-neg 78.1%

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

      2. unsub-neg 78.1%

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

   5. Simplified 78.1%

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

   if 7.0000000000000002e-227 < z < 8.60000000000000022e-20

   1. Initial program 97.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 61.5%

      \[\leadsto \frac{x \cdot y + z \cdot \left(t - a\right)}{\color{blue}{y}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 76.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.1 \cdot 10^{-52}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq -6.8 \cdot 10^{-191}:\\ \;\;\;\;\frac{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}{y}\\ \mathbf{elif}\;z \leq 7 \cdot 10^{-227}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 8.6 \cdot 10^{-20}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + x \cdot y}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 69.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z \cdot \left(t - a\right) + x \cdot y}{y}\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -1.7 \cdot 10^{-49}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -9 \cdot 10^{-191}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 4.2 \cdot 10^{-233}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 7 \cdot 10^{-20}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (+ (* z (- t a)) (* x y)) y)) (t_2 (/ (- t a) (- b y))))
   (if (<= z -1.7e-49)
     t_2
     (if (<= z -9e-191)
       t_1
       (if (<= z 4.2e-233) (/ x (- 1.0 z)) (if (<= z 7e-20) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((z * (t - a)) + (x * y)) / y;
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.7e-49) {
		tmp = t_2;
	} else if (z <= -9e-191) {
		tmp = t_1;
	} else if (z <= 4.2e-233) {
		tmp = x / (1.0 - z);
	} else if (z <= 7e-20) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((z * (t - a)) + (x * y)) / y
    t_2 = (t - a) / (b - y)
    if (z <= (-1.7d-49)) then
        tmp = t_2
    else if (z <= (-9d-191)) then
        tmp = t_1
    else if (z <= 4.2d-233) then
        tmp = x / (1.0d0 - z)
    else if (z <= 7d-20) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((z * (t - a)) + (x * y)) / y;
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.7e-49) {
		tmp = t_2;
	} else if (z <= -9e-191) {
		tmp = t_1;
	} else if (z <= 4.2e-233) {
		tmp = x / (1.0 - z);
	} else if (z <= 7e-20) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = ((z * (t - a)) + (x * y)) / y
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -1.7e-49:
		tmp = t_2
	elif z <= -9e-191:
		tmp = t_1
	elif z <= 4.2e-233:
		tmp = x / (1.0 - z)
	elif z <= 7e-20:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(Float64(z * Float64(t - a)) + Float64(x * y)) / y)
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -1.7e-49)
		tmp = t_2;
	elseif (z <= -9e-191)
		tmp = t_1;
	elseif (z <= 4.2e-233)
		tmp = Float64(x / Float64(1.0 - z));
	elseif (z <= 7e-20)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = ((z * (t - a)) + (x * y)) / y;
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -1.7e-49)
		tmp = t_2;
	elseif (z <= -9e-191)
		tmp = t_1;
	elseif (z <= 4.2e-233)
		tmp = x / (1.0 - z);
	elseif (z <= 7e-20)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.7e-49], t$95$2, If[LessEqual[z, -9e-191], t$95$1, If[LessEqual[z, 4.2e-233], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7e-20], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.70000000000000002e-49 or 7.00000000000000007e-20 < z

   1. Initial program 52.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 79.2%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -1.70000000000000002e-49 < z < -9.00000000000000017e-191 or 4.1999999999999997e-233 < z < 7.00000000000000007e-20

   1. Initial program 94.7%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 67.2%

      \[\leadsto \frac{x \cdot y + z \cdot \left(t - a\right)}{\color{blue}{y}} \]

   if -9.00000000000000017e-191 < z < 4.1999999999999997e-233

   1. Initial program 75.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 78.1%

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

      1. mul-1-neg 78.1%

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

      2. unsub-neg 78.1%

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

   5. Simplified 78.1%

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

4. Final simplification 76.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.7 \cdot 10^{-49}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq -9 \cdot 10^{-191}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + x \cdot y}{y}\\ \mathbf{elif}\;z \leq 4.2 \cdot 10^{-233}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;z \leq 7 \cdot 10^{-20}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + x \cdot y}{y}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 83.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2 \cdot 10^{+106} \lor \neg \left(z \leq 10^{+77}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -2e+106) (not (<= z 1e+77)))
   (/ (- t a) (- b y))
   (/ (- (* z (- a t)) (* x y)) (- (* z (- y b)) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -2e+106) || !(z <= 1e+77)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-2d+106)) .or. (.not. (z <= 1d+77))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -2e+106) || !(z <= 1e+77)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -2e+106) or not (z <= 1e+77):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -2e+106) || !(z <= 1e+77))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(z * Float64(a - t)) - Float64(x * y)) / Float64(Float64(z * Float64(y - b)) - y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -2e+106) || ~((z <= 1e+77)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((z * (a - t)) - (x * y)) / ((z * (y - b)) - y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -2e+106], N[Not[LessEqual[z, 1e+77]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z * N[(a - t), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision] / N[(N[(z * N[(y - b), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -2.00000000000000018e106 or 9.99999999999999983e76 < z

   1. Initial program 36.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 84.4%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -2.00000000000000018e106 < z < 9.99999999999999983e76

   1. Initial program 85.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing
3. Recombined 2 regimes into one program.

4. Final simplification 84.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2 \cdot 10^{+106} \lor \neg \left(z \leq 10^{+77}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(a - t\right) - x \cdot y}{z \cdot \left(y - b\right) - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 44.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.6 \cdot 10^{+33} \lor \neg \left(z \leq -4.2 \cdot 10^{-10} \lor \neg \left(z \leq -3 \cdot 10^{-68}\right) \land z \leq 0.00195\right):\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.6e+33)
         (not (or (<= z -4.2e-10) (and (not (<= z -3e-68)) (<= z 0.00195)))))
   (/ t (- b y))
   (/ x (- 1.0 z))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.6e+33) || !((z <= -4.2e-10) || (!(z <= -3e-68) && (z <= 0.00195)))) {
		tmp = t / (b - y);
	} else {
		tmp = x / (1.0 - z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-1.6d+33)) .or. (.not. (z <= (-4.2d-10)) .or. (.not. (z <= (-3d-68))) .and. (z <= 0.00195d0))) then
        tmp = t / (b - y)
    else
        tmp = x / (1.0d0 - z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.6e+33) || !((z <= -4.2e-10) || (!(z <= -3e-68) && (z <= 0.00195)))) {
		tmp = t / (b - y);
	} else {
		tmp = x / (1.0 - z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.6e+33) or not ((z <= -4.2e-10) or (not (z <= -3e-68) and (z <= 0.00195))):
		tmp = t / (b - y)
	else:
		tmp = x / (1.0 - z)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.6e+33) || !((z <= -4.2e-10) || (!(z <= -3e-68) && (z <= 0.00195))))
		tmp = Float64(t / Float64(b - y));
	else
		tmp = Float64(x / Float64(1.0 - z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.6e+33) || ~(((z <= -4.2e-10) || (~((z <= -3e-68)) && (z <= 0.00195)))))
		tmp = t / (b - y);
	else
		tmp = x / (1.0 - z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.6e+33], N[Not[Or[LessEqual[z, -4.2e-10], And[N[Not[LessEqual[z, -3e-68]], $MachinePrecision], LessEqual[z, 0.00195]]]], $MachinePrecision]], N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1.60000000000000009e33 or -4.2e-10 < z < -3e-68 or 0.0019499999999999999 < z

   1. Initial program 51.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 81.8%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   4. Taylor expanded in t around inf 46.4%

      \[\leadsto \color{blue}{\frac{t}{b - y}} \]

   if -1.60000000000000009e33 < z < -4.2e-10 or -3e-68 < z < 0.0019499999999999999

   1. Initial program 85.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 57.2%

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

      1. mul-1-neg 57.2%

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

      2. unsub-neg 57.2%

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

   5. Simplified 57.2%

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

4. Final simplification 50.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.6 \cdot 10^{+33} \lor \neg \left(z \leq -4.2 \cdot 10^{-10} \lor \neg \left(z \leq -3 \cdot 10^{-68}\right) \land z \leq 0.00195\right):\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 53.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -6.5 \cdot 10^{+16}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -3.3 \cdot 10^{-62}:\\ \;\;\;\;\frac{a}{y - b}\\ \mathbf{elif}\;y \leq -8.2 \cdot 10^{-72}:\\ \;\;\;\;\frac{x \cdot y}{y}\\ \mathbf{elif}\;y \leq 7 \cdot 10^{-30}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ x (- 1.0 z))))
   (if (<= y -6.5e+16)
     t_1
     (if (<= y -3.3e-62)
       (/ a (- y b))
       (if (<= y -8.2e-72)
         (/ (* x y) y)
         (if (<= y 7e-30) (/ (- t a) b) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -6.5e+16) {
		tmp = t_1;
	} else if (y <= -3.3e-62) {
		tmp = a / (y - b);
	} else if (y <= -8.2e-72) {
		tmp = (x * y) / y;
	} else if (y <= 7e-30) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (1.0d0 - z)
    if (y <= (-6.5d+16)) then
        tmp = t_1
    else if (y <= (-3.3d-62)) then
        tmp = a / (y - b)
    else if (y <= (-8.2d-72)) then
        tmp = (x * y) / y
    else if (y <= 7d-30) then
        tmp = (t - a) / b
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -6.5e+16) {
		tmp = t_1;
	} else if (y <= -3.3e-62) {
		tmp = a / (y - b);
	} else if (y <= -8.2e-72) {
		tmp = (x * y) / y;
	} else if (y <= 7e-30) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (1.0 - z)
	tmp = 0
	if y <= -6.5e+16:
		tmp = t_1
	elif y <= -3.3e-62:
		tmp = a / (y - b)
	elif y <= -8.2e-72:
		tmp = (x * y) / y
	elif y <= 7e-30:
		tmp = (t - a) / b
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -6.5e+16)
		tmp = t_1;
	elseif (y <= -3.3e-62)
		tmp = Float64(a / Float64(y - b));
	elseif (y <= -8.2e-72)
		tmp = Float64(Float64(x * y) / y);
	elseif (y <= 7e-30)
		tmp = Float64(Float64(t - a) / b);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -6.5e+16)
		tmp = t_1;
	elseif (y <= -3.3e-62)
		tmp = a / (y - b);
	elseif (y <= -8.2e-72)
		tmp = (x * y) / y;
	elseif (y <= 7e-30)
		tmp = (t - a) / b;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.5e+16], t$95$1, If[LessEqual[y, -3.3e-62], N[(a / N[(y - b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -8.2e-72], N[(N[(x * y), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 7e-30], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -6.5e16 or 7.0000000000000006e-30 < y

   1. Initial program 50.1%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 53.0%

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

      1. mul-1-neg 53.0%

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

      2. unsub-neg 53.0%

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

   5. Simplified 53.0%

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

   if -6.5e16 < y < -3.30000000000000004e-62

   1. Initial program 71.6%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 53.5%

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

      1. +-commutative 53.5%

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

      2. mul-1-neg 53.5%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 53.5%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 53.5%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 53.5%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 53.5%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in z around inf 52.0%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b - y}} \]
   7. Step-by-step derivation

      1. associate-*r/ 52.0%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b - y}} \]

      2. mul-1-neg 52.0%

         \[\leadsto \frac{\color{blue}{-a}}{b - y} \]

   8. Simplified 52.0%

      \[\leadsto \color{blue}{\frac{-a}{b - y}} \]

   if -3.30000000000000004e-62 < y < -8.20000000000000007e-72

   1. Initial program 69.7%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 67.2%

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

      1. *-commutative 67.2%

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

   5. Simplified 67.2%

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

   6. Taylor expanded in z around 0 67.2%

      \[\leadsto \frac{y \cdot x}{\color{blue}{y}} \]

   if -8.20000000000000007e-72 < y < 7.0000000000000006e-30

   1. Initial program 82.9%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 67.9%

      \[\leadsto \color{blue}{\frac{t - a}{b}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 59.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -6.5 \cdot 10^{+16}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;y \leq -3.3 \cdot 10^{-62}:\\ \;\;\;\;\frac{a}{y - b}\\ \mathbf{elif}\;y \leq -8.2 \cdot 10^{-72}:\\ \;\;\;\;\frac{x \cdot y}{y}\\ \mathbf{elif}\;y \leq 7 \cdot 10^{-30}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 36.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-a}{b}\\ \mathbf{if}\;z \leq -1.8 \cdot 10^{+186}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -6.5 \cdot 10^{+54}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq -1.25 \cdot 10^{-39} \lor \neg \left(z \leq 5.4 \cdot 10^{-91}\right):\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a) b)))
   (if (<= z -1.8e+186)
     t_1
     (if (<= z -6.5e+54)
       (/ t b)
       (if (or (<= z -1.25e-39) (not (<= z 5.4e-91))) t_1 x)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -1.8e+186) {
		tmp = t_1;
	} else if (z <= -6.5e+54) {
		tmp = t / b;
	} else if ((z <= -1.25e-39) || !(z <= 5.4e-91)) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -a / b
    if (z <= (-1.8d+186)) then
        tmp = t_1
    else if (z <= (-6.5d+54)) then
        tmp = t / b
    else if ((z <= (-1.25d-39)) .or. (.not. (z <= 5.4d-91))) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -1.8e+186) {
		tmp = t_1;
	} else if (z <= -6.5e+54) {
		tmp = t / b;
	} else if ((z <= -1.25e-39) || !(z <= 5.4e-91)) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -a / b
	tmp = 0
	if z <= -1.8e+186:
		tmp = t_1
	elif z <= -6.5e+54:
		tmp = t / b
	elif (z <= -1.25e-39) or not (z <= 5.4e-91):
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(-a) / b)
	tmp = 0.0
	if (z <= -1.8e+186)
		tmp = t_1;
	elseif (z <= -6.5e+54)
		tmp = Float64(t / b);
	elseif ((z <= -1.25e-39) || !(z <= 5.4e-91))
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -a / b;
	tmp = 0.0;
	if (z <= -1.8e+186)
		tmp = t_1;
	elseif (z <= -6.5e+54)
		tmp = t / b;
	elseif ((z <= -1.25e-39) || ~((z <= 5.4e-91)))
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[((-a) / b), $MachinePrecision]}, If[LessEqual[z, -1.8e+186], t$95$1, If[LessEqual[z, -6.5e+54], N[(t / b), $MachinePrecision], If[Or[LessEqual[z, -1.25e-39], N[Not[LessEqual[z, 5.4e-91]], $MachinePrecision]], t$95$1, x]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.8000000000000001e186 or -6.5e54 < z < -1.25e-39 or 5.3999999999999995e-91 < z

   1. Initial program 54.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 37.9%

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

      1. +-commutative 37.9%

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

      2. mul-1-neg 37.9%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 37.9%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 37.9%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 37.9%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 37.9%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in y around 0 30.3%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b}} \]
   7. Step-by-step derivation

      1. associate-*r/ 30.3%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b}} \]

      2. mul-1-neg 30.3%

         \[\leadsto \frac{\color{blue}{-a}}{b} \]

   8. Simplified 30.3%

      \[\leadsto \color{blue}{\frac{-a}{b}} \]

   if -1.8000000000000001e186 < z < -6.5e54

   1. Initial program 65.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 56.4%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + \frac{z \cdot \left(t - a\right)}{y}\right)}}{y + z \cdot \left(b - y\right)} \]
   4. Step-by-step derivation

      1. associate-/l* 56.4%

         \[\leadsto \frac{y \cdot \left(x + \color{blue}{z \cdot \frac{t - a}{y}}\right)}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 56.4%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in b around inf 15.9%

      \[\leadsto \color{blue}{\frac{y \cdot \left(x + \frac{z \cdot \left(t - a\right)}{y}\right)}{b \cdot z}} \]
   7. Step-by-step derivation

      1. associate-/l* 15.3%

         \[\leadsto \color{blue}{y \cdot \frac{x + \frac{z \cdot \left(t - a\right)}{y}}{b \cdot z}} \]

      2. associate-/l* 15.3%

         \[\leadsto y \cdot \frac{x + \color{blue}{z \cdot \frac{t - a}{y}}}{b \cdot z} \]

      3. *-commutative 15.3%

         \[\leadsto y \cdot \frac{x + z \cdot \frac{t - a}{y}}{\color{blue}{z \cdot b}} \]

   8. Simplified 15.3%

      \[\leadsto \color{blue}{y \cdot \frac{x + z \cdot \frac{t - a}{y}}{z \cdot b}} \]

   9. Taylor expanded in t around inf 24.3%

      \[\leadsto \color{blue}{\frac{t}{b}} \]

   if -1.25e-39 < z < 5.3999999999999995e-91

   1. Initial program 83.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 62.7%

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

4. Final simplification 40.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.8 \cdot 10^{+186}:\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{elif}\;z \leq -6.5 \cdot 10^{+54}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq -1.25 \cdot 10^{-39} \lor \neg \left(z \leq 5.4 \cdot 10^{-91}\right):\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 35.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-a}{b}\\ \mathbf{if}\;z \leq -2.8 \cdot 10^{+185}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -0.76:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 1.3 \cdot 10^{-90}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a) b)))
   (if (<= z -2.8e+185)
     t_1
     (if (<= z -0.76) (/ x (- z)) (if (<= z 1.3e-90) (+ x (* x z)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -2.8e+185) {
		tmp = t_1;
	} else if (z <= -0.76) {
		tmp = x / -z;
	} else if (z <= 1.3e-90) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -a / b
    if (z <= (-2.8d+185)) then
        tmp = t_1
    else if (z <= (-0.76d0)) then
        tmp = x / -z
    else if (z <= 1.3d-90) then
        tmp = x + (x * z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -2.8e+185) {
		tmp = t_1;
	} else if (z <= -0.76) {
		tmp = x / -z;
	} else if (z <= 1.3e-90) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -a / b
	tmp = 0
	if z <= -2.8e+185:
		tmp = t_1
	elif z <= -0.76:
		tmp = x / -z
	elif z <= 1.3e-90:
		tmp = x + (x * z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(-a) / b)
	tmp = 0.0
	if (z <= -2.8e+185)
		tmp = t_1;
	elseif (z <= -0.76)
		tmp = Float64(x / Float64(-z));
	elseif (z <= 1.3e-90)
		tmp = Float64(x + Float64(x * z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -a / b;
	tmp = 0.0;
	if (z <= -2.8e+185)
		tmp = t_1;
	elseif (z <= -0.76)
		tmp = x / -z;
	elseif (z <= 1.3e-90)
		tmp = x + (x * z);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[((-a) / b), $MachinePrecision]}, If[LessEqual[z, -2.8e+185], t$95$1, If[LessEqual[z, -0.76], N[(x / (-z)), $MachinePrecision], If[LessEqual[z, 1.3e-90], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.79999999999999982e185 or 1.3e-90 < z

   1. Initial program 51.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 36.2%

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

      1. +-commutative 36.2%

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

      2. mul-1-neg 36.2%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 36.2%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 36.2%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 36.2%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 36.2%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in y around 0 30.4%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b}} \]
   7. Step-by-step derivation

      1. associate-*r/ 30.4%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b}} \]

      2. mul-1-neg 30.4%

         \[\leadsto \frac{\color{blue}{-a}}{b} \]

   8. Simplified 30.4%

      \[\leadsto \color{blue}{\frac{-a}{b}} \]

   if -2.79999999999999982e185 < z < -0.76000000000000001

   1. Initial program 65.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 17.9%

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

      1. *-commutative 17.9%

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

   5. Simplified 17.9%

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

   6. Taylor expanded in b around 0 13.4%

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

      1. mul-1-neg 13.4%

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

      2. distribute-lft-neg-out 13.4%

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

      3. *-commutative 13.4%

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

   8. Simplified 13.4%

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

   9. Taylor expanded in z around inf 31.7%

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

       1. associate-*r/ 31.7%

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

       2. mul-1-neg 31.7%

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

   11. Simplified 31.7%

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

   if -0.76000000000000001 < z < 1.3e-90

   1. Initial program 85.2%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 66.1%

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

      1. +-commutative 66.1%

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

      2. mul-1-neg 66.1%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 66.1%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 66.1%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 66.1%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 66.1%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in z around 0 53.4%

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

      1. associate-*r/ 53.4%

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

      2. mul-1-neg 53.4%

         \[\leadsto x + z \cdot \left(\frac{\color{blue}{-a}}{y} - \frac{x \cdot \left(b - y\right)}{y}\right) \]

      3. *-commutative 53.4%

         \[\leadsto x + z \cdot \left(\frac{-a}{y} - \frac{\color{blue}{\left(b - y\right) \cdot x}}{y}\right) \]

   8. Simplified 53.4%

      \[\leadsto \color{blue}{x + z \cdot \left(\frac{-a}{y} - \frac{\left(b - y\right) \cdot x}{y}\right)} \]

   9. Taylor expanded in y around inf 57.9%

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

       1. *-commutative 57.9%

          \[\leadsto x + \color{blue}{z \cdot x} \]

   11. Simplified 57.9%

       \[\leadsto x + \color{blue}{z \cdot x} \]
3. Recombined 3 regimes into one program.

4. Final simplification 40.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.8 \cdot 10^{+185}:\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{elif}\;z \leq -0.76:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 1.3 \cdot 10^{-90}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;\frac{-a}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 35.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-a}{b}\\ \mathbf{if}\;z \leq -2.9 \cdot 10^{+186}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -0.75:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{-91}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a) b)))
   (if (<= z -2.9e+186)
     t_1
     (if (<= z -0.75) (/ x (- z)) (if (<= z 7.2e-91) (+ x (* x z)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -2.9e+186) {
		tmp = t_1;
	} else if (z <= -0.75) {
		tmp = x / -z;
	} else if (z <= 7.2e-91) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -a / b
    if (z <= (-2.9d+186)) then
        tmp = t_1
    else if (z <= (-0.75d0)) then
        tmp = x / -z
    else if (z <= 7.2d-91) then
        tmp = x + (x * z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -2.9e+186) {
		tmp = t_1;
	} else if (z <= -0.75) {
		tmp = x / -z;
	} else if (z <= 7.2e-91) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -a / b
	tmp = 0
	if z <= -2.9e+186:
		tmp = t_1
	elif z <= -0.75:
		tmp = x / -z
	elif z <= 7.2e-91:
		tmp = x + (x * z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(-a) / b)
	tmp = 0.0
	if (z <= -2.9e+186)
		tmp = t_1;
	elseif (z <= -0.75)
		tmp = Float64(x / Float64(-z));
	elseif (z <= 7.2e-91)
		tmp = Float64(x + Float64(x * z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -a / b;
	tmp = 0.0;
	if (z <= -2.9e+186)
		tmp = t_1;
	elseif (z <= -0.75)
		tmp = x / -z;
	elseif (z <= 7.2e-91)
		tmp = x + (x * z);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[((-a) / b), $MachinePrecision]}, If[LessEqual[z, -2.9e+186], t$95$1, If[LessEqual[z, -0.75], N[(x / (-z)), $MachinePrecision], If[LessEqual[z, 7.2e-91], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.9e186 or 7.2000000000000001e-91 < z

   1. Initial program 51.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 36.2%

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

      1. +-commutative 36.2%

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

      2. mul-1-neg 36.2%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 36.2%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 36.2%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 36.2%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 36.2%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in y around 0 30.4%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b}} \]
   7. Step-by-step derivation

      1. associate-*r/ 30.4%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b}} \]

      2. mul-1-neg 30.4%

         \[\leadsto \frac{\color{blue}{-a}}{b} \]

   8. Simplified 30.4%

      \[\leadsto \color{blue}{\frac{-a}{b}} \]

   if -2.9e186 < z < -0.75

   1. Initial program 65.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 17.9%

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

      1. *-commutative 17.9%

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

   5. Simplified 17.9%

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

   6. Taylor expanded in b around 0 13.4%

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

      1. mul-1-neg 13.4%

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

      2. distribute-lft-neg-out 13.4%

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

      3. *-commutative 13.4%

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

   8. Simplified 13.4%

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

   9. Taylor expanded in z around inf 31.7%

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

       1. associate-*r/ 31.7%

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

       2. mul-1-neg 31.7%

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

   11. Simplified 31.7%

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

   if -0.75 < z < 7.2000000000000001e-91

   1. Initial program 85.2%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 47.8%

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

      1. *-commutative 47.8%

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

   5. Simplified 47.8%

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

   6. Taylor expanded in b around 0 44.9%

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

      1. mul-1-neg 44.9%

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

      2. distribute-lft-neg-out 44.9%

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

      3. *-commutative 44.9%

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

   8. Simplified 44.9%

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

   9. Taylor expanded in z around 0 57.9%

      \[\leadsto \color{blue}{x + x \cdot z} \]
3. Recombined 3 regimes into one program.

4. Final simplification 40.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.9 \cdot 10^{+186}:\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{elif}\;z \leq -0.75:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{-91}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;\frac{-a}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 35.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-a}{b}\\ \mathbf{if}\;z \leq -3.9 \cdot 10^{+182}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -1:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 1.3 \cdot 10^{-90}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a) b)))
   (if (<= z -3.9e+182)
     t_1
     (if (<= z -1.0) (/ x (- z)) (if (<= z 1.3e-90) x t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -3.9e+182) {
		tmp = t_1;
	} else if (z <= -1.0) {
		tmp = x / -z;
	} else if (z <= 1.3e-90) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -a / b
    if (z <= (-3.9d+182)) then
        tmp = t_1
    else if (z <= (-1.0d0)) then
        tmp = x / -z
    else if (z <= 1.3d-90) then
        tmp = x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double tmp;
	if (z <= -3.9e+182) {
		tmp = t_1;
	} else if (z <= -1.0) {
		tmp = x / -z;
	} else if (z <= 1.3e-90) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -a / b
	tmp = 0
	if z <= -3.9e+182:
		tmp = t_1
	elif z <= -1.0:
		tmp = x / -z
	elif z <= 1.3e-90:
		tmp = x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(-a) / b)
	tmp = 0.0
	if (z <= -3.9e+182)
		tmp = t_1;
	elseif (z <= -1.0)
		tmp = Float64(x / Float64(-z));
	elseif (z <= 1.3e-90)
		tmp = x;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -a / b;
	tmp = 0.0;
	if (z <= -3.9e+182)
		tmp = t_1;
	elseif (z <= -1.0)
		tmp = x / -z;
	elseif (z <= 1.3e-90)
		tmp = x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[((-a) / b), $MachinePrecision]}, If[LessEqual[z, -3.9e+182], t$95$1, If[LessEqual[z, -1.0], N[(x / (-z)), $MachinePrecision], If[LessEqual[z, 1.3e-90], x, t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -3.8999999999999999e182 or 1.3e-90 < z

   1. Initial program 51.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 36.2%

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

      1. +-commutative 36.2%

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

      2. mul-1-neg 36.2%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 36.2%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 36.2%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 36.2%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 36.2%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in y around 0 30.4%

      \[\leadsto \color{blue}{-1 \cdot \frac{a}{b}} \]
   7. Step-by-step derivation

      1. associate-*r/ 30.4%

         \[\leadsto \color{blue}{\frac{-1 \cdot a}{b}} \]

      2. mul-1-neg 30.4%

         \[\leadsto \frac{\color{blue}{-a}}{b} \]

   8. Simplified 30.4%

      \[\leadsto \color{blue}{\frac{-a}{b}} \]

   if -3.8999999999999999e182 < z < -1

   1. Initial program 65.3%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 17.9%

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

      1. *-commutative 17.9%

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

   5. Simplified 17.9%

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

   6. Taylor expanded in b around 0 13.4%

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

      1. mul-1-neg 13.4%

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

      2. distribute-lft-neg-out 13.4%

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

      3. *-commutative 13.4%

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

   8. Simplified 13.4%

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

   9. Taylor expanded in z around inf 31.7%

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

       1. associate-*r/ 31.7%

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

       2. mul-1-neg 31.7%

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

   11. Simplified 31.7%

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

   if -1 < z < 1.3e-90

   1. Initial program 85.2%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 57.7%

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

4. Final simplification 40.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.9 \cdot 10^{+182}:\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{elif}\;z \leq -1:\\ \;\;\;\;\frac{x}{-z}\\ \mathbf{elif}\;z \leq 1.3 \cdot 10^{-90}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{-a}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 65.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.2 \cdot 10^{-70} \lor \neg \left(z \leq 1.3 \cdot 10^{-90}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -3.2e-70) (not (<= z 1.3e-90)))
   (/ (- t a) (- b y))
   (/ x (- 1.0 z))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -3.2e-70) || !(z <= 1.3e-90)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x / (1.0 - z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-3.2d-70)) .or. (.not. (z <= 1.3d-90))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x / (1.0d0 - z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -3.2e-70) || !(z <= 1.3e-90)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x / (1.0 - z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -3.2e-70) or not (z <= 1.3e-90):
		tmp = (t - a) / (b - y)
	else:
		tmp = x / (1.0 - z)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -3.2e-70) || !(z <= 1.3e-90))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x / Float64(1.0 - z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -3.2e-70) || ~((z <= 1.3e-90)))
		tmp = (t - a) / (b - y);
	else
		tmp = x / (1.0 - z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -3.2e-70], N[Not[LessEqual[z, 1.3e-90]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -3.1999999999999997e-70 or 1.3e-90 < z

   1. Initial program 57.4%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 75.4%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   if -3.1999999999999997e-70 < z < 1.3e-90

   1. Initial program 84.0%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 64.1%

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

      1. mul-1-neg 64.1%

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

      2. unsub-neg 64.1%

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

   5. Simplified 64.1%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.2 \cdot 10^{-70} \lor \neg \left(z \leq 1.3 \cdot 10^{-90}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 53.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -8.2 \cdot 10^{-72} \lor \neg \left(y \leq 3.1 \cdot 10^{-32}\right):\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -8.2e-72) (not (<= y 3.1e-32))) (/ x (- 1.0 z)) (/ (- t a) b)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -8.2e-72) || !(y <= 3.1e-32)) {
		tmp = x / (1.0 - z);
	} else {
		tmp = (t - a) / b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((y <= (-8.2d-72)) .or. (.not. (y <= 3.1d-32))) then
        tmp = x / (1.0d0 - z)
    else
        tmp = (t - a) / b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -8.2e-72) || !(y <= 3.1e-32)) {
		tmp = x / (1.0 - z);
	} else {
		tmp = (t - a) / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -8.2e-72) or not (y <= 3.1e-32):
		tmp = x / (1.0 - z)
	else:
		tmp = (t - a) / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -8.2e-72) || !(y <= 3.1e-32))
		tmp = Float64(x / Float64(1.0 - z));
	else
		tmp = Float64(Float64(t - a) / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -8.2e-72) || ~((y <= 3.1e-32)))
		tmp = x / (1.0 - z);
	else
		tmp = (t - a) / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -8.2e-72], N[Not[LessEqual[y, 3.1e-32]], $MachinePrecision]], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -8.20000000000000007e-72 or 3.10000000000000011e-32 < y

   1. Initial program 52.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 50.3%

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

      1. mul-1-neg 50.3%

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

      2. unsub-neg 50.3%

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

   5. Simplified 50.3%

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

   if -8.20000000000000007e-72 < y < 3.10000000000000011e-32

   1. Initial program 82.9%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 67.9%

      \[\leadsto \color{blue}{\frac{t - a}{b}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 57.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -8.2 \cdot 10^{-72} \lor \neg \left(y \leq 3.1 \cdot 10^{-32}\right):\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 45.0% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.55 \cdot 10^{-69} \lor \neg \left(z \leq 2.75 \cdot 10^{-43}\right):\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.55e-69) (not (<= z 2.75e-43))) (/ t (- b y)) (+ x (* x z))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.55e-69) || !(z <= 2.75e-43)) {
		tmp = t / (b - y);
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-1.55d-69)) .or. (.not. (z <= 2.75d-43))) then
        tmp = t / (b - y)
    else
        tmp = x + (x * z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.55e-69) || !(z <= 2.75e-43)) {
		tmp = t / (b - y);
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.55e-69) or not (z <= 2.75e-43):
		tmp = t / (b - y)
	else:
		tmp = x + (x * z)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.55e-69) || !(z <= 2.75e-43))
		tmp = Float64(t / Float64(b - y));
	else
		tmp = Float64(x + Float64(x * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.55e-69) || ~((z <= 2.75e-43)))
		tmp = t / (b - y);
	else
		tmp = x + (x * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.55e-69], N[Not[LessEqual[z, 2.75e-43]], $MachinePrecision]], N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1.55e-69 or 2.75000000000000006e-43 < z

   1. Initial program 54.9%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 76.8%

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]

   4. Taylor expanded in t around inf 43.5%

      \[\leadsto \color{blue}{\frac{t}{b - y}} \]

   if -1.55e-69 < z < 2.75000000000000006e-43

   1. Initial program 85.8%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 70.6%

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

      1. +-commutative 70.6%

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

      2. mul-1-neg 70.6%

         \[\leadsto \frac{x \cdot y + \color{blue}{\left(-a \cdot z\right)}}{y + z \cdot \left(b - y\right)} \]

      3. unsub-neg 70.6%

         \[\leadsto \frac{\color{blue}{x \cdot y - a \cdot z}}{y + z \cdot \left(b - y\right)} \]

      4. *-commutative 70.6%

         \[\leadsto \frac{\color{blue}{y \cdot x} - a \cdot z}{y + z \cdot \left(b - y\right)} \]

      5. *-commutative 70.6%

         \[\leadsto \frac{y \cdot x - \color{blue}{z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 70.6%

      \[\leadsto \frac{\color{blue}{y \cdot x - z \cdot a}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in z around 0 53.3%

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

      1. associate-*r/ 53.3%

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

      2. mul-1-neg 53.3%

         \[\leadsto x + z \cdot \left(\frac{\color{blue}{-a}}{y} - \frac{x \cdot \left(b - y\right)}{y}\right) \]

      3. *-commutative 53.3%

         \[\leadsto x + z \cdot \left(\frac{-a}{y} - \frac{\color{blue}{\left(b - y\right) \cdot x}}{y}\right) \]

   8. Simplified 53.3%

      \[\leadsto \color{blue}{x + z \cdot \left(\frac{-a}{y} - \frac{\left(b - y\right) \cdot x}{y}\right)} \]

   9. Taylor expanded in y around inf 59.4%

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

       1. *-commutative 59.4%

          \[\leadsto x + \color{blue}{z \cdot x} \]

   11. Simplified 59.4%

       \[\leadsto x + \color{blue}{z \cdot x} \]
3. Recombined 2 regimes into one program.

4. Final simplification 48.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.55 \cdot 10^{-69} \lor \neg \left(z \leq 2.75 \cdot 10^{-43}\right):\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 34.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -8.2 \cdot 10^{-72}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 3.4 \cdot 10^{-63}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -8.2e-72) x (if (<= y 3.4e-63) (/ t b) x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -8.2e-72) {
		tmp = x;
	} else if (y <= 3.4e-63) {
		tmp = t / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= (-8.2d-72)) then
        tmp = x
    else if (y <= 3.4d-63) then
        tmp = t / b
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -8.2e-72) {
		tmp = x;
	} else if (y <= 3.4e-63) {
		tmp = t / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -8.2e-72:
		tmp = x
	elif y <= 3.4e-63:
		tmp = t / b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -8.2e-72)
		tmp = x;
	elseif (y <= 3.4e-63)
		tmp = Float64(t / b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -8.2e-72)
		tmp = x;
	elseif (y <= 3.4e-63)
		tmp = t / b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -8.2e-72], x, If[LessEqual[y, 3.4e-63], N[(t / b), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if y < -8.20000000000000007e-72 or 3.39999999999999998e-63 < y

   1. Initial program 53.1%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 34.6%

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

   if -8.20000000000000007e-72 < y < 3.39999999999999998e-63

   1. Initial program 84.5%

      \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 61.4%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + \frac{z \cdot \left(t - a\right)}{y}\right)}}{y + z \cdot \left(b - y\right)} \]
   4. Step-by-step derivation

      1. associate-/l* 51.9%

         \[\leadsto \frac{y \cdot \left(x + \color{blue}{z \cdot \frac{t - a}{y}}\right)}{y + z \cdot \left(b - y\right)} \]

   5. Simplified 51.9%

      \[\leadsto \frac{\color{blue}{y \cdot \left(x + z \cdot \frac{t - a}{y}\right)}}{y + z \cdot \left(b - y\right)} \]

   6. Taylor expanded in b around inf 36.8%

      \[\leadsto \color{blue}{\frac{y \cdot \left(x + \frac{z \cdot \left(t - a\right)}{y}\right)}{b \cdot z}} \]
   7. Step-by-step derivation

      1. associate-/l* 32.5%

         \[\leadsto \color{blue}{y \cdot \frac{x + \frac{z \cdot \left(t - a\right)}{y}}{b \cdot z}} \]

      2. associate-/l* 28.6%

         \[\leadsto y \cdot \frac{x + \color{blue}{z \cdot \frac{t - a}{y}}}{b \cdot z} \]

      3. *-commutative 28.6%

         \[\leadsto y \cdot \frac{x + z \cdot \frac{t - a}{y}}{\color{blue}{z \cdot b}} \]

   8. Simplified 28.6%

      \[\leadsto \color{blue}{y \cdot \frac{x + z \cdot \frac{t - a}{y}}{z \cdot b}} \]

   9. Taylor expanded in t around inf 38.1%

      \[\leadsto \color{blue}{\frac{t}{b}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 19: 25.8% accurate, 17.0× speedup

Math

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

FPCore

(FPCore (x y z t a b) :precision binary64 x)

C

double code(double x, double y, double z, double t, double a, double b) {
	return x;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = x
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return x;
}

Python

def code(x, y, z, t, a, b):
	return x

Julia

function code(x, y, z, t, a, b)
	return x
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = x;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := x

Derivation

1. Initial program 65.4%

   \[\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)} \]
2. Add Preprocessing

3. Taylor expanded in z around 0 24.0%

   \[\leadsto \color{blue}{x} \]
4. Add Preprocessing

Developer target: 74.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \frac{z \cdot t + y \cdot x}{y + z \cdot \left(b - y\right)} - \frac{a}{\left(b - y\right) + \frac{y}{z}} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (- (/ (+ (* z t) (* y x)) (+ y (* z (- b y)))) (/ a (+ (- b y) (/ y z)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)));
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)))
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)));
}

Python

def code(x, y, z, t, a, b):
	return (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)))

Julia

function code(x, y, z, t, a, b)
	return Float64(Float64(Float64(Float64(z * t) + Float64(y * x)) / Float64(y + Float64(z * Float64(b - y)))) - Float64(a / Float64(Float64(b - y) + Float64(y / z))))
end

MATLAB

function tmp = code(x, y, z, t, a, b)
	tmp = (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)));
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(N[(z * t), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a / N[(N[(b - y), $MachinePrecision] + N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024103 
(FPCore (x y z t a b)
  :name "Development.Shake.Progress:decay from shake-0.15.5"
  :precision binary64

  :alt
  (- (/ (+ (* z t) (* y x)) (+ y (* z (- b y)))) (/ a (+ (- b y) (/ y z))))

  (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))