Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 66.7% → 82.9%

Time: 13.3s

Alternatives: 12

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.7% 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: 82.9% 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 -7.4 \cdot 10^{+81}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -1.7 \cdot 10^{-247}:\\ \;\;\;\;x \cdot \left(\frac{y}{t\_1} + \frac{\frac{z \cdot \left(t - a\right)}{x}}{t\_1}\right)\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{+114}:\\ \;\;\;\;\frac{\frac{z}{\frac{1}{t - a}} + 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 -7.4e+81)
     t_2
     (if (<= z -1.7e-247)
       (* x (+ (/ y t_1) (/ (/ (* z (- t a)) x) t_1)))
       (if (<= z 9.5e+114) (/ (+ (/ z (/ 1.0 (- t a))) (* 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 <= -7.4e+81) {
		tmp = t_2;
	} else if (z <= -1.7e-247) {
		tmp = x * ((y / t_1) + (((z * (t - a)) / x) / t_1));
	} else if (z <= 9.5e+114) {
		tmp = ((z / (1.0 / (t - a))) + (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 <= (-7.4d+81)) then
        tmp = t_2
    else if (z <= (-1.7d-247)) then
        tmp = x * ((y / t_1) + (((z * (t - a)) / x) / t_1))
    else if (z <= 9.5d+114) then
        tmp = ((z / (1.0d0 / (t - a))) + (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 <= -7.4e+81) {
		tmp = t_2;
	} else if (z <= -1.7e-247) {
		tmp = x * ((y / t_1) + (((z * (t - a)) / x) / t_1));
	} else if (z <= 9.5e+114) {
		tmp = ((z / (1.0 / (t - a))) + (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 <= -7.4e+81:
		tmp = t_2
	elif z <= -1.7e-247:
		tmp = x * ((y / t_1) + (((z * (t - a)) / x) / t_1))
	elif z <= 9.5e+114:
		tmp = ((z / (1.0 / (t - a))) + (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 <= -7.4e+81)
		tmp = t_2;
	elseif (z <= -1.7e-247)
		tmp = Float64(x * Float64(Float64(y / t_1) + Float64(Float64(Float64(z * Float64(t - a)) / x) / t_1)));
	elseif (z <= 9.5e+114)
		tmp = Float64(Float64(Float64(z / Float64(1.0 / Float64(t - a))) + 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 <= -7.4e+81)
		tmp = t_2;
	elseif (z <= -1.7e-247)
		tmp = x * ((y / t_1) + (((z * (t - a)) / x) / t_1));
	elseif (z <= 9.5e+114)
		tmp = ((z / (1.0 / (t - a))) + (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, -7.4e+81], t$95$2, If[LessEqual[z, -1.7e-247], N[(x * N[(N[(y / t$95$1), $MachinePrecision] + N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.5e+114], N[(N[(N[(z / N[(1.0 / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], t$95$2]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -7.4000000000000001e81 or 9.5000000000000001e114 < z

   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 z around inf

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 87.0%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 87.0%

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

   if -7.4000000000000001e81 < z < -1.7000000000000001e-247

   1. Initial program 81.1%

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

      1. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{t \cdot t - a \cdot a}{t + a}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      2. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{1}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      3. un-div-inv N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{z}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{t + a}{t \cdot t - a \cdot a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      5. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{\frac{t \cdot t - a \cdot a}{t + a}}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      6. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{t - a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      7. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \left(t - a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      8. --lowering--.f64 81.0%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

   4. Applied egg-rr 81.0%

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

   5. Taylor expanded in x around inf

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

      1. *-lowering-*.f64 N/A

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

      2. +-lowering-+.f64 N/A

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

      3. /-lowering-/.f64 N/A

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

      4. +-lowering-+.f64 N/A

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

      5. *-lowering-*.f64 N/A

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

      6. --lowering--.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \left(\frac{z \cdot \left(t - a\right)}{x \cdot \left(y + z \cdot \left(b - y\right)\right)}\right)\right)\right) \]

      7. associate-/r* N/A

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

      8. /-lowering-/.f64 N/A

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

      9. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\left(z \cdot \left(t - a\right)\right), x\right), \left(\color{blue}{y} + z \cdot \left(b - y\right)\right)\right)\right)\right) \]

      10. *-lowering-*.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), x\right), \left(y + z \cdot \left(b - y\right)\right)\right)\right)\right) \]

      11. --lowering--.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), x\right), \left(y + z \cdot \left(b - y\right)\right)\right)\right)\right) \]

      12. +-lowering-+.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), x\right), \mathsf{+.f64}\left(y, \color{blue}{\left(z \cdot \left(b - y\right)\right)}\right)\right)\right)\right) \]

      13. *-lowering-*.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), x\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \color{blue}{\left(b - y\right)}\right)\right)\right)\right)\right) \]

      14. --lowering--.f64 86.8%

          \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(\mathsf{/.f64}\left(y, \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right), \mathsf{/.f64}\left(\mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), x\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right)\right)\right)\right)\right) \]

   7. Simplified 86.8%

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

   if -1.7000000000000001e-247 < z < 9.5000000000000001e114

   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. Step-by-step derivation

      1. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{t \cdot t - a \cdot a}{t + a}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      2. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{1}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      3. un-div-inv N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{z}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{t + a}{t \cdot t - a \cdot a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      5. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{\frac{t \cdot t - a \cdot a}{t + a}}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      6. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{t - a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      7. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \left(t - a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      8. --lowering--.f64 89.5%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

   4. Applied egg-rr 89.5%

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

4. Final simplification 87.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7.4 \cdot 10^{+81}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq -1.7 \cdot 10^{-247}:\\ \;\;\;\;x \cdot \left(\frac{y}{y + z \cdot \left(b - y\right)} + \frac{\frac{z \cdot \left(t - a\right)}{x}}{y + z \cdot \left(b - y\right)}\right)\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{+114}:\\ \;\;\;\;\frac{\frac{z}{\frac{1}{t - a}} + y \cdot x}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 72.4% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- t a))) (t_2 (/ (- t a) (- b y))))
   (if (<= z -1.02e+33)
     t_2
     (if (<= z -1.3e-91)
       (/ t_1 (+ y (* z (- b y))))
       (if (<= z 0.0022) (* x (+ 1.0 (/ t_1 (* y x)))) 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 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.02e+33) {
		tmp = t_2;
	} else if (z <= -1.3e-91) {
		tmp = t_1 / (y + (z * (b - y)));
	} else if (z <= 0.0022) {
		tmp = x * (1.0 + (t_1 / (y * x)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = z * (t - a)
    t_2 = (t - a) / (b - y)
    if (z <= (-1.02d+33)) then
        tmp = t_2
    else if (z <= (-1.3d-91)) then
        tmp = t_1 / (y + (z * (b - y)))
    else if (z <= 0.0022d0) then
        tmp = x * (1.0d0 + (t_1 / (y * x)))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -1.02e+33) {
		tmp = t_2;
	} else if (z <= -1.3e-91) {
		tmp = t_1 / (y + (z * (b - y)));
	} else if (z <= 0.0022) {
		tmp = x * (1.0 + (t_1 / (y * x)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -1.02e+33:
		tmp = t_2
	elif z <= -1.3e-91:
		tmp = t_1 / (y + (z * (b - y)))
	elif z <= 0.0022:
		tmp = x * (1.0 + (t_1 / (y * x)))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -1.02e+33)
		tmp = t_2;
	elseif (z <= -1.3e-91)
		tmp = Float64(t_1 / Float64(y + Float64(z * Float64(b - y))));
	elseif (z <= 0.0022)
		tmp = Float64(x * Float64(1.0 + Float64(t_1 / Float64(y * x))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -1.02e+33)
		tmp = t_2;
	elseif (z <= -1.3e-91)
		tmp = t_1 / (y + (z * (b - y)));
	elseif (z <= 0.0022)
		tmp = x * (1.0 + (t_1 / (y * x)));
	else
		tmp = 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[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.02e+33], t$95$2, If[LessEqual[z, -1.3e-91], N[(t$95$1 / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.0022], N[(x * N[(1.0 + N[(t$95$1 / N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.02000000000000001e33 or 0.00220000000000000013 < z

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

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 81.4%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 81.4%

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

   if -1.02000000000000001e33 < z < -1.30000000000000007e-91

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

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(z \cdot \left(t - a\right)\right), \color{blue}{\left(y + z \cdot \left(b - y\right)\right)}\right) \]

      2. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(\color{blue}{y} + z \cdot \left(b - y\right)\right)\right) \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y + z \cdot \left(b - y\right)\right)\right) \]

      4. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{+.f64}\left(y, \color{blue}{\left(z \cdot \left(b - y\right)\right)}\right)\right) \]

      5. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \color{blue}{\left(b - y\right)}\right)\right)\right) \]

      6. --lowering--.f64 66.3%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right)\right)\right) \]

   5. Simplified 66.3%

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

   if -1.30000000000000007e-91 < z < 0.00220000000000000013

   1. Initial program 85.6%

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

      1. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{t \cdot t - a \cdot a}{t + a}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      2. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{1}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      3. un-div-inv N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{z}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{t + a}{t \cdot t - a \cdot a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      5. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{\frac{t \cdot t - a \cdot a}{t + a}}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      6. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{t - a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      7. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \left(t - a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      8. --lowering--.f64 85.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

   4. Applied egg-rr 85.6%

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

   5. Taylor expanded in z around 0

      \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \color{blue}{y}\right) \]
   6. Step-by-step derivation

   7. Simplified 62.5%

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

   8. Taylor expanded in x around inf

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

      1. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \color{blue}{\left(1 + \frac{z \cdot \left(t - a\right)}{x \cdot y}\right)}\right) \]

      2. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \color{blue}{\left(\frac{z \cdot \left(t - a\right)}{x \cdot y}\right)}\right)\right) \]

      3. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\left(z \cdot \left(t - a\right)\right), \color{blue}{\left(x \cdot y\right)}\right)\right)\right) \]

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(\color{blue}{x} \cdot y\right)\right)\right)\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(x \cdot y\right)\right)\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y \cdot \color{blue}{x}\right)\right)\right)\right) \]

      7. *-lowering-*.f64 67.1%

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, \color{blue}{x}\right)\right)\right)\right) \]

   10. Simplified 67.1%

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

Alternative 3: 83.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -9.5 \cdot 10^{+81}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{+114}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + y \cdot x}{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 -9.5e+81)
     t_1
     (if (<= z 9.5e+114)
       (/ (+ (* z (- t a)) (* y x)) (+ 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 <= -9.5e+81) {
		tmp = t_1;
	} else if (z <= 9.5e+114) {
		tmp = ((z * (t - a)) + (y * x)) / (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 <= (-9.5d+81)) then
        tmp = t_1
    else if (z <= 9.5d+114) then
        tmp = ((z * (t - a)) + (y * x)) / (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 <= -9.5e+81) {
		tmp = t_1;
	} else if (z <= 9.5e+114) {
		tmp = ((z * (t - a)) + (y * x)) / (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 <= -9.5e+81:
		tmp = t_1
	elif z <= 9.5e+114:
		tmp = ((z * (t - a)) + (y * x)) / (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 <= -9.5e+81)
		tmp = t_1;
	elseif (z <= 9.5e+114)
		tmp = Float64(Float64(Float64(z * Float64(t - a)) + Float64(y * x)) / 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 <= -9.5e+81)
		tmp = t_1;
	elseif (z <= 9.5e+114)
		tmp = ((z * (t - a)) + (y * x)) / (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, -9.5e+81], t$95$1, If[LessEqual[z, 9.5e+114], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(y * x), $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 < -9.50000000000000083e81 or 9.5000000000000001e114 < z

   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 z around inf

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 87.0%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 87.0%

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

   if -9.50000000000000083e81 < z < 9.5000000000000001e114

   1. Initial program 85.7%

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

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

Alternative 4: 71.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -3.9 \cdot 10^{-64}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 0.0022:\\ \;\;\;\;x \cdot \left(1 + \frac{z \cdot \left(t - a\right)}{y \cdot x}\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.9e-64)
     t_1
     (if (<= z 0.0022) (* x (+ 1.0 (/ (* z (- t a)) (* y 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 <= -3.9e-64) {
		tmp = t_1;
	} else if (z <= 0.0022) {
		tmp = x * (1.0 + ((z * (t - a)) / (y * 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 <= (-3.9d-64)) then
        tmp = t_1
    else if (z <= 0.0022d0) then
        tmp = x * (1.0d0 + ((z * (t - a)) / (y * 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 <= -3.9e-64) {
		tmp = t_1;
	} else if (z <= 0.0022) {
		tmp = x * (1.0 + ((z * (t - a)) / (y * 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 <= -3.9e-64:
		tmp = t_1
	elif z <= 0.0022:
		tmp = x * (1.0 + ((z * (t - a)) / (y * 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 <= -3.9e-64)
		tmp = t_1;
	elseif (z <= 0.0022)
		tmp = Float64(x * Float64(1.0 + Float64(Float64(z * Float64(t - a)) / Float64(y * 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 <= -3.9e-64)
		tmp = t_1;
	elseif (z <= 0.0022)
		tmp = x * (1.0 + ((z * (t - a)) / (y * 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, -3.9e-64], t$95$1, If[LessEqual[z, 0.0022], N[(x * N[(1.0 + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -3.8999999999999997e-64 or 0.00220000000000000013 < z

   1. Initial program 54.8%

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

   3. Taylor expanded in z around inf

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 76.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 76.6%

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

   if -3.8999999999999997e-64 < z < 0.00220000000000000013

   1. Initial program 86.6%

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

      1. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{t \cdot t - a \cdot a}{t + a}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      2. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{1}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      3. un-div-inv N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{z}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{t + a}{t \cdot t - a \cdot a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      5. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{\frac{t \cdot t - a \cdot a}{t + a}}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      6. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{t - a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      7. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \left(t - a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      8. --lowering--.f64 86.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

   4. Applied egg-rr 86.6%

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

   5. Taylor expanded in z around 0

      \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \color{blue}{y}\right) \]
   6. Step-by-step derivation

   7. Simplified 62.6%

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

   8. Taylor expanded in x around inf

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

      1. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \color{blue}{\left(1 + \frac{z \cdot \left(t - a\right)}{x \cdot y}\right)}\right) \]

      2. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \color{blue}{\left(\frac{z \cdot \left(t - a\right)}{x \cdot y}\right)}\right)\right) \]

      3. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\left(z \cdot \left(t - a\right)\right), \color{blue}{\left(x \cdot y\right)}\right)\right)\right) \]

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(\color{blue}{x} \cdot y\right)\right)\right)\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(x \cdot y\right)\right)\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y \cdot \color{blue}{x}\right)\right)\right)\right) \]

      7. *-lowering-*.f64 66.1%

         \[\leadsto \mathsf{*.f64}\left(x, \mathsf{+.f64}\left(1, \mathsf{/.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, \color{blue}{x}\right)\right)\right)\right) \]

   10. Simplified 66.1%

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

Alternative 5: 63.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -7.2 \cdot 10^{-65}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.92 \cdot 10^{-116}:\\ \;\;\;\;\frac{y \cdot x - z \cdot a}{y}\\ \mathbf{elif}\;z \leq 0.0019:\\ \;\;\;\;\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 -7.2e-65)
     t_1
     (if (<= z 1.92e-116)
       (/ (- (* y x) (* z a)) y)
       (if (<= z 0.0019) (/ 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 <= -7.2e-65) {
		tmp = t_1;
	} else if (z <= 1.92e-116) {
		tmp = ((y * x) - (z * a)) / y;
	} else if (z <= 0.0019) {
		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 <= (-7.2d-65)) then
        tmp = t_1
    else if (z <= 1.92d-116) then
        tmp = ((y * x) - (z * a)) / y
    else if (z <= 0.0019d0) 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 <= -7.2e-65) {
		tmp = t_1;
	} else if (z <= 1.92e-116) {
		tmp = ((y * x) - (z * a)) / y;
	} else if (z <= 0.0019) {
		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 <= -7.2e-65:
		tmp = t_1
	elif z <= 1.92e-116:
		tmp = ((y * x) - (z * a)) / y
	elif z <= 0.0019:
		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 <= -7.2e-65)
		tmp = t_1;
	elseif (z <= 1.92e-116)
		tmp = Float64(Float64(Float64(y * x) - Float64(z * a)) / y);
	elseif (z <= 0.0019)
		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 <= -7.2e-65)
		tmp = t_1;
	elseif (z <= 1.92e-116)
		tmp = ((y * x) - (z * a)) / y;
	elseif (z <= 0.0019)
		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, -7.2e-65], t$95$1, If[LessEqual[z, 1.92e-116], N[(N[(N[(y * x), $MachinePrecision] - N[(z * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[z, 0.0019], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -7.1999999999999996e-65 or 0.0019 < z

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

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 76.8%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 76.8%

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

   if -7.1999999999999996e-65 < z < 1.92000000000000011e-116

   1. Initial program 90.0%

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

      1. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{t \cdot t - a \cdot a}{t + a}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      2. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(z \cdot \frac{1}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      3. un-div-inv N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{z}{\frac{t + a}{t \cdot t - a \cdot a}}\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{t + a}{t \cdot t - a \cdot a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      5. clear-num N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{\frac{t \cdot t - a \cdot a}{t + a}}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      6. flip-- N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \left(\frac{1}{t - a}\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      7. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \left(t - a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

      8. --lowering--.f64 90.0%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \mathsf{+.f64}\left(y, \mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(b, y\right)\right)\right)\right) \]

   4. Applied egg-rr 90.0%

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

   5. Taylor expanded in z around 0

      \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{/.f64}\left(z, \mathsf{/.f64}\left(1, \mathsf{\_.f64}\left(t, a\right)\right)\right)\right), \color{blue}{y}\right) \]
   6. Step-by-step derivation

   7. Simplified 63.7%

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

   8. Taylor expanded in t around 0

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(-1 \cdot \left(a \cdot z\right) + x \cdot y\right), \color{blue}{y}\right) \]

      2. +-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\left(x \cdot y + -1 \cdot \left(a \cdot z\right)\right), y\right) \]

      3. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(\left(x \cdot y + \left(\mathsf{neg}\left(a \cdot z\right)\right)\right), y\right) \]

      4. unsub-neg N/A

         \[\leadsto \mathsf{/.f64}\left(\left(x \cdot y - a \cdot z\right), y\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\left(x \cdot y\right), \left(a \cdot z\right)\right), y\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\left(y \cdot x\right), \left(a \cdot z\right)\right), y\right) \]

      7. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{*.f64}\left(y, x\right), \left(a \cdot z\right)\right), y\right) \]

      8. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{*.f64}\left(y, x\right), \left(z \cdot a\right)\right), y\right) \]

      9. *-lowering-*.f64 52.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{*.f64}\left(y, x\right), \mathsf{*.f64}\left(z, a\right)\right), y\right) \]

   10. Simplified 52.6%

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

   if 1.92000000000000011e-116 < z < 0.0019

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

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(x, \color{blue}{\left(1 + -1 \cdot z\right)}\right) \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 + \left(\mathsf{neg}\left(z\right)\right)\right)\right) \]

      3. unsub-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 - \color{blue}{z}\right)\right) \]

      4. --lowering--.f64 76.9%

         \[\leadsto \mathsf{/.f64}\left(x, \mathsf{\_.f64}\left(1, \color{blue}{z}\right)\right) \]

   5. Simplified 76.9%

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

Alternative 6: 36.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.05 \cdot 10^{+128}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq -5 \cdot 10^{-50}:\\ \;\;\;\;\frac{0 - a}{b}\\ \mathbf{elif}\;z \leq 0.0021:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -1.05e+128)
   (/ t b)
   (if (<= z -5e-50) (/ (- 0.0 a) b) (if (<= z 0.0021) x (/ t b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -1.05e+128) {
		tmp = t / b;
	} else if (z <= -5e-50) {
		tmp = (0.0 - a) / b;
	} else if (z <= 0.0021) {
		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 <= (-1.05d+128)) then
        tmp = t / b
    else if (z <= (-5d-50)) then
        tmp = (0.0d0 - a) / b
    else if (z <= 0.0021d0) 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 <= -1.05e+128) {
		tmp = t / b;
	} else if (z <= -5e-50) {
		tmp = (0.0 - a) / b;
	} else if (z <= 0.0021) {
		tmp = x;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -1.05e+128:
		tmp = t / b
	elif z <= -5e-50:
		tmp = (0.0 - a) / b
	elif z <= 0.0021:
		tmp = x
	else:
		tmp = t / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -1.05e+128)
		tmp = Float64(t / b);
	elseif (z <= -5e-50)
		tmp = Float64(Float64(0.0 - a) / b);
	elseif (z <= 0.0021)
		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 <= -1.05e+128)
		tmp = t / b;
	elseif (z <= -5e-50)
		tmp = (0.0 - a) / b;
	elseif (z <= 0.0021)
		tmp = x;
	else
		tmp = t / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -1.05e+128], N[(t / b), $MachinePrecision], If[LessEqual[z, -5e-50], N[(N[(0.0 - a), $MachinePrecision] / b), $MachinePrecision], If[LessEqual[z, 0.0021], x, N[(t / b), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.05e128 or 0.00209999999999999987 < z

   1. Initial program 51.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 b around inf

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

      1. /-lowering-/.f64 N/A

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

      2. +-commutative N/A

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

      3. +-lowering-+.f64 N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y \cdot x\right)\right), \left(b \cdot z\right)\right) \]

      7. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(b \cdot z\right)\right) \]

      8. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(z \cdot \color{blue}{b}\right)\right) \]

      9. *-lowering-*.f64 31.8%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \mathsf{*.f64}\left(z, \color{blue}{b}\right)\right) \]

   5. Simplified 31.8%

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

   6. Taylor expanded in t around inf

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

      1. /-lowering-/.f64 31.1%

         \[\leadsto \mathsf{/.f64}\left(t, \color{blue}{b}\right) \]

   8. Simplified 31.1%

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

   if -1.05e128 < z < -4.99999999999999968e-50

   1. Initial program 62.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 b around inf

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

      1. /-lowering-/.f64 N/A

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

      2. +-commutative N/A

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

      3. +-lowering-+.f64 N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y \cdot x\right)\right), \left(b \cdot z\right)\right) \]

      7. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(b \cdot z\right)\right) \]

      8. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(z \cdot \color{blue}{b}\right)\right) \]

      9. *-lowering-*.f64 41.3%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \mathsf{*.f64}\left(z, \color{blue}{b}\right)\right) \]

   5. Simplified 41.3%

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

   6. Taylor expanded in a around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{a}{b}\right) \]

      2. neg-sub0 N/A

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

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{a}{b}\right)}\right) \]

      4. /-lowering-/.f64 31.0%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(a, \color{blue}{b}\right)\right) \]

   8. Simplified 31.0%

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

   if -4.99999999999999968e-50 < z < 0.00209999999999999987

   1. Initial program 86.2%

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

   3. Taylor expanded in z around 0

      \[\leadsto \color{blue}{x} \]
   4. Step-by-step derivation

   5. Simplified 50.9%

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

4. Final simplification 40.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.05 \cdot 10^{+128}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq -5 \cdot 10^{-50}:\\ \;\;\;\;\frac{0 - a}{b}\\ \mathbf{elif}\;z \leq 0.0021:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 63.6% accurate, 1.0× speedup

Math

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

Derivation

1. Split input into 2 regimes

2. if z < -6.2999999999999998e-68 or 0.021999999999999999 < z

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

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 76.8%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 76.8%

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

   if -6.2999999999999998e-68 < z < 0.021999999999999999

   1. Initial program 86.5%

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

   3. Taylor expanded in y around inf

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(x, \color{blue}{\left(1 + -1 \cdot z\right)}\right) \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 + \left(\mathsf{neg}\left(z\right)\right)\right)\right) \]

      3. unsub-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 - \color{blue}{z}\right)\right) \]

      4. --lowering--.f64 52.5%

         \[\leadsto \mathsf{/.f64}\left(x, \mathsf{\_.f64}\left(1, \color{blue}{z}\right)\right) \]

   5. Simplified 52.5%

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

Alternative 8: 55.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -1.45 \cdot 10^{+50}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.4 \cdot 10^{-42}:\\ \;\;\;\;\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 -1.45e+50) t_1 (if (<= y 1.4e-42) (/ (- 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 <= -1.45e+50) {
		tmp = t_1;
	} else if (y <= 1.4e-42) {
		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 <= (-1.45d+50)) then
        tmp = t_1
    else if (y <= 1.4d-42) 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 <= -1.45e+50) {
		tmp = t_1;
	} else if (y <= 1.4e-42) {
		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 <= -1.45e+50:
		tmp = t_1
	elif y <= 1.4e-42:
		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 <= -1.45e+50)
		tmp = t_1;
	elseif (y <= 1.4e-42)
		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 <= -1.45e+50)
		tmp = t_1;
	elseif (y <= 1.4e-42)
		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, -1.45e+50], t$95$1, If[LessEqual[y, 1.4e-42], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if y < -1.45e50 or 1.39999999999999999e-42 < y

   1. Initial program 52.3%

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

   3. Taylor expanded in y around inf

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(x, \color{blue}{\left(1 + -1 \cdot z\right)}\right) \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 + \left(\mathsf{neg}\left(z\right)\right)\right)\right) \]

      3. unsub-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 - \color{blue}{z}\right)\right) \]

      4. --lowering--.f64 57.5%

         \[\leadsto \mathsf{/.f64}\left(x, \mathsf{\_.f64}\left(1, \color{blue}{z}\right)\right) \]

   5. Simplified 57.5%

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

   if -1.45e50 < y < 1.39999999999999999e-42

   1. Initial program 83.9%

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

   3. Taylor expanded in y around 0

      \[\leadsto \color{blue}{\frac{t - a}{b}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{b}\right) \]

      2. --lowering--.f64 52.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), b\right) \]

   5. Simplified 52.6%

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

Alternative 9: 44.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t}{b - y}\\ \mathbf{if}\;z \leq -7 \cdot 10^{+85}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 6000000000000:\\ \;\;\;\;\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 (- b y))))
   (if (<= z -7e+85) t_1 (if (<= z 6000000000000.0) (/ 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 / (b - y);
	double tmp;
	if (z <= -7e+85) {
		tmp = t_1;
	} else if (z <= 6000000000000.0) {
		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 / (b - y)
    if (z <= (-7d+85)) then
        tmp = t_1
    else if (z <= 6000000000000.0d0) 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 / (b - y);
	double tmp;
	if (z <= -7e+85) {
		tmp = t_1;
	} else if (z <= 6000000000000.0) {
		tmp = x / (1.0 - z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t / (b - y)
	tmp = 0
	if z <= -7e+85:
		tmp = t_1
	elif z <= 6000000000000.0:
		tmp = x / (1.0 - z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t / Float64(b - y))
	tmp = 0.0
	if (z <= -7e+85)
		tmp = t_1;
	elseif (z <= 6000000000000.0)
		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 / (b - y);
	tmp = 0.0;
	if (z <= -7e+85)
		tmp = t_1;
	elseif (z <= 6000000000000.0)
		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[(t / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7e+85], t$95$1, If[LessEqual[z, 6000000000000.0], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -7.0000000000000001e85 or 6e12 < z

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

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 84.8%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 84.8%

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

   6. Taylor expanded in t around inf

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(t, \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 49.1%

         \[\leadsto \mathsf{/.f64}\left(t, \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   8. Simplified 49.1%

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

   if -7.0000000000000001e85 < z < 6e12

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

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(x, \color{blue}{\left(1 + -1 \cdot z\right)}\right) \]

      2. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 + \left(\mathsf{neg}\left(z\right)\right)\right)\right) \]

      3. unsub-neg N/A

         \[\leadsto \mathsf{/.f64}\left(x, \left(1 - \color{blue}{z}\right)\right) \]

      4. --lowering--.f64 46.9%

         \[\leadsto \mathsf{/.f64}\left(x, \mathsf{\_.f64}\left(1, \color{blue}{z}\right)\right) \]

   5. Simplified 46.9%

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

Alternative 10: 44.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t}{b - y}\\ \mathbf{if}\;z \leq -1.6 \cdot 10^{-65}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 0.0019:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ t (- b y))))
   (if (<= z -1.6e-65) t_1 (if (<= z 0.0019) x t_1))))

C

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

Python

def code(x, y, z, t, a, b):
	t_1 = t / (b - y)
	tmp = 0
	if z <= -1.6e-65:
		tmp = t_1
	elif z <= 0.0019:
		tmp = x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t / Float64(b - y))
	tmp = 0.0
	if (z <= -1.6e-65)
		tmp = t_1;
	elseif (z <= 0.0019)
		tmp = x;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t / (b - y);
	tmp = 0.0;
	if (z <= -1.6e-65)
		tmp = t_1;
	elseif (z <= 0.0019)
		tmp = x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -1.6e-65 or 0.0019 < z

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

      \[\leadsto \color{blue}{\frac{t - a}{b - y}} \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\left(t - a\right), \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \left(\color{blue}{b} - y\right)\right) \]

      3. --lowering--.f64 76.8%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(t, a\right), \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   5. Simplified 76.8%

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

   6. Taylor expanded in t around inf

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

      1. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(t, \color{blue}{\left(b - y\right)}\right) \]

      2. --lowering--.f64 43.3%

         \[\leadsto \mathsf{/.f64}\left(t, \mathsf{\_.f64}\left(b, \color{blue}{y}\right)\right) \]

   8. Simplified 43.3%

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

   if -1.6e-65 < z < 0.0019

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

      \[\leadsto \color{blue}{x} \]
   4. Step-by-step derivation

   5. Simplified 51.3%

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

Alternative 11: 36.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3 \cdot 10^{-64}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq 0.0027:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -3e-64) (/ t b) (if (<= z 0.0027) x (/ t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -3e-64) {
		tmp = t / b;
	} else if (z <= 0.0027) {
		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 <= (-3d-64)) then
        tmp = t / b
    else if (z <= 0.0027d0) 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 <= -3e-64) {
		tmp = t / b;
	} else if (z <= 0.0027) {
		tmp = x;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -3e-64:
		tmp = t / b
	elif z <= 0.0027:
		tmp = x
	else:
		tmp = t / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -3e-64)
		tmp = Float64(t / b);
	elseif (z <= 0.0027)
		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 <= -3e-64)
		tmp = t / b;
	elseif (z <= 0.0027)
		tmp = x;
	else
		tmp = t / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -3e-64], N[(t / b), $MachinePrecision], If[LessEqual[z, 0.0027], x, N[(t / b), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -3.0000000000000001e-64 or 0.0027000000000000001 < z

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

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

      1. /-lowering-/.f64 N/A

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

      2. +-commutative N/A

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

      3. +-lowering-+.f64 N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \left(t - a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      5. --lowering--.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(x \cdot y\right)\right), \left(b \cdot z\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \left(y \cdot x\right)\right), \left(b \cdot z\right)\right) \]

      7. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(b \cdot z\right)\right) \]

      8. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \left(z \cdot \color{blue}{b}\right)\right) \]

      9. *-lowering-*.f64 35.3%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{+.f64}\left(\mathsf{*.f64}\left(z, \mathsf{\_.f64}\left(t, a\right)\right), \mathsf{*.f64}\left(y, x\right)\right), \mathsf{*.f64}\left(z, \color{blue}{b}\right)\right) \]

   5. Simplified 35.3%

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

   6. Taylor expanded in t around inf

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

      1. /-lowering-/.f64 28.3%

         \[\leadsto \mathsf{/.f64}\left(t, \color{blue}{b}\right) \]

   8. Simplified 28.3%

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

   if -3.0000000000000001e-64 < z < 0.0027000000000000001

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

      \[\leadsto \color{blue}{x} \]
   4. Step-by-step derivation

   5. Simplified 51.3%

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

Alternative 12: 25.3% 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.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

   \[\leadsto \color{blue}{x} \]
4. Step-by-step derivation

5. Simplified 25.6%

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

Developer Target 1: 74.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 2024138 
(FPCore (x y z t a b)
  :name "Development.Shake.Progress:decay from shake-0.15.5"
  :precision binary64

  :alt
  (! :herbie-platform default (- (/ (+ (* z t) (* y x)) (+ y (* z (- b y)))) (/ a (+ (- b y) (/ y z)))))

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