Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 66.3% → 83.8%

Time: 19.3s

Alternatives: 17

Speedup: 1.1×

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: 66.3% 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: 83.8% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ t_2 := \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ t_3 := \frac{t - a}{b - y}\\ t_4 := y + z \cdot \left(b - y\right)\\ \mathbf{if}\;z \leq -0.086:\\ \;\;\;\;\left(y \cdot \frac{\frac{x}{z}}{b - y} + t_3\right) - t_2\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + t_1}{t_4}\\ \mathbf{elif}\;z \leq 3.9 \cdot 10^{+139}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{t_1}{t_4}\\ \mathbf{else}:\\ \;\;\;\;\left(t_3 + \frac{\frac{x}{z} \cdot y}{b - y}\right) - t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- t a)))
        (t_2 (* (/ y z) (/ (- t a) (pow (- b y) 2.0))))
        (t_3 (/ (- t a) (- b y)))
        (t_4 (+ y (* z (- b y)))))
   (if (<= z -0.086)
     (- (+ (* y (/ (/ x z) (- b y))) t_3) t_2)
     (if (<= z 2.4e-11)
       (/ (+ (* x y) t_1) t_4)
       (if (<= z 3.9e+139)
         (+ (* (/ x z) (/ y (- b y))) (/ t_1 t_4))
         (- (+ t_3 (/ (* (/ x z) y) (- b y))) t_2))))))

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) * ((t - a) / pow((b - y), 2.0));
	double t_3 = (t - a) / (b - y);
	double t_4 = y + (z * (b - y));
	double tmp;
	if (z <= -0.086) {
		tmp = ((y * ((x / z) / (b - y))) + t_3) - t_2;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_4;
	} else if (z <= 3.9e+139) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_4);
	} else {
		tmp = (t_3 + (((x / z) * y) / (b - y))) - 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) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = z * (t - a)
    t_2 = (y / z) * ((t - a) / ((b - y) ** 2.0d0))
    t_3 = (t - a) / (b - y)
    t_4 = y + (z * (b - y))
    if (z <= (-0.086d0)) then
        tmp = ((y * ((x / z) / (b - y))) + t_3) - t_2
    else if (z <= 2.4d-11) then
        tmp = ((x * y) + t_1) / t_4
    else if (z <= 3.9d+139) then
        tmp = ((x / z) * (y / (b - y))) + (t_1 / t_4)
    else
        tmp = (t_3 + (((x / z) * y) / (b - y))) - 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);
	double t_2 = (y / z) * ((t - a) / Math.pow((b - y), 2.0));
	double t_3 = (t - a) / (b - y);
	double t_4 = y + (z * (b - y));
	double tmp;
	if (z <= -0.086) {
		tmp = ((y * ((x / z) / (b - y))) + t_3) - t_2;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_4;
	} else if (z <= 3.9e+139) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_4);
	} else {
		tmp = (t_3 + (((x / z) * y) / (b - y))) - t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = (y / z) * ((t - a) / math.pow((b - y), 2.0))
	t_3 = (t - a) / (b - y)
	t_4 = y + (z * (b - y))
	tmp = 0
	if z <= -0.086:
		tmp = ((y * ((x / z) / (b - y))) + t_3) - t_2
	elif z <= 2.4e-11:
		tmp = ((x * y) + t_1) / t_4
	elif z <= 3.9e+139:
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_4)
	else:
		tmp = (t_3 + (((x / z) * y) / (b - y))) - t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	t_2 = Float64(Float64(y / z) * Float64(Float64(t - a) / (Float64(b - y) ^ 2.0)))
	t_3 = Float64(Float64(t - a) / Float64(b - y))
	t_4 = Float64(y + Float64(z * Float64(b - y)))
	tmp = 0.0
	if (z <= -0.086)
		tmp = Float64(Float64(Float64(y * Float64(Float64(x / z) / Float64(b - y))) + t_3) - t_2);
	elseif (z <= 2.4e-11)
		tmp = Float64(Float64(Float64(x * y) + t_1) / t_4);
	elseif (z <= 3.9e+139)
		tmp = Float64(Float64(Float64(x / z) * Float64(y / Float64(b - y))) + Float64(t_1 / t_4));
	else
		tmp = Float64(Float64(t_3 + Float64(Float64(Float64(x / z) * y) / Float64(b - y))) - t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	t_2 = (y / z) * ((t - a) / ((b - y) ^ 2.0));
	t_3 = (t - a) / (b - y);
	t_4 = y + (z * (b - y));
	tmp = 0.0;
	if (z <= -0.086)
		tmp = ((y * ((x / z) / (b - y))) + t_3) - t_2;
	elseif (z <= 2.4e-11)
		tmp = ((x * y) + t_1) / t_4;
	elseif (z <= 3.9e+139)
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_4);
	else
		tmp = (t_3 + (((x / z) * y) / (b - y))) - t_2;
	end
	tmp_2 = 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[(N[(y / z), $MachinePrecision] * N[(N[(t - a), $MachinePrecision] / N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.086], N[(N[(N[(y * N[(N[(x / z), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[z, 2.4e-11], N[(N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[z, 3.9e+139], N[(N[(N[(x / z), $MachinePrecision] * N[(y / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 / t$95$4), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$3 + N[(N[(N[(x / z), $MachinePrecision] * y), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -0.085999999999999993

   1. Initial program 30.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 z around inf 62.6%

      \[\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+ 62.6%

         \[\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 62.6%

         \[\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+ 62.6%

         \[\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. times-frac 71.4%

         \[\leadsto \left(\color{blue}{\frac{x}{z} \cdot \frac{y}{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}} \]

      5. associate-*r/ 66.9%

         \[\leadsto \left(\color{blue}{\frac{\frac{x}{z} \cdot y}{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 66.9%

         \[\leadsto \left(\frac{\frac{x}{z} \cdot y}{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 80.3%

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

   5. Simplified 80.3%

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

      1. expm1-log1p-u 77.5%

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

      2. expm1-udef 73.5%

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

      3. associate-/l* 77.4%

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

   7. Applied egg-rr 77.4%

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

      1. expm1-def 81.4%

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

      2. expm1-log1p 86.9%

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

      3. associate-/r/ 86.9%

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

   9. Simplified 86.9%

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

   if -0.085999999999999993 < z < 2.4000000000000001e-11

   1. Initial program 91.6%

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

   if 2.4000000000000001e-11 < z < 3.90000000000000006e139

   1. Initial program 75.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 x around 0 75.0%

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

   4. Taylor expanded in z around inf 75.0%

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

      1. times-frac 92.5%

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

   6. Simplified 92.5%

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

   if 3.90000000000000006e139 < z

   1. Initial program 17.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 71.0%

      \[\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+ 71.0%

         \[\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 71.0%

         \[\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+ 71.0%

         \[\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. times-frac 77.6%

         \[\leadsto \left(\color{blue}{\frac{x}{z} \cdot \frac{y}{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}} \]

      5. associate-*r/ 77.6%

         \[\leadsto \left(\color{blue}{\frac{\frac{x}{z} \cdot y}{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 77.7%

         \[\leadsto \left(\frac{\frac{x}{z} \cdot y}{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 93.3%

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

   5. Simplified 93.3%

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

4. Final simplification 91.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -0.086:\\ \;\;\;\;\left(y \cdot \frac{\frac{x}{z}}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;z \leq 3.9 \cdot 10^{+139}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\left(\frac{t - a}{b - y} + \frac{\frac{x}{z} \cdot y}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 83.5% 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 := \left(y \cdot \frac{\frac{x}{z}}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ \mathbf{if}\;z \leq -0.086:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + t_1}{t_2}\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+143}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{t_1}{t_2}\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \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
         (-
          (+ (* y (/ (/ x z) (- b y))) (/ (- t a) (- b y)))
          (* (/ y z) (/ (- t a) (pow (- b y) 2.0))))))
   (if (<= z -0.086)
     t_3
     (if (<= z 2.4e-11)
       (/ (+ (* x y) t_1) t_2)
       (if (<= z 6e+143) (+ (* (/ x z) (/ y (- b y))) (/ t_1 t_2)) t_3)))))

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 = ((y * ((x / z) / (b - y))) + ((t - a) / (b - y))) - ((y / z) * ((t - a) / pow((b - y), 2.0)));
	double tmp;
	if (z <= -0.086) {
		tmp = t_3;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_2;
	} else if (z <= 6e+143) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	} else {
		tmp = t_3;
	}
	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) :: t_3
    real(8) :: tmp
    t_1 = z * (t - a)
    t_2 = y + (z * (b - y))
    t_3 = ((y * ((x / z) / (b - y))) + ((t - a) / (b - y))) - ((y / z) * ((t - a) / ((b - y) ** 2.0d0)))
    if (z <= (-0.086d0)) then
        tmp = t_3
    else if (z <= 2.4d-11) then
        tmp = ((x * y) + t_1) / t_2
    else if (z <= 6d+143) then
        tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2)
    else
        tmp = t_3
    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);
	double t_2 = y + (z * (b - y));
	double t_3 = ((y * ((x / z) / (b - y))) + ((t - a) / (b - y))) - ((y / z) * ((t - a) / Math.pow((b - y), 2.0)));
	double tmp;
	if (z <= -0.086) {
		tmp = t_3;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_2;
	} else if (z <= 6e+143) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = y + (z * (b - y))
	t_3 = ((y * ((x / z) / (b - y))) + ((t - a) / (b - y))) - ((y / z) * ((t - a) / math.pow((b - y), 2.0)))
	tmp = 0
	if z <= -0.086:
		tmp = t_3
	elif z <= 2.4e-11:
		tmp = ((x * y) + t_1) / t_2
	elif z <= 6e+143:
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2)
	else:
		tmp = t_3
	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(Float64(Float64(y * Float64(Float64(x / z) / Float64(b - y))) + Float64(Float64(t - a) / Float64(b - y))) - Float64(Float64(y / z) * Float64(Float64(t - a) / (Float64(b - y) ^ 2.0))))
	tmp = 0.0
	if (z <= -0.086)
		tmp = t_3;
	elseif (z <= 2.4e-11)
		tmp = Float64(Float64(Float64(x * y) + t_1) / t_2);
	elseif (z <= 6e+143)
		tmp = Float64(Float64(Float64(x / z) * Float64(y / Float64(b - y))) + Float64(t_1 / t_2));
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	t_2 = y + (z * (b - y));
	t_3 = ((y * ((x / z) / (b - y))) + ((t - a) / (b - y))) - ((y / z) * ((t - a) / ((b - y) ^ 2.0)));
	tmp = 0.0;
	if (z <= -0.086)
		tmp = t_3;
	elseif (z <= 2.4e-11)
		tmp = ((x * y) + t_1) / t_2;
	elseif (z <= 6e+143)
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	else
		tmp = t_3;
	end
	tmp_2 = 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[(N[(y * N[(N[(x / z), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y / z), $MachinePrecision] * N[(N[(t - a), $MachinePrecision] / N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.086], t$95$3, If[LessEqual[z, 2.4e-11], N[(N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[z, 6e+143], N[(N[(N[(x / z), $MachinePrecision] * N[(y / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 / t$95$2), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -0.085999999999999993 or 6.0000000000000001e143 < z

   1. Initial program 24.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 inf 67.6%

      \[\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+ 67.6%

         \[\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 67.6%

         \[\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+ 67.6%

         \[\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. times-frac 75.3%

         \[\leadsto \left(\color{blue}{\frac{x}{z} \cdot \frac{y}{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}} \]

      5. associate-*r/ 73.1%

         \[\leadsto \left(\color{blue}{\frac{\frac{x}{z} \cdot y}{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 73.1%

         \[\leadsto \left(\frac{\frac{x}{z} \cdot y}{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 86.6%

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

   5. Simplified 86.6%

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

      1. expm1-log1p-u 84.1%

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

      2. expm1-udef 78.0%

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

      3. associate-/l* 80.0%

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

   7. Applied egg-rr 80.0%

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

      1. expm1-def 86.1%

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

      2. expm1-log1p 90.0%

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

      3. associate-/r/ 88.7%

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

   9. Simplified 88.7%

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

   if -0.085999999999999993 < z < 2.4000000000000001e-11

   1. Initial program 91.6%

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

   if 2.4000000000000001e-11 < z < 6.0000000000000001e143

   1. Initial program 73.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 0 73.2%

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

   4. Taylor expanded in z around inf 73.2%

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

      1. times-frac 92.7%

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

   6. Simplified 92.7%

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

4. Final simplification 90.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -0.086:\\ \;\;\;\;\left(y \cdot \frac{\frac{x}{z}}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+143}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\left(y \cdot \frac{\frac{x}{z}}{b - y} + \frac{t - a}{b - y}\right) - \frac{y}{z} \cdot \frac{t - a}{{\left(b - y\right)}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 85.2% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ t_2 := {\left(b - y\right)}^{2}\\ \mathbf{if}\;z \leq -0.086:\\ \;\;\;\;\left(y \cdot \frac{\frac{x}{z}}{b - y} + t_1\right) - \frac{y}{z} \cdot \frac{t - a}{t_2}\\ \mathbf{elif}\;z \leq 5.6 \cdot 10^{+58}:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\left(t_1 + \frac{1}{\frac{\frac{b}{y} + -1}{\frac{x}{z}}}\right) + \frac{y}{z} \cdot \frac{a - t}{t_2}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))) (t_2 (pow (- b y) 2.0)))
   (if (<= z -0.086)
     (- (+ (* y (/ (/ x z) (- b y))) t_1) (* (/ y z) (/ (- t a) t_2)))
     (if (<= z 5.6e+58)
       (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y))))
       (+
        (+ t_1 (/ 1.0 (/ (+ (/ b y) -1.0) (/ x z))))
        (* (/ y z) (/ (- a t) t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double t_2 = pow((b - y), 2.0);
	double tmp;
	if (z <= -0.086) {
		tmp = ((y * ((x / z) / (b - y))) + t_1) - ((y / z) * ((t - a) / t_2));
	} else if (z <= 5.6e+58) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	} else {
		tmp = (t_1 + (1.0 / (((b / y) + -1.0) / (x / z)))) + ((y / z) * ((a - t) / 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 = (t - a) / (b - y)
    t_2 = (b - y) ** 2.0d0
    if (z <= (-0.086d0)) then
        tmp = ((y * ((x / z) / (b - y))) + t_1) - ((y / z) * ((t - a) / t_2))
    else if (z <= 5.6d+58) then
        tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
    else
        tmp = (t_1 + (1.0d0 / (((b / y) + (-1.0d0)) / (x / z)))) + ((y / z) * ((a - t) / 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 = (t - a) / (b - y);
	double t_2 = Math.pow((b - y), 2.0);
	double tmp;
	if (z <= -0.086) {
		tmp = ((y * ((x / z) / (b - y))) + t_1) - ((y / z) * ((t - a) / t_2));
	} else if (z <= 5.6e+58) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	} else {
		tmp = (t_1 + (1.0 / (((b / y) + -1.0) / (x / z)))) + ((y / z) * ((a - t) / t_2));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	t_2 = math.pow((b - y), 2.0)
	tmp = 0
	if z <= -0.086:
		tmp = ((y * ((x / z) / (b - y))) + t_1) - ((y / z) * ((t - a) / t_2))
	elif z <= 5.6e+58:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
	else:
		tmp = (t_1 + (1.0 / (((b / y) + -1.0) / (x / z)))) + ((y / z) * ((a - t) / t_2))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	t_2 = Float64(b - y) ^ 2.0
	tmp = 0.0
	if (z <= -0.086)
		tmp = Float64(Float64(Float64(y * Float64(Float64(x / z) / Float64(b - y))) + t_1) - Float64(Float64(y / z) * Float64(Float64(t - a) / t_2)));
	elseif (z <= 5.6e+58)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))));
	else
		tmp = Float64(Float64(t_1 + Float64(1.0 / Float64(Float64(Float64(b / y) + -1.0) / Float64(x / z)))) + Float64(Float64(y / z) * Float64(Float64(a - t) / t_2)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	t_2 = (b - y) ^ 2.0;
	tmp = 0.0;
	if (z <= -0.086)
		tmp = ((y * ((x / z) / (b - y))) + t_1) - ((y / z) * ((t - a) / t_2));
	elseif (z <= 5.6e+58)
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	else
		tmp = (t_1 + (1.0 / (((b / y) + -1.0) / (x / z)))) + ((y / z) * ((a - t) / t_2));
	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]}, Block[{t$95$2 = N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[z, -0.086], N[(N[(N[(y * N[(N[(x / z), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[(y / z), $MachinePrecision] * N[(N[(t - a), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.6e+58], 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], N[(N[(t$95$1 + N[(1.0 / N[(N[(N[(b / y), $MachinePrecision] + -1.0), $MachinePrecision] / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(y / z), $MachinePrecision] * N[(N[(a - t), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -0.085999999999999993

   1. Initial program 30.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 z around inf 62.6%

      \[\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+ 62.6%

         \[\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 62.6%

         \[\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+ 62.6%

         \[\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. times-frac 71.4%

         \[\leadsto \left(\color{blue}{\frac{x}{z} \cdot \frac{y}{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}} \]

      5. associate-*r/ 66.9%

         \[\leadsto \left(\color{blue}{\frac{\frac{x}{z} \cdot y}{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 66.9%

         \[\leadsto \left(\frac{\frac{x}{z} \cdot y}{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 80.3%

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

   5. Simplified 80.3%

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

      1. expm1-log1p-u 77.5%

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

      2. expm1-udef 73.5%

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

      3. associate-/l* 77.4%

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

   7. Applied egg-rr 77.4%

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

      1. expm1-def 81.4%

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

      2. expm1-log1p 86.9%

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

      3. associate-/r/ 86.9%

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

   9. Simplified 86.9%

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

   if -0.085999999999999993 < z < 5.5999999999999996e58

   1. Initial program 91.0%

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

   if 5.5999999999999996e58 < z

   1. Initial program 31.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 inf 65.5%

      \[\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+ 65.5%

         \[\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 65.5%

         \[\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+ 65.5%

         \[\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. times-frac 77.2%

         \[\leadsto \left(\color{blue}{\frac{x}{z} \cdot \frac{y}{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}} \]

      5. associate-*r/ 75.7%

         \[\leadsto \left(\color{blue}{\frac{\frac{x}{z} \cdot y}{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 75.8%

         \[\leadsto \left(\frac{\frac{x}{z} \cdot y}{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 88.0%

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

   5. Simplified 88.0%

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

      1. clear-num 87.9%

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

      2. inv-pow 87.9%

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

      3. *-commutative 87.9%

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

   7. Applied egg-rr 87.9%

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

      1. unpow-1 87.9%

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

      2. associate-/r* 90.9%

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

      3. div-sub 90.9%

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

      4. sub-neg 90.9%

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

      5. *-inverses 90.9%

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

      6. metadata-eval 90.9%

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

   9. Simplified 90.9%

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

4. Final simplification 90.3%

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

Alternative 4: 83.9% accurate, 0.6× 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{t - a}{b - y}\\ \mathbf{if}\;z \leq -1.8 \cdot 10^{+16}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + t_1}{t_2}\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+143}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{t_1}{t_2}\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \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 (/ (- t a) (- b y))))
   (if (<= z -1.8e+16)
     t_3
     (if (<= z 2.4e-11)
       (/ (+ (* x y) t_1) t_2)
       (if (<= z 6e+143) (+ (* (/ x z) (/ y (- b y))) (/ t_1 t_2)) t_3)))))

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 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.8e+16) {
		tmp = t_3;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_2;
	} else if (z <= 6e+143) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	} else {
		tmp = t_3;
	}
	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) :: t_3
    real(8) :: tmp
    t_1 = z * (t - a)
    t_2 = y + (z * (b - y))
    t_3 = (t - a) / (b - y)
    if (z <= (-1.8d+16)) then
        tmp = t_3
    else if (z <= 2.4d-11) then
        tmp = ((x * y) + t_1) / t_2
    else if (z <= 6d+143) then
        tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2)
    else
        tmp = t_3
    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);
	double t_2 = y + (z * (b - y));
	double t_3 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.8e+16) {
		tmp = t_3;
	} else if (z <= 2.4e-11) {
		tmp = ((x * y) + t_1) / t_2;
	} else if (z <= 6e+143) {
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = y + (z * (b - y))
	t_3 = (t - a) / (b - y)
	tmp = 0
	if z <= -1.8e+16:
		tmp = t_3
	elif z <= 2.4e-11:
		tmp = ((x * y) + t_1) / t_2
	elif z <= 6e+143:
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2)
	else:
		tmp = t_3
	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(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -1.8e+16)
		tmp = t_3;
	elseif (z <= 2.4e-11)
		tmp = Float64(Float64(Float64(x * y) + t_1) / t_2);
	elseif (z <= 6e+143)
		tmp = Float64(Float64(Float64(x / z) * Float64(y / Float64(b - y))) + Float64(t_1 / t_2));
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	t_2 = y + (z * (b - y));
	t_3 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -1.8e+16)
		tmp = t_3;
	elseif (z <= 2.4e-11)
		tmp = ((x * y) + t_1) / t_2;
	elseif (z <= 6e+143)
		tmp = ((x / z) * (y / (b - y))) + (t_1 / t_2);
	else
		tmp = t_3;
	end
	tmp_2 = 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[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.8e+16], t$95$3, If[LessEqual[z, 2.4e-11], N[(N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[z, 6e+143], N[(N[(N[(x / z), $MachinePrecision] * N[(y / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 / t$95$2), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.8e16 or 6.0000000000000001e143 < z

   1. Initial program 23.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 z around inf 87.0%

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

   if -1.8e16 < z < 2.4000000000000001e-11

   1. Initial program 91.0%

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

   if 2.4000000000000001e-11 < z < 6.0000000000000001e143

   1. Initial program 73.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 0 73.2%

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

   4. Taylor expanded in z around inf 73.2%

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

      1. times-frac 92.7%

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

   6. Simplified 92.7%

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

4. Final simplification 89.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.8 \cdot 10^{+16}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq 2.4 \cdot 10^{-11}:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+143}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{b - y} + \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 83.8% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.8e+17) (not (<= z 2.5e+95)))
   (/ (- t a) (- b y))
   (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.8e+17) || !(z <= 2.5e+95)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (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 <= (-1.8d+17)) .or. (.not. (z <= 2.5d+95))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((x * y) + (z * (t - a))) / (y + (z * (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 <= -1.8e+17) || !(z <= 2.5e+95)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.8e+17) or not (z <= 2.5e+95):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.8e+17) || !(z <= 2.5e+95))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.8e+17) || ~((z <= 2.5e+95)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.8e+17], N[Not[LessEqual[z, 2.5e+95]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], 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]]

Derivation

1. Split input into 2 regimes

2. if z < -1.8e17 or 2.50000000000000012e95 < z

   1. Initial program 25.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.4%

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

   if -1.8e17 < z < 2.50000000000000012e95

   1. Initial program 89.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 87.5%

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

Alternative 6: 81.1% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -9.2) (not (<= z 2.4e-11)))
   (/ (- t a) (- b y))
   (+ x (/ (* z (- t a)) (+ y (* z (- b y)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -9.2) || !(z <= 2.4e-11)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * (t - a)) / (y + (z * (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 <= (-9.2d0)) .or. (.not. (z <= 2.4d-11))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x + ((z * (t - a)) / (y + (z * (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 <= -9.2) || !(z <= 2.4e-11)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * (t - a)) / (y + (z * (b - y))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -9.2) or not (z <= 2.4e-11):
		tmp = (t - a) / (b - y)
	else:
		tmp = x + ((z * (t - a)) / (y + (z * (b - y))))
	return tmp

Julia

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

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -9.2) || ~((z <= 2.4e-11)))
		tmp = (t - a) / (b - y);
	else
		tmp = x + ((z * (t - a)) / (y + (z * (b - y))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -9.1999999999999993 or 2.4000000000000001e-11 < z

   1. Initial program 40.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 inf 79.8%

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

   if -9.1999999999999993 < z < 2.4000000000000001e-11

   1. Initial program 90.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 x around 0 90.9%

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

   4. Taylor expanded in z around 0 83.3%

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

4. Final simplification 81.5%

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

Alternative 7: 83.0% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1300000000.0) (not (<= z 1.85)))
   (/ (- t a) (- b y))
   (/ (+ (* x y) (* z (- t a))) (+ y (* z b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1300000000.0) || !(z <= 1.85)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * 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 ((z <= (-1300000000.0d0)) .or. (.not. (z <= 1.85d0))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((x * y) + (z * (t - a))) / (y + (z * 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 ((z <= -1300000000.0) || !(z <= 1.85)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1300000000.0) or not (z <= 1.85):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1300000000.0) || !(z <= 1.85))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1300000000.0) || ~((z <= 1.85)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -1.3e9 or 1.8500000000000001 < z

   1. Initial program 38.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 inf 80.9%

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

   if -1.3e9 < z < 1.8500000000000001

   1. Initial program 91.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 b around inf 90.0%

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

      1. *-commutative 90.0%

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

   5. Simplified 90.0%

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

4. Final simplification 85.4%

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

Alternative 8: 53.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{a - t}{y}\\ t_2 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -3.8 \cdot 10^{+172}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.38 \cdot 10^{+119}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -2.8:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 145000:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+117} \lor \neg \left(y \leq 5 \cdot 10^{+148}\right):\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a t) y)) (t_2 (/ x (- 1.0 z))))
   (if (<= y -3.8e+172)
     t_2
     (if (<= y -1.38e+119)
       t_1
       (if (<= y -2.8)
         t_2
         (if (<= y 145000.0)
           (/ (- t a) b)
           (if (or (<= y 5.2e+117) (not (<= y 5e+148))) t_2 t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (a - t) / y;
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -3.8e+172) {
		tmp = t_2;
	} else if (y <= -1.38e+119) {
		tmp = t_1;
	} else if (y <= -2.8) {
		tmp = t_2;
	} else if (y <= 145000.0) {
		tmp = (t - a) / b;
	} else if ((y <= 5.2e+117) || !(y <= 5e+148)) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: tmp
    t_1 = (a - t) / y
    t_2 = x / (1.0d0 - z)
    if (y <= (-3.8d+172)) then
        tmp = t_2
    else if (y <= (-1.38d+119)) then
        tmp = t_1
    else if (y <= (-2.8d0)) then
        tmp = t_2
    else if (y <= 145000.0d0) then
        tmp = (t - a) / b
    else if ((y <= 5.2d+117) .or. (.not. (y <= 5d+148))) then
        tmp = t_2
    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 - t) / y;
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -3.8e+172) {
		tmp = t_2;
	} else if (y <= -1.38e+119) {
		tmp = t_1;
	} else if (y <= -2.8) {
		tmp = t_2;
	} else if (y <= 145000.0) {
		tmp = (t - a) / b;
	} else if ((y <= 5.2e+117) || !(y <= 5e+148)) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (a - t) / y
	t_2 = x / (1.0 - z)
	tmp = 0
	if y <= -3.8e+172:
		tmp = t_2
	elif y <= -1.38e+119:
		tmp = t_1
	elif y <= -2.8:
		tmp = t_2
	elif y <= 145000.0:
		tmp = (t - a) / b
	elif (y <= 5.2e+117) or not (y <= 5e+148):
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(a - t) / y)
	t_2 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -3.8e+172)
		tmp = t_2;
	elseif (y <= -1.38e+119)
		tmp = t_1;
	elseif (y <= -2.8)
		tmp = t_2;
	elseif (y <= 145000.0)
		tmp = Float64(Float64(t - a) / b);
	elseif ((y <= 5.2e+117) || !(y <= 5e+148))
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (a - t) / y;
	t_2 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -3.8e+172)
		tmp = t_2;
	elseif (y <= -1.38e+119)
		tmp = t_1;
	elseif (y <= -2.8)
		tmp = t_2;
	elseif (y <= 145000.0)
		tmp = (t - a) / b;
	elseif ((y <= 5.2e+117) || ~((y <= 5e+148)))
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(a - t), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.8e+172], t$95$2, If[LessEqual[y, -1.38e+119], t$95$1, If[LessEqual[y, -2.8], t$95$2, If[LessEqual[y, 145000.0], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[Or[LessEqual[y, 5.2e+117], N[Not[LessEqual[y, 5e+148]], $MachinePrecision]], t$95$2, t$95$1]]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -3.7999999999999997e172 or -1.38000000000000001e119 < y < -2.7999999999999998 or 145000 < y < 5.1999999999999999e117 or 5.00000000000000024e148 < y

   1. Initial program 57.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 56.6%

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

      1. mul-1-neg 56.6%

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

      2. unsub-neg 56.6%

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

   5. Simplified 56.6%

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

   if -3.7999999999999997e172 < y < -1.38000000000000001e119 or 5.1999999999999999e117 < y < 5.00000000000000024e148

   1. Initial program 49.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 73.5%

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

   4. Taylor expanded in b around 0 69.6%

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

      1. associate-*r/ 69.6%

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

      2. neg-mul-1 69.6%

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

   6. Simplified 69.6%

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

   if -2.7999999999999998 < y < 145000

   1. Initial program 74.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 0 59.0%

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

4. Final simplification 59.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -3.8 \cdot 10^{+172}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;y \leq -1.38 \cdot 10^{+119}:\\ \;\;\;\;\frac{a - t}{y}\\ \mathbf{elif}\;y \leq -2.8:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;y \leq 145000:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+117} \lor \neg \left(y \leq 5 \cdot 10^{+148}\right):\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;\frac{a - t}{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 71.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.95e-94) (not (<= z 2.2e-48)))
   (/ (- t a) (- b y))
   (+ x (/ (* z (- (- t a) (* x b))) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.95e-94) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * ((t - a) - (x * 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 <= (-1.95d-94)) .or. (.not. (z <= 2.2d-48))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x + ((z * ((t - a) - (x * 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 <= -1.95e-94) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * ((t - a) - (x * b))) / y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.95e-94) or not (z <= 2.2e-48):
		tmp = (t - a) / (b - y)
	else:
		tmp = x + ((z * ((t - a) - (x * b))) / y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.95e-94) || !(z <= 2.2e-48))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x + Float64(Float64(z * Float64(Float64(t - a) - Float64(x * b))) / y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.95e-94) || ~((z <= 2.2e-48)))
		tmp = (t - a) / (b - y);
	else
		tmp = x + ((z * ((t - a) - (x * b))) / y);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -1.9500000000000001e-94 or 2.20000000000000013e-48 < z

   1. Initial program 50.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 76.4%

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

   if -1.9500000000000001e-94 < z < 2.20000000000000013e-48

   1. Initial program 89.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 b around inf 89.4%

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

      1. *-commutative 89.4%

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

   5. Simplified 89.4%

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

   6. Taylor expanded in y around -inf 78.0%

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

      1. mul-1-neg 78.0%

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

      2. unsub-neg 78.0%

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

      3. distribute-lft-out-- 78.0%

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

      4. mul-1-neg 78.0%

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

      5. *-commutative 78.0%

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

      6. associate-*r* 74.3%

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

      7. distribute-rgt-out-- 74.3%

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

   8. Simplified 74.3%

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

4. Final simplification 75.6%

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

Alternative 10: 68.7% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -2.1e-94) (not (<= z 2.2e-48)))
   (/ (- t a) (- b y))
   (/ (+ (* x y) (* z (- t a))) y)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -2.1e-94) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / 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 <= (-2.1d-94)) .or. (.not. (z <= 2.2d-48))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((x * y) + (z * (t - a))) / 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 <= -2.1e-94) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((x * y) + (z * (t - a))) / y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -2.1e-94) or not (z <= 2.2e-48):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((x * y) + (z * (t - a))) / y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -2.1e-94) || !(z <= 2.2e-48))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -2.1e-94) || ~((z <= 2.2e-48)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((x * y) + (z * (t - a))) / y;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -2.1000000000000001e-94 or 2.20000000000000013e-48 < z

   1. Initial program 50.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 76.4%

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

   if -2.1000000000000001e-94 < z < 2.20000000000000013e-48

   1. Initial program 89.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 b around inf 89.4%

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

      1. *-commutative 89.4%

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

   5. Simplified 89.4%

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

   6. Taylor expanded in b around 0 69.0%

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

4. Final simplification 73.5%

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

Alternative 11: 43.3% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -4.2 \cdot 10^{-48}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.75 \cdot 10^{-159}:\\ \;\;\;\;-\frac{a}{b}\\ \mathbf{elif}\;y \leq 2900000000:\\ \;\;\;\;\frac{t}{b - y}\\ \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 -4.2e-48)
     t_1
     (if (<= y 1.75e-159)
       (- (/ a b))
       (if (<= y 2900000000.0) (/ t (- b y)) 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 <= -4.2e-48) {
		tmp = t_1;
	} else if (y <= 1.75e-159) {
		tmp = -(a / b);
	} else if (y <= 2900000000.0) {
		tmp = t / (b - 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 = x / (1.0d0 - z)
    if (y <= (-4.2d-48)) then
        tmp = t_1
    else if (y <= 1.75d-159) then
        tmp = -(a / b)
    else if (y <= 2900000000.0d0) then
        tmp = t / (b - 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 = x / (1.0 - z);
	double tmp;
	if (y <= -4.2e-48) {
		tmp = t_1;
	} else if (y <= 1.75e-159) {
		tmp = -(a / b);
	} else if (y <= 2900000000.0) {
		tmp = t / (b - y);
	} 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 <= -4.2e-48:
		tmp = t_1
	elif y <= 1.75e-159:
		tmp = -(a / b)
	elif y <= 2900000000.0:
		tmp = t / (b - y)
	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 <= -4.2e-48)
		tmp = t_1;
	elseif (y <= 1.75e-159)
		tmp = Float64(-Float64(a / b));
	elseif (y <= 2900000000.0)
		tmp = Float64(t / Float64(b - y));
	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 <= -4.2e-48)
		tmp = t_1;
	elseif (y <= 1.75e-159)
		tmp = -(a / b);
	elseif (y <= 2900000000.0)
		tmp = t / (b - y);
	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, -4.2e-48], t$95$1, If[LessEqual[y, 1.75e-159], (-N[(a / b), $MachinePrecision]), If[LessEqual[y, 2900000000.0], N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if y < -4.19999999999999977e-48 or 2.9e9 < y

   1. Initial program 55.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 inf 49.7%

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

      1. mul-1-neg 49.7%

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

      2. unsub-neg 49.7%

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

   5. Simplified 49.7%

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

   if -4.19999999999999977e-48 < y < 1.75000000000000001e-159

   1. Initial program 81.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 a around inf 44.4%

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

      1. mul-1-neg 44.4%

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

      2. distribute-lft-neg-out 44.4%

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

      3. *-commutative 44.4%

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

   5. Simplified 44.4%

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

   6. Taylor expanded in y around 0 41.1%

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

      1. associate-*r/ 41.1%

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

      2. neg-mul-1 41.1%

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

   8. Simplified 41.1%

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

   if 1.75000000000000001e-159 < y < 2.9e9

   1. Initial program 59.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 z around inf 67.0%

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

   4. Taylor expanded in t around inf 43.7%

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

4. Final simplification 46.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.2 \cdot 10^{-48}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{elif}\;y \leq 1.75 \cdot 10^{-159}:\\ \;\;\;\;-\frac{a}{b}\\ \mathbf{elif}\;y \leq 2900000000:\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{1 - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 64.6% accurate, 1.5× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.4e-100) (not (<= z 2.2e-48))) (/ (- t a) (- b y)) x))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.4e-100) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} 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 ((z <= (-1.4d-100)) .or. (.not. (z <= 2.2d-48))) then
        tmp = (t - a) / (b - y)
    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 ((z <= -1.4e-100) || !(z <= 2.2e-48)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.4e-100) or not (z <= 2.2e-48):
		tmp = (t - a) / (b - y)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.4e-100) || !(z <= 2.2e-48))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.4e-100) || ~((z <= 2.2e-48)))
		tmp = (t - a) / (b - y);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.4e-100], N[Not[LessEqual[z, 2.2e-48]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if z < -1.39999999999999998e-100 or 2.20000000000000013e-48 < z

   1. Initial program 50.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 76.4%

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

   if -1.39999999999999998e-100 < z < 2.20000000000000013e-48

   1. Initial program 89.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 52.1%

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

4. Final simplification 67.1%

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

Alternative 13: 36.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := -\frac{a}{b}\\ \mathbf{if}\;z \leq -7.5 \cdot 10^{-95}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 2.2 \cdot 10^{-48}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{+198}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- (/ a b))))
   (if (<= z -7.5e-95)
     t_1
     (if (<= z 2.2e-48) x (if (<= z 4.5e+198) t_1 (/ t b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -(a / b);
	double tmp;
	if (z <= -7.5e-95) {
		tmp = t_1;
	} else if (z <= 2.2e-48) {
		tmp = x;
	} else if (z <= 4.5e+198) {
		tmp = t_1;
	} else {
		tmp = t / 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) :: t_1
    real(8) :: tmp
    t_1 = -(a / b)
    if (z <= (-7.5d-95)) then
        tmp = t_1
    else if (z <= 2.2d-48) then
        tmp = x
    else if (z <= 4.5d+198) then
        tmp = t_1
    else
        tmp = t / 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 t_1 = -(a / b);
	double tmp;
	if (z <= -7.5e-95) {
		tmp = t_1;
	} else if (z <= 2.2e-48) {
		tmp = x;
	} else if (z <= 4.5e+198) {
		tmp = t_1;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -(a / b)
	tmp = 0
	if z <= -7.5e-95:
		tmp = t_1
	elif z <= 2.2e-48:
		tmp = x
	elif z <= 4.5e+198:
		tmp = t_1
	else:
		tmp = t / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(-Float64(a / b))
	tmp = 0.0
	if (z <= -7.5e-95)
		tmp = t_1;
	elseif (z <= 2.2e-48)
		tmp = x;
	elseif (z <= 4.5e+198)
		tmp = t_1;
	else
		tmp = Float64(t / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -(a / b);
	tmp = 0.0;
	if (z <= -7.5e-95)
		tmp = t_1;
	elseif (z <= 2.2e-48)
		tmp = x;
	elseif (z <= 4.5e+198)
		tmp = t_1;
	else
		tmp = t / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = (-N[(a / b), $MachinePrecision])}, If[LessEqual[z, -7.5e-95], t$95$1, If[LessEqual[z, 2.2e-48], x, If[LessEqual[z, 4.5e+198], t$95$1, N[(t / b), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -7.5000000000000003e-95 or 2.20000000000000013e-48 < z < 4.50000000000000001e198

   1. Initial program 59.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 a around inf 32.1%

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

      1. mul-1-neg 32.1%

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

      2. distribute-lft-neg-out 32.1%

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

      3. *-commutative 32.1%

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

   5. Simplified 32.1%

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

   6. Taylor expanded in y around 0 30.1%

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

      1. associate-*r/ 30.1%

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

      2. neg-mul-1 30.1%

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

   8. Simplified 30.1%

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

   if -7.5000000000000003e-95 < z < 2.20000000000000013e-48

   1. Initial program 89.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 52.1%

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

   if 4.50000000000000001e198 < z

   1. Initial program 8.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 8.2%

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

   4. Taylor expanded in y around 0 53.4%

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

   5. Taylor expanded in a around 0 40.3%

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

4. Final simplification 39.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7.5 \cdot 10^{-95}:\\ \;\;\;\;-\frac{a}{b}\\ \mathbf{elif}\;z \leq 2.2 \cdot 10^{-48}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{+198}:\\ \;\;\;\;-\frac{a}{b}\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 45.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.15 \cdot 10^{-55} \lor \neg \left(z \leq 1.7 \cdot 10^{-5}\right):\\ \;\;\;\;\frac{t}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.15e-55) (not (<= z 1.7e-5))) (/ t (- b y)) x))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.15e-55) || !(z <= 1.7e-5)) {
		tmp = t / (b - y);
	} 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 ((z <= (-1.15d-55)) .or. (.not. (z <= 1.7d-5))) then
        tmp = t / (b - y)
    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 ((z <= -1.15e-55) || !(z <= 1.7e-5)) {
		tmp = t / (b - y);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -1.15e-55) or not (z <= 1.7e-5):
		tmp = t / (b - y)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.15e-55) || !(z <= 1.7e-5))
		tmp = Float64(t / Float64(b - y));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -1.15e-55) || ~((z <= 1.7e-5)))
		tmp = t / (b - y);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.15e-55], N[Not[LessEqual[z, 1.7e-5]], $MachinePrecision]], N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if z < -1.15000000000000006e-55 or 1.7e-5 < z

   1. Initial program 43.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 inf 78.5%

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

   4. Taylor expanded in t around inf 41.4%

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

   if -1.15000000000000006e-55 < z < 1.7e-5

   1. Initial program 91.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 47.2%

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

4. Final simplification 44.0%

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

Alternative 15: 54.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -11500 \lor \neg \left(y \leq 156000\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 -11500.0) (not (<= y 156000.0))) (/ 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 <= -11500.0) || !(y <= 156000.0)) {
		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 <= (-11500.0d0)) .or. (.not. (y <= 156000.0d0))) 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 <= -11500.0) || !(y <= 156000.0)) {
		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 <= -11500.0) or not (y <= 156000.0):
		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 <= -11500.0) || !(y <= 156000.0))
		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 <= -11500.0) || ~((y <= 156000.0)))
		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, -11500.0], N[Not[LessEqual[y, 156000.0]], $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 < -11500 or 156000 < y

   1. Initial program 56.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 y around inf 50.9%

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

      1. mul-1-neg 50.9%

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

      2. unsub-neg 50.9%

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

   5. Simplified 50.9%

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

   if -11500 < y < 156000

   1. Initial program 74.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 0 59.0%

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

4. Final simplification 54.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -11500 \lor \neg \left(y \leq 156000\right):\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 37.1% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.2 \cdot 10^{-56} \lor \neg \left(z \leq 3.7 \cdot 10^{-6}\right):\\ \;\;\;\;\frac{t}{b}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -8.2e-56) (not (<= z 3.7e-6))) (/ t b) x))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -8.2e-56) || !(z <= 3.7e-6)) {
		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 ((z <= (-8.2d-56)) .or. (.not. (z <= 3.7d-6))) 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 ((z <= -8.2e-56) || !(z <= 3.7e-6)) {
		tmp = t / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -8.2e-56) or not (z <= 3.7e-6):
		tmp = t / b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -8.2e-56) || !(z <= 3.7e-6))
		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 ((z <= -8.2e-56) || ~((z <= 3.7e-6)))
		tmp = t / b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -8.2e-56], N[Not[LessEqual[z, 3.7e-6]], $MachinePrecision]], N[(t / b), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if z < -8.2000000000000003e-56 or 3.7000000000000002e-6 < z

   1. Initial program 43.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 t around 0 43.6%

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

   4. Taylor expanded in y around 0 46.7%

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

   5. Taylor expanded in a around 0 27.2%

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

   if -8.2000000000000003e-56 < z < 3.7000000000000002e-6

   1. Initial program 91.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 47.2%

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

4. Final simplification 36.3%

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

Alternative 17: 26.2% 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.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 23.4%

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

4. Final simplification 23.4%

   \[\leadsto x \]
5. Add Preprocessing

Developer target: 73.5% 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 2024011 
(FPCore (x y z t a b)
  :name "Development.Shake.Progress:decay from shake-0.15.5"
  :precision binary64

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

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