Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 66.2% → 91.7%

Time: 16.6s

Alternatives: 18

Speedup: 0.7×

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.2% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 91.7% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ t_2 := \frac{t - a}{b - y}\\ t_3 := \frac{x \cdot y + z \cdot \left(t - a\right)}{t\_1}\\ t_4 := \frac{t - a}{t\_1} \cdot z + x\\ \mathbf{if}\;t\_3 \leq -\infty:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;t\_3 \leq -4 \cdot 10^{-271}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_3 \leq 0:\\ \;\;\;\;t\_2 + \frac{\frac{y \cdot x}{b - y} - \frac{\left(t - a\right) \cdot y}{\left(b - y\right) \cdot \left(b - y\right)}}{z}\\ \mathbf{elif}\;t\_3 \leq 5 \cdot 10^{+285}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;t\_3 \leq \infty:\\ \;\;\;\;t\_4\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y))))
        (t_2 (/ (- t a) (- b y)))
        (t_3 (/ (+ (* x y) (* z (- t a))) t_1))
        (t_4 (+ (* (/ (- t a) t_1) z) x)))
   (if (<= t_3 (- INFINITY))
     t_4
     (if (<= t_3 -4e-271)
       t_3
       (if (<= t_3 0.0)
         (+
          t_2
          (/ (- (/ (* y x) (- b y)) (/ (* (- t a) y) (* (- b y) (- b y)))) z))
         (if (<= t_3 5e+285) t_3 (if (<= t_3 INFINITY) t_4 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double t_3 = ((x * y) + (z * (t - a))) / t_1;
	double t_4 = (((t - a) / t_1) * z) + x;
	double tmp;
	if (t_3 <= -((double) INFINITY)) {
		tmp = t_4;
	} else if (t_3 <= -4e-271) {
		tmp = t_3;
	} else if (t_3 <= 0.0) {
		tmp = t_2 + ((((y * x) / (b - y)) - (((t - a) * y) / ((b - y) * (b - y)))) / z);
	} else if (t_3 <= 5e+285) {
		tmp = t_3;
	} else if (t_3 <= ((double) INFINITY)) {
		tmp = t_4;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double t_3 = ((x * y) + (z * (t - a))) / t_1;
	double t_4 = (((t - a) / t_1) * z) + x;
	double tmp;
	if (t_3 <= -Double.POSITIVE_INFINITY) {
		tmp = t_4;
	} else if (t_3 <= -4e-271) {
		tmp = t_3;
	} else if (t_3 <= 0.0) {
		tmp = t_2 + ((((y * x) / (b - y)) - (((t - a) * y) / ((b - y) * (b - y)))) / z);
	} else if (t_3 <= 5e+285) {
		tmp = t_3;
	} else if (t_3 <= Double.POSITIVE_INFINITY) {
		tmp = t_4;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	t_2 = (t - a) / (b - y)
	t_3 = ((x * y) + (z * (t - a))) / t_1
	t_4 = (((t - a) / t_1) * z) + x
	tmp = 0
	if t_3 <= -math.inf:
		tmp = t_4
	elif t_3 <= -4e-271:
		tmp = t_3
	elif t_3 <= 0.0:
		tmp = t_2 + ((((y * x) / (b - y)) - (((t - a) * y) / ((b - y) * (b - y)))) / z)
	elif t_3 <= 5e+285:
		tmp = t_3
	elif t_3 <= math.inf:
		tmp = t_4
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	t_3 = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / t_1)
	t_4 = Float64(Float64(Float64(Float64(t - a) / t_1) * z) + x)
	tmp = 0.0
	if (t_3 <= Float64(-Inf))
		tmp = t_4;
	elseif (t_3 <= -4e-271)
		tmp = t_3;
	elseif (t_3 <= 0.0)
		tmp = Float64(t_2 + Float64(Float64(Float64(Float64(y * x) / Float64(b - y)) - Float64(Float64(Float64(t - a) * y) / Float64(Float64(b - y) * Float64(b - y)))) / z));
	elseif (t_3 <= 5e+285)
		tmp = t_3;
	elseif (t_3 <= Inf)
		tmp = t_4;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	t_2 = (t - a) / (b - y);
	t_3 = ((x * y) + (z * (t - a))) / t_1;
	t_4 = (((t - a) / t_1) * z) + x;
	tmp = 0.0;
	if (t_3 <= -Inf)
		tmp = t_4;
	elseif (t_3 <= -4e-271)
		tmp = t_3;
	elseif (t_3 <= 0.0)
		tmp = t_2 + ((((y * x) / (b - y)) - (((t - a) * y) / ((b - y) * (b - y)))) / z);
	elseif (t_3 <= 5e+285)
		tmp = t_3;
	elseif (t_3 <= Inf)
		tmp = t_4;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 4 regimes

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

   1. Initial program 39.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -inf.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < -3.99999999999999985e-271 or 0.0 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 5.00000000000000016e285

   1. Initial program 99.6%

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

   if -3.99999999999999985e-271 < (/.f64 (+.f64 (*.f64 x y) (*.f64 z (-.f64 t a))) (+.f64 y (*.f64 z (-.f64 b y)))) < 0.0

   1. Initial program 33.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

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

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

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 2: 68.2% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ t_2 := \frac{x \cdot y + t\_1}{y}\\ t_3 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -0.0036:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;z \leq -1.3 \cdot 10^{-96}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -5.5 \cdot 10^{-140}:\\ \;\;\;\;\frac{t\_1 + y \cdot x}{z \cdot b}\\ \mathbf{elif}\;z \leq 9 \cdot 10^{-307}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 6.5 \cdot 10^{-14}:\\ \;\;\;\;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 (/ (+ (* x y) t_1) y))
        (t_3 (/ (- t a) (- b y))))
   (if (<= z -0.0036)
     t_3
     (if (<= z -1.3e-96)
       t_2
       (if (<= z -5.5e-140)
         (/ (+ t_1 (* y x)) (* z b))
         (if (<= z 9e-307) x (if (<= z 6.5e-14) 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 = ((x * y) + t_1) / y;
	double t_3 = (t - a) / (b - y);
	double tmp;
	if (z <= -0.0036) {
		tmp = t_3;
	} else if (z <= -1.3e-96) {
		tmp = t_2;
	} else if (z <= -5.5e-140) {
		tmp = (t_1 + (y * x)) / (z * b);
	} else if (z <= 9e-307) {
		tmp = x;
	} else if (z <= 6.5e-14) {
		tmp = 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 = ((x * y) + t_1) / y
    t_3 = (t - a) / (b - y)
    if (z <= (-0.0036d0)) then
        tmp = t_3
    else if (z <= (-1.3d-96)) then
        tmp = t_2
    else if (z <= (-5.5d-140)) then
        tmp = (t_1 + (y * x)) / (z * b)
    else if (z <= 9d-307) then
        tmp = x
    else if (z <= 6.5d-14) then
        tmp = 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 = ((x * y) + t_1) / y;
	double t_3 = (t - a) / (b - y);
	double tmp;
	if (z <= -0.0036) {
		tmp = t_3;
	} else if (z <= -1.3e-96) {
		tmp = t_2;
	} else if (z <= -5.5e-140) {
		tmp = (t_1 + (y * x)) / (z * b);
	} else if (z <= 9e-307) {
		tmp = x;
	} else if (z <= 6.5e-14) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = ((x * y) + t_1) / y
	t_3 = (t - a) / (b - y)
	tmp = 0
	if z <= -0.0036:
		tmp = t_3
	elif z <= -1.3e-96:
		tmp = t_2
	elif z <= -5.5e-140:
		tmp = (t_1 + (y * x)) / (z * b)
	elif z <= 9e-307:
		tmp = x
	elif z <= 6.5e-14:
		tmp = 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(Float64(Float64(x * y) + t_1) / y)
	t_3 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -0.0036)
		tmp = t_3;
	elseif (z <= -1.3e-96)
		tmp = t_2;
	elseif (z <= -5.5e-140)
		tmp = Float64(Float64(t_1 + Float64(y * x)) / Float64(z * b));
	elseif (z <= 9e-307)
		tmp = x;
	elseif (z <= 6.5e-14)
		tmp = 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 = ((x * y) + t_1) / y;
	t_3 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -0.0036)
		tmp = t_3;
	elseif (z <= -1.3e-96)
		tmp = t_2;
	elseif (z <= -5.5e-140)
		tmp = (t_1 + (y * x)) / (z * b);
	elseif (z <= 9e-307)
		tmp = x;
	elseif (z <= 6.5e-14)
		tmp = 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[(N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.0036], t$95$3, If[LessEqual[z, -1.3e-96], t$95$2, If[LessEqual[z, -5.5e-140], N[(N[(t$95$1 + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(z * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9e-307], x, If[LessEqual[z, 6.5e-14], t$95$2, t$95$3]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -0.0035999999999999999 or 6.5000000000000001e-14 < z

   1. Initial program 48.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.0035999999999999999 < z < -1.3000000000000001e-96 or 8.99999999999999978e-307 < z < 6.5000000000000001e-14

   1. Initial program 94.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.3000000000000001e-96 < z < -5.50000000000000026e-140

   1. Initial program 92.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -5.50000000000000026e-140 < z < 8.99999999999999978e-307

   1. Initial program 85.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 68.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x \cdot y + z \cdot \left(t - a\right)}{y}\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -0.0036:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -9 \cdot 10^{-123}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -7.5 \cdot 10^{-139}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;z \leq 5 \cdot 10^{-307}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 1.26 \cdot 10^{-9}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (+ (* x y) (* z (- t a))) y)) (t_2 (/ (- t a) (- b y))))
   (if (<= z -0.0036)
     t_2
     (if (<= z -9e-123)
       t_1
       (if (<= z -7.5e-139)
         (/ (- t a) b)
         (if (<= z 5e-307) x (if (<= z 1.26e-9) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x * y) + (z * (t - a))) / y;
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -0.0036) {
		tmp = t_2;
	} else if (z <= -9e-123) {
		tmp = t_1;
	} else if (z <= -7.5e-139) {
		tmp = (t - a) / b;
	} else if (z <= 5e-307) {
		tmp = x;
	} else if (z <= 1.26e-9) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((x * y) + (z * (t - a))) / y
    t_2 = (t - a) / (b - y)
    if (z <= (-0.0036d0)) then
        tmp = t_2
    else if (z <= (-9d-123)) then
        tmp = t_1
    else if (z <= (-7.5d-139)) then
        tmp = (t - a) / b
    else if (z <= 5d-307) then
        tmp = x
    else if (z <= 1.26d-9) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x * y) + (z * (t - a))) / y;
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -0.0036) {
		tmp = t_2;
	} else if (z <= -9e-123) {
		tmp = t_1;
	} else if (z <= -7.5e-139) {
		tmp = (t - a) / b;
	} else if (z <= 5e-307) {
		tmp = x;
	} else if (z <= 1.26e-9) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = ((x * y) + (z * (t - a))) / y
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -0.0036:
		tmp = t_2
	elif z <= -9e-123:
		tmp = t_1
	elif z <= -7.5e-139:
		tmp = (t - a) / b
	elif z <= 5e-307:
		tmp = x
	elif z <= 1.26e-9:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / y)
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -0.0036)
		tmp = t_2;
	elseif (z <= -9e-123)
		tmp = t_1;
	elseif (z <= -7.5e-139)
		tmp = Float64(Float64(t - a) / b);
	elseif (z <= 5e-307)
		tmp = x;
	elseif (z <= 1.26e-9)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = ((x * y) + (z * (t - a))) / y;
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -0.0036)
		tmp = t_2;
	elseif (z <= -9e-123)
		tmp = t_1;
	elseif (z <= -7.5e-139)
		tmp = (t - a) / b;
	elseif (z <= 5e-307)
		tmp = x;
	elseif (z <= 1.26e-9)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.0036], t$95$2, If[LessEqual[z, -9e-123], t$95$1, If[LessEqual[z, -7.5e-139], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, 5e-307], x, If[LessEqual[z, 1.26e-9], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -0.0035999999999999999 or 1.25999999999999999e-9 < z

   1. Initial program 48.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.0035999999999999999 < z < -8.99999999999999986e-123 or 5.00000000000000014e-307 < z < 1.25999999999999999e-9

   1. Initial program 93.8%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.99999999999999986e-123 < z < -7.5000000000000001e-139

   1. Initial program 98.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.5000000000000001e-139 < z < 5.00000000000000014e-307

   1. Initial program 85.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 4: 84.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -4.2 \cdot 10^{+53}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq 50000000:\\ \;\;\;\;\frac{z \cdot \left(t - a\right)}{t\_1} + \frac{y \cdot x}{t\_1}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y)))) (t_2 (/ (- t a) (- b y))))
   (if (<= z -4.2e+53)
     t_2
     (if (<= z 50000000.0) (+ (/ (* z (- t a)) t_1) (/ (* y x) t_1)) t_2))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.2e+53) {
		tmp = t_2;
	} else if (z <= 50000000.0) {
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = y + (z * (b - y))
    t_2 = (t - a) / (b - y)
    if (z <= (-4.2d+53)) then
        tmp = t_2
    else if (z <= 50000000.0d0) then
        tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1)
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.2e+53) {
		tmp = t_2;
	} else if (z <= 50000000.0) {
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -4.2e+53:
		tmp = t_2
	elif z <= 50000000.0:
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1)
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -4.2e+53)
		tmp = t_2;
	elseif (z <= 50000000.0)
		tmp = Float64(Float64(Float64(z * Float64(t - a)) / t_1) + Float64(Float64(y * x) / t_1));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -4.2e+53)
		tmp = t_2;
	elseif (z <= 50000000.0)
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.2e+53], t$95$2, If[LessEqual[z, 50000000.0], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]

Derivation

1. Split input into 2 regimes

2. if z < -4.2000000000000004e53 or 5e7 < z

   1. Initial program 41.4%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.2000000000000004e53 < z < 5e7

   1. Initial program 92.3%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 64.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -4.5 \cdot 10^{-52}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -9.8 \cdot 10^{-123}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -3.4 \cdot 10^{-140}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;z \leq -4.2 \cdot 10^{-164}:\\ \;\;\;\;\frac{y \cdot x}{y \cdot \left(1 - z\right)}\\ \mathbf{elif}\;z \leq 1.22 \cdot 10^{-90}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -4.5e-52)
     t_1
     (if (<= z -9.8e-123)
       x
       (if (<= z -3.4e-140)
         (/ (- t a) b)
         (if (<= z -4.2e-164)
           (/ (* y x) (* y (- 1.0 z)))
           (if (<= z 1.22e-90) (/ x (- 1.0 z)) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.5e-52) {
		tmp = t_1;
	} else if (z <= -9.8e-123) {
		tmp = x;
	} else if (z <= -3.4e-140) {
		tmp = (t - a) / b;
	} else if (z <= -4.2e-164) {
		tmp = (y * x) / (y * (1.0 - z));
	} else if (z <= 1.22e-90) {
		tmp = x / (1.0 - z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-4.5d-52)) then
        tmp = t_1
    else if (z <= (-9.8d-123)) then
        tmp = x
    else if (z <= (-3.4d-140)) then
        tmp = (t - a) / b
    else if (z <= (-4.2d-164)) then
        tmp = (y * x) / (y * (1.0d0 - z))
    else if (z <= 1.22d-90) then
        tmp = x / (1.0d0 - z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.5e-52) {
		tmp = t_1;
	} else if (z <= -9.8e-123) {
		tmp = x;
	} else if (z <= -3.4e-140) {
		tmp = (t - a) / b;
	} else if (z <= -4.2e-164) {
		tmp = (y * x) / (y * (1.0 - z));
	} else if (z <= 1.22e-90) {
		tmp = x / (1.0 - z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -4.5e-52:
		tmp = t_1
	elif z <= -9.8e-123:
		tmp = x
	elif z <= -3.4e-140:
		tmp = (t - a) / b
	elif z <= -4.2e-164:
		tmp = (y * x) / (y * (1.0 - z))
	elif z <= 1.22e-90:
		tmp = x / (1.0 - z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -4.5e-52)
		tmp = t_1;
	elseif (z <= -9.8e-123)
		tmp = x;
	elseif (z <= -3.4e-140)
		tmp = Float64(Float64(t - a) / b);
	elseif (z <= -4.2e-164)
		tmp = Float64(Float64(y * x) / Float64(y * Float64(1.0 - z)));
	elseif (z <= 1.22e-90)
		tmp = Float64(x / Float64(1.0 - z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -4.5e-52)
		tmp = t_1;
	elseif (z <= -9.8e-123)
		tmp = x;
	elseif (z <= -3.4e-140)
		tmp = (t - a) / b;
	elseif (z <= -4.2e-164)
		tmp = (y * x) / (y * (1.0 - z));
	elseif (z <= 1.22e-90)
		tmp = x / (1.0 - z);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.5e-52], t$95$1, If[LessEqual[z, -9.8e-123], x, If[LessEqual[z, -3.4e-140], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, -4.2e-164], N[(N[(y * x), $MachinePrecision] / N[(y * N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.22e-90], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if z < -4.5e-52 or 1.2199999999999999e-90 < z

   1. Initial program 56.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.5e-52 < z < -9.7999999999999996e-123

   1. Initial program 86.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -9.7999999999999996e-123 < z < -3.40000000000000008e-140

   1. Initial program 98.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.40000000000000008e-140 < z < -4.1999999999999998e-164

   1. Initial program 100.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 inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -4.1999999999999998e-164 < z < 1.2199999999999999e-90

   1. Initial program 88.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 y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 6: 64.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -4.2 \cdot 10^{-52}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -2.4 \cdot 10^{-121}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -5.6 \cdot 10^{-139}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;z \leq -5.2 \cdot 10^{-164}:\\ \;\;\;\;\frac{y \cdot x}{y}\\ \mathbf{elif}\;z \leq 6.8 \cdot 10^{-89}:\\ \;\;\;\;\frac{x}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -4.2e-52)
     t_1
     (if (<= z -2.4e-121)
       x
       (if (<= z -5.6e-139)
         (/ (- t a) b)
         (if (<= z -5.2e-164)
           (/ (* y x) y)
           (if (<= z 6.8e-89) (/ x (- 1.0 z)) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.2e-52) {
		tmp = t_1;
	} else if (z <= -2.4e-121) {
		tmp = x;
	} else if (z <= -5.6e-139) {
		tmp = (t - a) / b;
	} else if (z <= -5.2e-164) {
		tmp = (y * x) / y;
	} else if (z <= 6.8e-89) {
		tmp = x / (1.0 - z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-4.2d-52)) then
        tmp = t_1
    else if (z <= (-2.4d-121)) then
        tmp = x
    else if (z <= (-5.6d-139)) then
        tmp = (t - a) / b
    else if (z <= (-5.2d-164)) then
        tmp = (y * x) / y
    else if (z <= 6.8d-89) then
        tmp = x / (1.0d0 - z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -4.2e-52) {
		tmp = t_1;
	} else if (z <= -2.4e-121) {
		tmp = x;
	} else if (z <= -5.6e-139) {
		tmp = (t - a) / b;
	} else if (z <= -5.2e-164) {
		tmp = (y * x) / y;
	} else if (z <= 6.8e-89) {
		tmp = x / (1.0 - z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -4.2e-52:
		tmp = t_1
	elif z <= -2.4e-121:
		tmp = x
	elif z <= -5.6e-139:
		tmp = (t - a) / b
	elif z <= -5.2e-164:
		tmp = (y * x) / y
	elif z <= 6.8e-89:
		tmp = x / (1.0 - z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -4.2e-52)
		tmp = t_1;
	elseif (z <= -2.4e-121)
		tmp = x;
	elseif (z <= -5.6e-139)
		tmp = Float64(Float64(t - a) / b);
	elseif (z <= -5.2e-164)
		tmp = Float64(Float64(y * x) / y);
	elseif (z <= 6.8e-89)
		tmp = Float64(x / Float64(1.0 - z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -4.2e-52)
		tmp = t_1;
	elseif (z <= -2.4e-121)
		tmp = x;
	elseif (z <= -5.6e-139)
		tmp = (t - a) / b;
	elseif (z <= -5.2e-164)
		tmp = (y * x) / y;
	elseif (z <= 6.8e-89)
		tmp = x / (1.0 - z);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.2e-52], t$95$1, If[LessEqual[z, -2.4e-121], x, If[LessEqual[z, -5.6e-139], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, -5.2e-164], N[(N[(y * x), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[z, 6.8e-89], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if z < -4.1999999999999997e-52 or 6.8000000000000001e-89 < z

   1. Initial program 56.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.1999999999999997e-52 < z < -2.40000000000000003e-121

   1. Initial program 86.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.40000000000000003e-121 < z < -5.5999999999999997e-139

   1. Initial program 98.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -5.5999999999999997e-139 < z < -5.2000000000000003e-164

   1. Initial program 100.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 inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -5.2000000000000003e-164 < z < 6.8000000000000001e-89

   1. Initial program 88.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 y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 7: 63.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5 \cdot 10^{-52}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -1.08 \cdot 10^{-122}:\\ \;\;\;\;\frac{x}{t\_1} \cdot y\\ \mathbf{elif}\;z \leq -8.2 \cdot 10^{-139}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;z \leq 9600:\\ \;\;\;\;\frac{y \cdot x}{t\_1}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y)))) (t_2 (/ (- t a) (- b y))))
   (if (<= z -5e-52)
     t_2
     (if (<= z -1.08e-122)
       (* (/ x t_1) y)
       (if (<= z -8.2e-139)
         (/ (- t a) b)
         (if (<= z 9600.0) (/ (* y x) t_1) t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5e-52) {
		tmp = t_2;
	} else if (z <= -1.08e-122) {
		tmp = (x / t_1) * y;
	} else if (z <= -8.2e-139) {
		tmp = (t - a) / b;
	} else if (z <= 9600.0) {
		tmp = (y * x) / t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = y + (z * (b - y))
    t_2 = (t - a) / (b - y)
    if (z <= (-5d-52)) then
        tmp = t_2
    else if (z <= (-1.08d-122)) then
        tmp = (x / t_1) * y
    else if (z <= (-8.2d-139)) then
        tmp = (t - a) / b
    else if (z <= 9600.0d0) then
        tmp = (y * x) / t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5e-52) {
		tmp = t_2;
	} else if (z <= -1.08e-122) {
		tmp = (x / t_1) * y;
	} else if (z <= -8.2e-139) {
		tmp = (t - a) / b;
	} else if (z <= 9600.0) {
		tmp = (y * x) / t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -5e-52:
		tmp = t_2
	elif z <= -1.08e-122:
		tmp = (x / t_1) * y
	elif z <= -8.2e-139:
		tmp = (t - a) / b
	elif z <= 9600.0:
		tmp = (y * x) / t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5e-52)
		tmp = t_2;
	elseif (z <= -1.08e-122)
		tmp = Float64(Float64(x / t_1) * y);
	elseif (z <= -8.2e-139)
		tmp = Float64(Float64(t - a) / b);
	elseif (z <= 9600.0)
		tmp = Float64(Float64(y * x) / t_1);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -5e-52)
		tmp = t_2;
	elseif (z <= -1.08e-122)
		tmp = (x / t_1) * y;
	elseif (z <= -8.2e-139)
		tmp = (t - a) / b;
	elseif (z <= 9600.0)
		tmp = (y * x) / t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e-52], t$95$2, If[LessEqual[z, -1.08e-122], N[(N[(x / t$95$1), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, -8.2e-139], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, 9600.0], N[(N[(y * x), $MachinePrecision] / t$95$1), $MachinePrecision], t$95$2]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -5e-52 or 9600 < z

   1. Initial program 52.4%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -5e-52 < z < -1.08e-122

   1. Initial program 86.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 inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -1.08e-122 < z < -8.20000000000000028e-139

   1. Initial program 98.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.20000000000000028e-139 < z < 9600

   1. Initial program 91.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 x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 8: 63.8% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -3.9 \cdot 10^{-52}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -9.2 \cdot 10^{-123}:\\ \;\;\;\;\frac{x}{y + z \cdot \left(b - y\right)} \cdot y\\ \mathbf{elif}\;z \leq -8.2 \cdot 10^{-139}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{elif}\;z \leq 9 \cdot 10^{-17}:\\ \;\;\;\;\frac{y \cdot x}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -3.9e-52)
     t_1
     (if (<= z -9.2e-123)
       (* (/ x (+ y (* z (- b y)))) y)
       (if (<= z -8.2e-139)
         (/ (- t a) b)
         (if (<= z 9e-17) (/ (* y x) (+ y (* z b))) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -3.9e-52) {
		tmp = t_1;
	} else if (z <= -9.2e-123) {
		tmp = (x / (y + (z * (b - y)))) * y;
	} else if (z <= -8.2e-139) {
		tmp = (t - a) / b;
	} else if (z <= 9e-17) {
		tmp = (y * x) / (y + (z * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-3.9d-52)) then
        tmp = t_1
    else if (z <= (-9.2d-123)) then
        tmp = (x / (y + (z * (b - y)))) * y
    else if (z <= (-8.2d-139)) then
        tmp = (t - a) / b
    else if (z <= 9d-17) then
        tmp = (y * x) / (y + (z * b))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -3.9e-52) {
		tmp = t_1;
	} else if (z <= -9.2e-123) {
		tmp = (x / (y + (z * (b - y)))) * y;
	} else if (z <= -8.2e-139) {
		tmp = (t - a) / b;
	} else if (z <= 9e-17) {
		tmp = (y * x) / (y + (z * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -3.9e-52:
		tmp = t_1
	elif z <= -9.2e-123:
		tmp = (x / (y + (z * (b - y)))) * y
	elif z <= -8.2e-139:
		tmp = (t - a) / b
	elif z <= 9e-17:
		tmp = (y * x) / (y + (z * b))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -3.9e-52)
		tmp = t_1;
	elseif (z <= -9.2e-123)
		tmp = Float64(Float64(x / Float64(y + Float64(z * Float64(b - y)))) * y);
	elseif (z <= -8.2e-139)
		tmp = Float64(Float64(t - a) / b);
	elseif (z <= 9e-17)
		tmp = Float64(Float64(y * x) / Float64(y + Float64(z * b)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -3.9e-52)
		tmp = t_1;
	elseif (z <= -9.2e-123)
		tmp = (x / (y + (z * (b - y)))) * y;
	elseif (z <= -8.2e-139)
		tmp = (t - a) / b;
	elseif (z <= 9e-17)
		tmp = (y * x) / (y + (z * b));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.9e-52], t$95$1, If[LessEqual[z, -9.2e-123], N[(N[(x / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, -8.2e-139], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, 9e-17], N[(N[(y * x), $MachinePrecision] / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -3.90000000000000018e-52 or 8.99999999999999957e-17 < z

   1. Initial program 53.1%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.90000000000000018e-52 < z < -9.19999999999999947e-123

   1. Initial program 86.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 inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -9.19999999999999947e-123 < z < -8.20000000000000028e-139

   1. Initial program 98.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.20000000000000028e-139 < z < 8.99999999999999957e-17

   1. Initial program 91.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 9: 84.3% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -3.3 \cdot 10^{+53}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 50000000:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -3.3e+53)
     t_1
     (if (<= z 50000000.0)
       (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y))))
       t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -3.3e+53) {
		tmp = t_1;
	} else if (z <= 50000000.0) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (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 = (t - a) / (b - y)
    if (z <= (-3.3d+53)) then
        tmp = t_1
    else if (z <= 50000000.0d0) then
        tmp = ((x * y) + (z * (t - a))) / (y + (z * (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 = (t - a) / (b - y);
	double tmp;
	if (z <= -3.3e+53) {
		tmp = t_1;
	} else if (z <= 50000000.0) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -3.3e+53:
		tmp = t_1
	elif z <= 50000000.0:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -3.3e+53)
		tmp = t_1;
	elseif (z <= 50000000.0)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -3.3e+53)
		tmp = t_1;
	elseif (z <= 50000000.0)
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.3e+53], t$95$1, If[LessEqual[z, 50000000.0], 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], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -3.3000000000000002e53 or 5e7 < z

   1. Initial program 41.4%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.3000000000000002e53 < z < 5e7

   1. Initial program 92.3%

      \[\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. Add Preprocessing

Alternative 10: 44.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{a}{y - b}\\ t_2 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -1.5 \cdot 10^{-44}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq -1.06 \cdot 10^{-291}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{-162}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;y \leq 1.25 \cdot 10^{-31}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ a (- y b))) (t_2 (/ x (- 1.0 z))))
   (if (<= y -1.5e-44)
     t_2
     (if (<= y -1.06e-291)
       t_1
       (if (<= y 4.2e-162) (/ t b) (if (<= y 1.25e-31) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a / (y - b);
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -1.5e-44) {
		tmp = t_2;
	} else if (y <= -1.06e-291) {
		tmp = t_1;
	} else if (y <= 4.2e-162) {
		tmp = t / b;
	} else if (y <= 1.25e-31) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a / (y - b)
    t_2 = x / (1.0d0 - z)
    if (y <= (-1.5d-44)) then
        tmp = t_2
    else if (y <= (-1.06d-291)) then
        tmp = t_1
    else if (y <= 4.2d-162) then
        tmp = t / b
    else if (y <= 1.25d-31) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a / (y - b);
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -1.5e-44) {
		tmp = t_2;
	} else if (y <= -1.06e-291) {
		tmp = t_1;
	} else if (y <= 4.2e-162) {
		tmp = t / b;
	} else if (y <= 1.25e-31) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a / (y - b)
	t_2 = x / (1.0 - z)
	tmp = 0
	if y <= -1.5e-44:
		tmp = t_2
	elif y <= -1.06e-291:
		tmp = t_1
	elif y <= 4.2e-162:
		tmp = t / b
	elif y <= 1.25e-31:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a / Float64(y - b))
	t_2 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -1.5e-44)
		tmp = t_2;
	elseif (y <= -1.06e-291)
		tmp = t_1;
	elseif (y <= 4.2e-162)
		tmp = Float64(t / b);
	elseif (y <= 1.25e-31)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a / (y - b);
	t_2 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -1.5e-44)
		tmp = t_2;
	elseif (y <= -1.06e-291)
		tmp = t_1;
	elseif (y <= 4.2e-162)
		tmp = t / b;
	elseif (y <= 1.25e-31)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(y - b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.5e-44], t$95$2, If[LessEqual[y, -1.06e-291], t$95$1, If[LessEqual[y, 4.2e-162], N[(t / b), $MachinePrecision], If[LessEqual[y, 1.25e-31], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -1.5000000000000001e-44 or 1.25e-31 < y

   1. Initial program 63.6%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.5000000000000001e-44 < y < -1.05999999999999992e-291 or 4.2e-162 < y < 1.25e-31

   1. Initial program 73.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 a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -1.05999999999999992e-291 < y < 4.2e-162

   1. Initial program 84.7%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 11: 77.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -24000000000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 3.5 \cdot 10^{-6}:\\ \;\;\;\;\frac{t - a}{y + z \cdot \left(b - y\right)} \cdot z + x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -24000000000.0)
     t_1
     (if (<= z 3.5e-6) (+ (* (/ (- t a) (+ y (* z (- b y)))) z) x) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -24000000000.0) {
		tmp = t_1;
	} else if (z <= 3.5e-6) {
		tmp = (((t - a) / (y + (z * (b - y)))) * z) + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-24000000000.0d0)) then
        tmp = t_1
    else if (z <= 3.5d-6) then
        tmp = (((t - a) / (y + (z * (b - y)))) * z) + x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -24000000000.0) {
		tmp = t_1;
	} else if (z <= 3.5e-6) {
		tmp = (((t - a) / (y + (z * (b - y)))) * z) + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -24000000000.0:
		tmp = t_1
	elif z <= 3.5e-6:
		tmp = (((t - a) / (y + (z * (b - y)))) * z) + x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -24000000000.0)
		tmp = t_1;
	elseif (z <= 3.5e-6)
		tmp = Float64(Float64(Float64(Float64(t - a) / Float64(y + Float64(z * Float64(b - y)))) * z) + x);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -24000000000.0)
		tmp = t_1;
	elseif (z <= 3.5e-6)
		tmp = (((t - a) / (y + (z * (b - y)))) * z) + x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -2.4e10 or 3.49999999999999995e-6 < z

   1. Initial program 48.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.4e10 < z < 3.49999999999999995e-6

   1. Initial program 91.5%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 63.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -1.3 \cdot 10^{-84}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.7 \cdot 10^{-7}:\\ \;\;\;\;\frac{y \cdot x}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -1.3e-84) t_1 (if (<= z 1.7e-7) (/ (* y x) (+ y (* z b))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.3e-84) {
		tmp = t_1;
	} else if (z <= 1.7e-7) {
		tmp = (y * x) / (y + (z * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-1.3d-84)) then
        tmp = t_1
    else if (z <= 1.7d-7) then
        tmp = (y * x) / (y + (z * b))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

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

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -1.3e-84:
		tmp = t_1
	elif z <= 1.7e-7:
		tmp = (y * x) / (y + (z * b))
	else:
		tmp = t_1
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -1.3e-84 or 1.69999999999999987e-7 < z

   1. Initial program 54.6%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.3e-84 < z < 1.69999999999999987e-7

   1. Initial program 91.5%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 35.4% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -2.4 \cdot 10^{-43}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -1.15 \cdot 10^{-294}:\\ \;\;\;\;-\frac{a}{b}\\ \mathbf{elif}\;y \leq 1.1 \cdot 10^{-103}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -2.4e-43)
   x
   (if (<= y -1.15e-294) (- (/ a b)) (if (<= y 1.1e-103) (/ t b) x))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -2.4e-43) {
		tmp = x;
	} else if (y <= -1.15e-294) {
		tmp = -(a / b);
	} else if (y <= 1.1e-103) {
		tmp = t / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= (-2.4d-43)) then
        tmp = x
    else if (y <= (-1.15d-294)) then
        tmp = -(a / b)
    else if (y <= 1.1d-103) then
        tmp = t / b
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -2.4e-43) {
		tmp = x;
	} else if (y <= -1.15e-294) {
		tmp = -(a / b);
	} else if (y <= 1.1e-103) {
		tmp = t / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -2.4e-43:
		tmp = x
	elif y <= -1.15e-294:
		tmp = -(a / b)
	elif y <= 1.1e-103:
		tmp = t / b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -2.4e-43)
		tmp = x;
	elseif (y <= -1.15e-294)
		tmp = Float64(-Float64(a / b));
	elseif (y <= 1.1e-103)
		tmp = Float64(t / b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -2.4e-43)
		tmp = x;
	elseif (y <= -1.15e-294)
		tmp = -(a / b);
	elseif (y <= 1.1e-103)
		tmp = t / b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -2.4e-43], x, If[LessEqual[y, -1.15e-294], (-N[(a / b), $MachinePrecision]), If[LessEqual[y, 1.1e-103], N[(t / b), $MachinePrecision], x]]]

Derivation

1. Split input into 3 regimes

2. if y < -2.4000000000000002e-43 or 1.1e-103 < y

   1. Initial program 66.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.4000000000000002e-43 < y < -1.15000000000000008e-294

   1. Initial program 73.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 a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -1.15000000000000008e-294 < y < 1.1e-103

   1. Initial program 76.8%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 14: 54.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -2 \cdot 10^{-40}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{-24}:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ x (- 1.0 z))))
   (if (<= y -2e-40) t_1 (if (<= y 1.2e-24) (/ (- t a) b) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -2e-40) {
		tmp = t_1;
	} else if (y <= 1.2e-24) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (1.0d0 - z)
    if (y <= (-2d-40)) then
        tmp = t_1
    else if (y <= 1.2d-24) then
        tmp = (t - a) / b
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -2e-40) {
		tmp = t_1;
	} else if (y <= 1.2e-24) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (1.0 - z)
	tmp = 0
	if y <= -2e-40:
		tmp = t_1
	elif y <= 1.2e-24:
		tmp = (t - a) / b
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -2e-40)
		tmp = t_1;
	elseif (y <= 1.2e-24)
		tmp = Float64(Float64(t - a) / b);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -2e-40)
		tmp = t_1;
	elseif (y <= 1.2e-24)
		tmp = (t - a) / b;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2e-40], t$95$1, If[LessEqual[y, 1.2e-24], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if y < -1.9999999999999999e-40 or 1.1999999999999999e-24 < y

   1. Initial program 62.6%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.9999999999999999e-40 < y < 1.1999999999999999e-24

   1. Initial program 77.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 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 15: 44.7% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{a}{y - b}\\ \mathbf{if}\;z \leq -5.9 \cdot 10^{-52}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.7 \cdot 10^{-80}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ a (- y b))))
   (if (<= z -5.9e-52) t_1 (if (<= z 1.7e-80) x t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a / (y - b);
	double tmp;
	if (z <= -5.9e-52) {
		tmp = t_1;
	} else if (z <= 1.7e-80) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = a / (y - b)
    if (z <= (-5.9d-52)) then
        tmp = t_1
    else if (z <= 1.7d-80) then
        tmp = x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a / (y - b);
	double tmp;
	if (z <= -5.9e-52) {
		tmp = t_1;
	} else if (z <= 1.7e-80) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a / (y - b)
	tmp = 0
	if z <= -5.9e-52:
		tmp = t_1
	elif z <= 1.7e-80:
		tmp = x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a / Float64(y - b))
	tmp = 0.0
	if (z <= -5.9e-52)
		tmp = t_1;
	elseif (z <= 1.7e-80)
		tmp = x;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a / (y - b);
	tmp = 0.0;
	if (z <= -5.9e-52)
		tmp = t_1;
	elseif (z <= 1.7e-80)
		tmp = x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a / N[(y - b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.9e-52], t$95$1, If[LessEqual[z, 1.7e-80], x, t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -5.90000000000000019e-52 or 1.7e-80 < z

   1. Initial program 56.6%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -5.90000000000000019e-52 < z < 1.7e-80

   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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 16: 37.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6 \cdot 10^{-52}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq 4.3 \cdot 10^{-35}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -6e-52) (/ t b) (if (<= z 4.3e-35) x (/ t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -6e-52) {
		tmp = t / b;
	} else if (z <= 4.3e-35) {
		tmp = x;
	} 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) :: tmp
    if (z <= (-6d-52)) then
        tmp = t / b
    else if (z <= 4.3d-35) then
        tmp = x
    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 tmp;
	if (z <= -6e-52) {
		tmp = t / b;
	} else if (z <= 4.3e-35) {
		tmp = x;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -6e-52:
		tmp = t / b
	elif z <= 4.3e-35:
		tmp = x
	else:
		tmp = t / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -6e-52)
		tmp = Float64(t / b);
	elseif (z <= 4.3e-35)
		tmp = x;
	else
		tmp = Float64(t / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -6e-52)
		tmp = t / b;
	elseif (z <= 4.3e-35)
		tmp = x;
	else
		tmp = t / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -6e-52], N[(t / b), $MachinePrecision], If[LessEqual[z, 4.3e-35], x, N[(t / b), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -6e-52 or 4.3000000000000002e-35 < z

   1. Initial program 54.3%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -6e-52 < z < 4.3000000000000002e-35

   1. Initial program 90.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 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 35.1% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.9 \cdot 10^{+31}:\\ \;\;\;\;\frac{a}{y}\\ \mathbf{elif}\;z \leq 6 \cdot 10^{-29}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -2.9e+31) (/ a y) (if (<= z 6e-29) x (/ a y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -2.9e+31) {
		tmp = a / y;
	} else if (z <= 6e-29) {
		tmp = x;
	} else {
		tmp = 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.9d+31)) then
        tmp = a / y
    else if (z <= 6d-29) then
        tmp = x
    else
        tmp = 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.9e+31) {
		tmp = a / y;
	} else if (z <= 6e-29) {
		tmp = x;
	} else {
		tmp = a / y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -2.9e+31:
		tmp = a / y
	elif z <= 6e-29:
		tmp = x
	else:
		tmp = a / y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -2.9e+31)
		tmp = Float64(a / y);
	elseif (z <= 6e-29)
		tmp = x;
	else
		tmp = Float64(a / y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -2.9e+31)
		tmp = a / y;
	elseif (z <= 6e-29)
		tmp = x;
	else
		tmp = a / y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -2.9e+31], N[(a / y), $MachinePrecision], If[LessEqual[z, 6e-29], x, N[(a / y), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -2.9e31 or 6.0000000000000005e-29 < z

   1. Initial program 47.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 a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -2.9e31 < z < 6.0000000000000005e-29

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

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 26.4% 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 69.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 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

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

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

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