Numeric.Signal:interpolate from hsignal-0.2.7.1

Percentage Accurate: 79.7% → 94.8%

Time: 18.5s

Alternatives: 22

Speedup: 0.3×

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x + ((y - z) * ((t - x) / (a - z)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 79.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = x + ((y - z) * ((t - x) / (a - z)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 94.8% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{t - x}{z - a} \cdot \left(z - y\right)\\ \mathbf{if}\;t\_1 \leq -5 \cdot 10^{-306} \lor \neg \left(t\_1 \leq 10^{-292}\right):\\ \;\;\;\;\mathsf{fma}\left(t - x, \frac{y - z}{a - z}, x\right)\\ \mathbf{else}:\\ \;\;\;\;t + \frac{t - x}{z} \cdot \left(a - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (/ (- t x) (- z a)) (- z y)))))
   (if (or (<= t_1 -5e-306) (not (<= t_1 1e-292)))
     (fma (- t x) (/ (- y z) (- a z)) x)
     (+ t (* (/ (- t x) z) (- a y))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((t - x) / (z - a)) * (z - y));
	double tmp;
	if ((t_1 <= -5e-306) || !(t_1 <= 1e-292)) {
		tmp = fma((t - x), ((y - z) / (a - z)), x);
	} else {
		tmp = t + (((t - x) / z) * (a - y));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(Float64(t - x) / Float64(z - a)) * Float64(z - y)))
	tmp = 0.0
	if ((t_1 <= -5e-306) || !(t_1 <= 1e-292))
		tmp = fma(Float64(t - x), Float64(Float64(y - z) / Float64(a - z)), x);
	else
		tmp = Float64(t + Float64(Float64(Float64(t - x) / z) * Float64(a - y)));
	end
	return tmp
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -4.99999999999999998e-306 or 1.0000000000000001e-292 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z))))

   1. Initial program 92.1%

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

      1. +-commutative 92.1%

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

      2. remove-double-neg 92.1%

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

      3. unsub-neg 92.1%

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

      4. *-commutative 92.1%

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

      5. associate-*l/ 75.5%

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

      6. associate-/l* 95.9%

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

      7. fma-neg 95.9%

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

      8. remove-double-neg 95.9%

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

   3. Simplified 95.9%

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

   if -4.99999999999999998e-306 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 1.0000000000000001e-292

   1. Initial program 3.8%

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

   3. Taylor expanded in z around inf 96.1%

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

      1. associate--l+ 96.1%

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

      2. distribute-lft-out-- 96.1%

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

      3. div-sub 96.1%

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

      4. mul-1-neg 96.1%

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

      5. unsub-neg 96.1%

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

      6. div-sub 96.1%

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

      7. associate-/l* 99.8%

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

      8. associate-/l* 99.8%

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

      9. distribute-rgt-out-- 99.8%

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

   5. Simplified 99.8%

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

4. Final simplification 96.3%

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

Alternative 2: 37.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \frac{y}{a - z}\\ \mathbf{if}\;z \leq -3.9 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{+96}:\\ \;\;\;\;x \cdot \frac{y - a}{z}\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{+28}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{-234}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 2.3 \cdot 10^{-304}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.2 \cdot 10^{-172}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-5}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* t (/ y (- a z)))))
   (if (<= z -3.9e+125)
     t
     (if (<= z -2.1e+96)
       (* x (/ (- y a) z))
       (if (<= z -1.05e+28)
         t
         (if (<= z -1.05e-234)
           (* t (/ (- y z) a))
           (if (<= z 2.3e-304)
             x
             (if (<= z 4.2e-172)
               t_1
               (if (<= z 5.8e-68) x (if (<= z 5.8e-5) t_1 t))))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = t * (y / (a - z));
	double tmp;
	if (z <= -3.9e+125) {
		tmp = t;
	} else if (z <= -2.1e+96) {
		tmp = x * ((y - a) / z);
	} else if (z <= -1.05e+28) {
		tmp = t;
	} else if (z <= -1.05e-234) {
		tmp = t * ((y - z) / a);
	} else if (z <= 2.3e-304) {
		tmp = x;
	} else if (z <= 4.2e-172) {
		tmp = t_1;
	} else if (z <= 5.8e-68) {
		tmp = x;
	} else if (z <= 5.8e-5) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = t * (y / (a - z))
    if (z <= (-3.9d+125)) then
        tmp = t
    else if (z <= (-2.1d+96)) then
        tmp = x * ((y - a) / z)
    else if (z <= (-1.05d+28)) then
        tmp = t
    else if (z <= (-1.05d-234)) then
        tmp = t * ((y - z) / a)
    else if (z <= 2.3d-304) then
        tmp = x
    else if (z <= 4.2d-172) then
        tmp = t_1
    else if (z <= 5.8d-68) then
        tmp = x
    else if (z <= 5.8d-5) then
        tmp = t_1
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = t * (y / (a - z));
	double tmp;
	if (z <= -3.9e+125) {
		tmp = t;
	} else if (z <= -2.1e+96) {
		tmp = x * ((y - a) / z);
	} else if (z <= -1.05e+28) {
		tmp = t;
	} else if (z <= -1.05e-234) {
		tmp = t * ((y - z) / a);
	} else if (z <= 2.3e-304) {
		tmp = x;
	} else if (z <= 4.2e-172) {
		tmp = t_1;
	} else if (z <= 5.8e-68) {
		tmp = x;
	} else if (z <= 5.8e-5) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = t * (y / (a - z))
	tmp = 0
	if z <= -3.9e+125:
		tmp = t
	elif z <= -2.1e+96:
		tmp = x * ((y - a) / z)
	elif z <= -1.05e+28:
		tmp = t
	elif z <= -1.05e-234:
		tmp = t * ((y - z) / a)
	elif z <= 2.3e-304:
		tmp = x
	elif z <= 4.2e-172:
		tmp = t_1
	elif z <= 5.8e-68:
		tmp = x
	elif z <= 5.8e-5:
		tmp = t_1
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(t * Float64(y / Float64(a - z)))
	tmp = 0.0
	if (z <= -3.9e+125)
		tmp = t;
	elseif (z <= -2.1e+96)
		tmp = Float64(x * Float64(Float64(y - a) / z));
	elseif (z <= -1.05e+28)
		tmp = t;
	elseif (z <= -1.05e-234)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	elseif (z <= 2.3e-304)
		tmp = x;
	elseif (z <= 4.2e-172)
		tmp = t_1;
	elseif (z <= 5.8e-68)
		tmp = x;
	elseif (z <= 5.8e-5)
		tmp = t_1;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = t * (y / (a - z));
	tmp = 0.0;
	if (z <= -3.9e+125)
		tmp = t;
	elseif (z <= -2.1e+96)
		tmp = x * ((y - a) / z);
	elseif (z <= -1.05e+28)
		tmp = t;
	elseif (z <= -1.05e-234)
		tmp = t * ((y - z) / a);
	elseif (z <= 2.3e-304)
		tmp = x;
	elseif (z <= 4.2e-172)
		tmp = t_1;
	elseif (z <= 5.8e-68)
		tmp = x;
	elseif (z <= 5.8e-5)
		tmp = t_1;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.9e+125], t, If[LessEqual[z, -2.1e+96], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.05e+28], t, If[LessEqual[z, -1.05e-234], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e-304], x, If[LessEqual[z, 4.2e-172], t$95$1, If[LessEqual[z, 5.8e-68], x, If[LessEqual[z, 5.8e-5], t$95$1, t]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if z < -3.9000000000000002e125 or -2.1000000000000001e96 < z < -1.04999999999999995e28 or 5.8e-5 < z

   1. Initial program 74.0%

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

   3. Taylor expanded in z around inf 53.5%

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

   if -3.9000000000000002e125 < z < -2.1000000000000001e96

   1. Initial program 45.1%

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

   3. Taylor expanded in z around inf 86.9%

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

      1. associate--l+ 86.9%

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

      2. distribute-lft-out-- 86.9%

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

      3. div-sub 86.9%

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

      4. mul-1-neg 86.9%

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

      5. unsub-neg 86.9%

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

      6. div-sub 86.9%

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

      7. associate-/l* 86.9%

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

      8. associate-/l* 86.7%

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

      9. distribute-rgt-out-- 86.7%

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

   5. Simplified 86.7%

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

   6. Taylor expanded in t around 0 82.2%

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

      1. associate-/l* 69.0%

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

   8. Simplified 69.0%

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

   if -1.04999999999999995e28 < z < -1.04999999999999996e-234

   1. Initial program 93.2%

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

   3. Taylor expanded in x around 0 43.1%

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

      1. associate-/l* 51.2%

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

   5. Simplified 51.2%

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

   6. Taylor expanded in a around inf 38.1%

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

      1. associate-/l* 48.9%

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

   8. Simplified 48.9%

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

   if -1.04999999999999996e-234 < z < 2.3e-304 or 4.1999999999999999e-172 < z < 5.8000000000000001e-68

   1. Initial program 91.0%

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

   3. Taylor expanded in a around inf 52.5%

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

   if 2.3e-304 < z < 4.1999999999999999e-172 or 5.8000000000000001e-68 < z < 5.8e-5

   1. Initial program 95.1%

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

   3. Taylor expanded in y around inf 66.8%

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

      1. div-sub 66.8%

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

   5. Simplified 66.8%

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

   6. Taylor expanded in t around inf 43.1%

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

      1. associate-/l* 51.2%

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

   8. Simplified 51.2%

      \[\leadsto \color{blue}{t \cdot \frac{y}{a - z}} \]
3. Recombined 5 regimes into one program.

4. Final simplification 52.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.9 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{+96}:\\ \;\;\;\;x \cdot \frac{y - a}{z}\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{+28}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{-234}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 2.3 \cdot 10^{-304}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.2 \cdot 10^{-172}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 90.5% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (/ (- t x) (- z a)) (- z y)))))
   (if (or (<= t_1 -5e-306) (not (<= t_1 4e-199)))
     t_1
     (+ t (* (/ (- t x) z) (- a y))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((t - x) / (z - a)) * (z - y));
	double tmp;
	if ((t_1 <= -5e-306) || !(t_1 <= 4e-199)) {
		tmp = t_1;
	} else {
		tmp = t + (((t - x) / z) * (a - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = x + (((t - x) / (z - a)) * (z - y))
    if ((t_1 <= (-5d-306)) .or. (.not. (t_1 <= 4d-199))) then
        tmp = t_1
    else
        tmp = t + (((t - x) / z) * (a - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((t - x) / (z - a)) * (z - y));
	double tmp;
	if ((t_1 <= -5e-306) || !(t_1 <= 4e-199)) {
		tmp = t_1;
	} else {
		tmp = t + (((t - x) / z) * (a - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + (((t - x) / (z - a)) * (z - y))
	tmp = 0
	if (t_1 <= -5e-306) or not (t_1 <= 4e-199):
		tmp = t_1
	else:
		tmp = t + (((t - x) / z) * (a - y))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(Float64(t - x) / Float64(z - a)) * Float64(z - y)))
	tmp = 0.0
	if ((t_1 <= -5e-306) || !(t_1 <= 4e-199))
		tmp = t_1;
	else
		tmp = Float64(t + Float64(Float64(Float64(t - x) / z) * Float64(a - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + (((t - x) / (z - a)) * (z - y));
	tmp = 0.0;
	if ((t_1 <= -5e-306) || ~((t_1 <= 4e-199)))
		tmp = t_1;
	else
		tmp = t + (((t - x) / z) * (a - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(t - x), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -5e-306], N[Not[LessEqual[t$95$1, 4e-199]], $MachinePrecision]], t$95$1, N[(t + N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -4.99999999999999998e-306 or 3.99999999999999993e-199 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z))))

   1. Initial program 94.0%

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

   if -4.99999999999999998e-306 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 3.99999999999999993e-199

   1. Initial program 9.8%

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

   3. Taylor expanded in z around inf 91.0%

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

      1. associate--l+ 91.0%

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

      2. distribute-lft-out-- 91.0%

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

      3. div-sub 91.0%

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

      4. mul-1-neg 91.0%

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

      5. unsub-neg 91.0%

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

      6. div-sub 91.0%

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

      7. associate-/l* 93.9%

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

      8. associate-/l* 93.4%

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

      9. distribute-rgt-out-- 93.4%

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

   5. Simplified 93.4%

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

4. Final simplification 93.9%

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

Alternative 4: 94.7% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (/ (- t x) (- z a)) (- z y)))))
   (if (or (<= t_1 -5e-306) (not (<= t_1 1e-292)))
     (+ x (/ (- x t) (/ (- a z) (- z y))))
     (+ t (* (/ (- t x) z) (- a y))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((t - x) / (z - a)) * (z - y));
	double tmp;
	if ((t_1 <= -5e-306) || !(t_1 <= 1e-292)) {
		tmp = x + ((x - t) / ((a - z) / (z - y)));
	} else {
		tmp = t + (((t - x) / z) * (a - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = x + (((t - x) / (z - a)) * (z - y))
    if ((t_1 <= (-5d-306)) .or. (.not. (t_1 <= 1d-292))) then
        tmp = x + ((x - t) / ((a - z) / (z - y)))
    else
        tmp = t + (((t - x) / z) * (a - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((t - x) / (z - a)) * (z - y));
	double tmp;
	if ((t_1 <= -5e-306) || !(t_1 <= 1e-292)) {
		tmp = x + ((x - t) / ((a - z) / (z - y)));
	} else {
		tmp = t + (((t - x) / z) * (a - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + (((t - x) / (z - a)) * (z - y))
	tmp = 0
	if (t_1 <= -5e-306) or not (t_1 <= 1e-292):
		tmp = x + ((x - t) / ((a - z) / (z - y)))
	else:
		tmp = t + (((t - x) / z) * (a - y))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(Float64(t - x) / Float64(z - a)) * Float64(z - y)))
	tmp = 0.0
	if ((t_1 <= -5e-306) || !(t_1 <= 1e-292))
		tmp = Float64(x + Float64(Float64(x - t) / Float64(Float64(a - z) / Float64(z - y))));
	else
		tmp = Float64(t + Float64(Float64(Float64(t - x) / z) * Float64(a - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + (((t - x) / (z - a)) * (z - y));
	tmp = 0.0;
	if ((t_1 <= -5e-306) || ~((t_1 <= 1e-292)))
		tmp = x + ((x - t) / ((a - z) / (z - y)));
	else
		tmp = t + (((t - x) / z) * (a - y));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -4.99999999999999998e-306 or 1.0000000000000001e-292 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z))))

   1. Initial program 92.1%

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

      1. *-commutative 92.1%

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

      2. associate-*l/ 75.5%

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

      3. associate-*r/ 95.9%

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

      4. clear-num 95.8%

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

      5. un-div-inv 95.8%

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

   4. Applied egg-rr 95.8%

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

   if -4.99999999999999998e-306 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 1.0000000000000001e-292

   1. Initial program 3.8%

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

   3. Taylor expanded in z around inf 96.1%

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

      1. associate--l+ 96.1%

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

      2. distribute-lft-out-- 96.1%

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

      3. div-sub 96.1%

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

      4. mul-1-neg 96.1%

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

      5. unsub-neg 96.1%

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

      6. div-sub 96.1%

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

      7. associate-/l* 99.8%

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

      8. associate-/l* 99.8%

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

      9. distribute-rgt-out-- 99.8%

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

   5. Simplified 99.8%

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

4. Final simplification 96.2%

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

Alternative 5: 40.2% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.2 \cdot 10^{+127}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -5.9 \cdot 10^{+97}:\\ \;\;\;\;x \cdot \frac{y - a}{z}\\ \mathbf{elif}\;z \leq -1 \cdot 10^{+28}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.5 \cdot 10^{-146}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 3 \cdot 10^{-226}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -4.2e+127)
   t
   (if (<= z -5.9e+97)
     (* x (/ (- y a) z))
     (if (<= z -1e+28)
       t
       (if (<= z -2.5e-146)
         (* t (/ (- y z) a))
         (if (<= z 3e-226)
           (* y (/ (- t x) a))
           (if (<= z 9.5e-69) x (if (<= z 5.8e-5) (* t (/ y (- a z))) t))))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -4.2e+127) {
		tmp = t;
	} else if (z <= -5.9e+97) {
		tmp = x * ((y - a) / z);
	} else if (z <= -1e+28) {
		tmp = t;
	} else if (z <= -2.5e-146) {
		tmp = t * ((y - z) / a);
	} else if (z <= 3e-226) {
		tmp = y * ((t - x) / a);
	} else if (z <= 9.5e-69) {
		tmp = x;
	} else if (z <= 5.8e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-4.2d+127)) then
        tmp = t
    else if (z <= (-5.9d+97)) then
        tmp = x * ((y - a) / z)
    else if (z <= (-1d+28)) then
        tmp = t
    else if (z <= (-2.5d-146)) then
        tmp = t * ((y - z) / a)
    else if (z <= 3d-226) then
        tmp = y * ((t - x) / a)
    else if (z <= 9.5d-69) then
        tmp = x
    else if (z <= 5.8d-5) then
        tmp = t * (y / (a - z))
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -4.2e+127) {
		tmp = t;
	} else if (z <= -5.9e+97) {
		tmp = x * ((y - a) / z);
	} else if (z <= -1e+28) {
		tmp = t;
	} else if (z <= -2.5e-146) {
		tmp = t * ((y - z) / a);
	} else if (z <= 3e-226) {
		tmp = y * ((t - x) / a);
	} else if (z <= 9.5e-69) {
		tmp = x;
	} else if (z <= 5.8e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -4.2e+127:
		tmp = t
	elif z <= -5.9e+97:
		tmp = x * ((y - a) / z)
	elif z <= -1e+28:
		tmp = t
	elif z <= -2.5e-146:
		tmp = t * ((y - z) / a)
	elif z <= 3e-226:
		tmp = y * ((t - x) / a)
	elif z <= 9.5e-69:
		tmp = x
	elif z <= 5.8e-5:
		tmp = t * (y / (a - z))
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -4.2e+127)
		tmp = t;
	elseif (z <= -5.9e+97)
		tmp = Float64(x * Float64(Float64(y - a) / z));
	elseif (z <= -1e+28)
		tmp = t;
	elseif (z <= -2.5e-146)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	elseif (z <= 3e-226)
		tmp = Float64(y * Float64(Float64(t - x) / a));
	elseif (z <= 9.5e-69)
		tmp = x;
	elseif (z <= 5.8e-5)
		tmp = Float64(t * Float64(y / Float64(a - z)));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -4.2e+127)
		tmp = t;
	elseif (z <= -5.9e+97)
		tmp = x * ((y - a) / z);
	elseif (z <= -1e+28)
		tmp = t;
	elseif (z <= -2.5e-146)
		tmp = t * ((y - z) / a);
	elseif (z <= 3e-226)
		tmp = y * ((t - x) / a);
	elseif (z <= 9.5e-69)
		tmp = x;
	elseif (z <= 5.8e-5)
		tmp = t * (y / (a - z));
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.2e+127], t, If[LessEqual[z, -5.9e+97], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1e+28], t, If[LessEqual[z, -2.5e-146], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3e-226], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.5e-69], x, If[LessEqual[z, 5.8e-5], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]]]]

Derivation

1. Split input into 6 regimes

2. if z < -4.19999999999999983e127 or -5.90000000000000009e97 < z < -9.99999999999999958e27 or 5.8e-5 < z

   1. Initial program 74.0%

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

   3. Taylor expanded in z around inf 53.5%

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

   if -4.19999999999999983e127 < z < -5.90000000000000009e97

   1. Initial program 45.1%

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

   3. Taylor expanded in z around inf 86.9%

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

      1. associate--l+ 86.9%

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

      2. distribute-lft-out-- 86.9%

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

      3. div-sub 86.9%

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

      4. mul-1-neg 86.9%

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

      5. unsub-neg 86.9%

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

      6. div-sub 86.9%

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

      7. associate-/l* 86.9%

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

      8. associate-/l* 86.7%

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

      9. distribute-rgt-out-- 86.7%

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

   5. Simplified 86.7%

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

   6. Taylor expanded in t around 0 82.2%

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

      1. associate-/l* 69.0%

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

   8. Simplified 69.0%

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

   if -9.99999999999999958e27 < z < -2.49999999999999979e-146

   1. Initial program 93.5%

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

   3. Taylor expanded in x around 0 42.1%

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

      1. associate-/l* 48.3%

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

   5. Simplified 48.3%

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

   6. Taylor expanded in a around inf 38.7%

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

      1. associate-/l* 48.1%

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

   8. Simplified 48.1%

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

   if -2.49999999999999979e-146 < z < 2.99999999999999995e-226

   1. Initial program 94.4%

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

   3. Taylor expanded in y around inf 65.6%

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

      1. div-sub 65.6%

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

   5. Simplified 65.6%

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

   6. Taylor expanded in a around inf 56.3%

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

   if 2.99999999999999995e-226 < z < 9.50000000000000094e-69

   1. Initial program 88.9%

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

   3. Taylor expanded in a around inf 47.5%

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

   if 9.50000000000000094e-69 < z < 5.8e-5

   1. Initial program 99.7%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.7%

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

   5. Simplified 74.7%

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

   6. Taylor expanded in t around inf 45.1%

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

      1. associate-/l* 55.0%

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

   8. Simplified 55.0%

      \[\leadsto \color{blue}{t \cdot \frac{y}{a - z}} \]
3. Recombined 6 regimes into one program.

4. Final simplification 52.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -4.2 \cdot 10^{+127}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -5.9 \cdot 10^{+97}:\\ \;\;\;\;x \cdot \frac{y - a}{z}\\ \mathbf{elif}\;z \leq -1 \cdot 10^{+28}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.5 \cdot 10^{-146}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 3 \cdot 10^{-226}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 40.2% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.4 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.2 \cdot 10^{+95}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -4.8 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -1.56 \cdot 10^{-145}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 1.16 \cdot 10^{-225}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \mathbf{elif}\;z \leq 1.05 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 1.6 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -4.4e+125)
   t
   (if (<= z -2.2e+95)
     (/ (* x (- y a)) z)
     (if (<= z -4.8e+27)
       t
       (if (<= z -1.56e-145)
         (* t (/ (- y z) a))
         (if (<= z 1.16e-225)
           (* y (/ (- t x) a))
           (if (<= z 1.05e-68)
             x
             (if (<= z 1.6e-5) (* t (/ y (- a z))) t))))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -4.4e+125) {
		tmp = t;
	} else if (z <= -2.2e+95) {
		tmp = (x * (y - a)) / z;
	} else if (z <= -4.8e+27) {
		tmp = t;
	} else if (z <= -1.56e-145) {
		tmp = t * ((y - z) / a);
	} else if (z <= 1.16e-225) {
		tmp = y * ((t - x) / a);
	} else if (z <= 1.05e-68) {
		tmp = x;
	} else if (z <= 1.6e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-4.4d+125)) then
        tmp = t
    else if (z <= (-2.2d+95)) then
        tmp = (x * (y - a)) / z
    else if (z <= (-4.8d+27)) then
        tmp = t
    else if (z <= (-1.56d-145)) then
        tmp = t * ((y - z) / a)
    else if (z <= 1.16d-225) then
        tmp = y * ((t - x) / a)
    else if (z <= 1.05d-68) then
        tmp = x
    else if (z <= 1.6d-5) then
        tmp = t * (y / (a - z))
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -4.4e+125) {
		tmp = t;
	} else if (z <= -2.2e+95) {
		tmp = (x * (y - a)) / z;
	} else if (z <= -4.8e+27) {
		tmp = t;
	} else if (z <= -1.56e-145) {
		tmp = t * ((y - z) / a);
	} else if (z <= 1.16e-225) {
		tmp = y * ((t - x) / a);
	} else if (z <= 1.05e-68) {
		tmp = x;
	} else if (z <= 1.6e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -4.4e+125:
		tmp = t
	elif z <= -2.2e+95:
		tmp = (x * (y - a)) / z
	elif z <= -4.8e+27:
		tmp = t
	elif z <= -1.56e-145:
		tmp = t * ((y - z) / a)
	elif z <= 1.16e-225:
		tmp = y * ((t - x) / a)
	elif z <= 1.05e-68:
		tmp = x
	elif z <= 1.6e-5:
		tmp = t * (y / (a - z))
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -4.4e+125)
		tmp = t;
	elseif (z <= -2.2e+95)
		tmp = Float64(Float64(x * Float64(y - a)) / z);
	elseif (z <= -4.8e+27)
		tmp = t;
	elseif (z <= -1.56e-145)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	elseif (z <= 1.16e-225)
		tmp = Float64(y * Float64(Float64(t - x) / a));
	elseif (z <= 1.05e-68)
		tmp = x;
	elseif (z <= 1.6e-5)
		tmp = Float64(t * Float64(y / Float64(a - z)));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -4.4e+125)
		tmp = t;
	elseif (z <= -2.2e+95)
		tmp = (x * (y - a)) / z;
	elseif (z <= -4.8e+27)
		tmp = t;
	elseif (z <= -1.56e-145)
		tmp = t * ((y - z) / a);
	elseif (z <= 1.16e-225)
		tmp = y * ((t - x) / a);
	elseif (z <= 1.05e-68)
		tmp = x;
	elseif (z <= 1.6e-5)
		tmp = t * (y / (a - z));
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.4e+125], t, If[LessEqual[z, -2.2e+95], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -4.8e+27], t, If[LessEqual[z, -1.56e-145], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.16e-225], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.05e-68], x, If[LessEqual[z, 1.6e-5], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]]]]

Derivation

1. Split input into 6 regimes

2. if z < -4.39999999999999982e125 or -2.1999999999999999e95 < z < -4.79999999999999995e27 or 1.59999999999999993e-5 < z

   1. Initial program 74.0%

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

   3. Taylor expanded in z around inf 53.5%

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

   if -4.39999999999999982e125 < z < -2.1999999999999999e95

   1. Initial program 45.1%

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

   3. Taylor expanded in z around inf 86.9%

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

      1. associate--l+ 86.9%

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

      2. distribute-lft-out-- 86.9%

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

      3. div-sub 86.9%

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

      4. mul-1-neg 86.9%

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

      5. unsub-neg 86.9%

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

      6. div-sub 86.9%

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

      7. associate-/l* 86.9%

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

      8. associate-/l* 86.7%

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

      9. distribute-rgt-out-- 86.7%

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

   5. Simplified 86.7%

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

   6. Taylor expanded in t around 0 82.2%

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

   if -4.79999999999999995e27 < z < -1.56000000000000001e-145

   1. Initial program 93.5%

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

   3. Taylor expanded in x around 0 42.1%

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

      1. associate-/l* 48.3%

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

   5. Simplified 48.3%

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

   6. Taylor expanded in a around inf 38.7%

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

      1. associate-/l* 48.1%

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

   8. Simplified 48.1%

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

   if -1.56000000000000001e-145 < z < 1.16000000000000001e-225

   1. Initial program 94.4%

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

   3. Taylor expanded in y around inf 65.6%

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

      1. div-sub 65.6%

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

   5. Simplified 65.6%

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

   6. Taylor expanded in a around inf 56.3%

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

   if 1.16000000000000001e-225 < z < 1.05000000000000004e-68

   1. Initial program 88.9%

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

   3. Taylor expanded in a around inf 47.5%

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

   if 1.05000000000000004e-68 < z < 1.59999999999999993e-5

   1. Initial program 99.7%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.7%

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

   5. Simplified 74.7%

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

   6. Taylor expanded in t around inf 45.1%

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

      1. associate-/l* 55.0%

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

   8. Simplified 55.0%

      \[\leadsto \color{blue}{t \cdot \frac{y}{a - z}} \]
3. Recombined 6 regimes into one program.

4. Final simplification 53.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -4.4 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2.2 \cdot 10^{+95}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -4.8 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -1.56 \cdot 10^{-145}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 1.16 \cdot 10^{-225}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \mathbf{elif}\;z \leq 1.05 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 1.6 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 39.5% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.8 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -4.4 \cdot 10^{+95}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -7 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2 \cdot 10^{-210}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 3.6 \cdot 10^{-225}:\\ \;\;\;\;\frac{y \cdot \left(t - x\right)}{a}\\ \mathbf{elif}\;z \leq 1.8 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 3.25 \cdot 10^{-6}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -3.8e+125)
   t
   (if (<= z -4.4e+95)
     (/ (* x (- y a)) z)
     (if (<= z -7e+27)
       t
       (if (<= z -2e-210)
         (* t (/ (- y z) a))
         (if (<= z 3.6e-225)
           (/ (* y (- t x)) a)
           (if (<= z 1.8e-68)
             x
             (if (<= z 3.25e-6) (* t (/ y (- a z))) t))))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3.8e+125) {
		tmp = t;
	} else if (z <= -4.4e+95) {
		tmp = (x * (y - a)) / z;
	} else if (z <= -7e+27) {
		tmp = t;
	} else if (z <= -2e-210) {
		tmp = t * ((y - z) / a);
	} else if (z <= 3.6e-225) {
		tmp = (y * (t - x)) / a;
	} else if (z <= 1.8e-68) {
		tmp = x;
	} else if (z <= 3.25e-6) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-3.8d+125)) then
        tmp = t
    else if (z <= (-4.4d+95)) then
        tmp = (x * (y - a)) / z
    else if (z <= (-7d+27)) then
        tmp = t
    else if (z <= (-2d-210)) then
        tmp = t * ((y - z) / a)
    else if (z <= 3.6d-225) then
        tmp = (y * (t - x)) / a
    else if (z <= 1.8d-68) then
        tmp = x
    else if (z <= 3.25d-6) then
        tmp = t * (y / (a - z))
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3.8e+125) {
		tmp = t;
	} else if (z <= -4.4e+95) {
		tmp = (x * (y - a)) / z;
	} else if (z <= -7e+27) {
		tmp = t;
	} else if (z <= -2e-210) {
		tmp = t * ((y - z) / a);
	} else if (z <= 3.6e-225) {
		tmp = (y * (t - x)) / a;
	} else if (z <= 1.8e-68) {
		tmp = x;
	} else if (z <= 3.25e-6) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -3.8e+125:
		tmp = t
	elif z <= -4.4e+95:
		tmp = (x * (y - a)) / z
	elif z <= -7e+27:
		tmp = t
	elif z <= -2e-210:
		tmp = t * ((y - z) / a)
	elif z <= 3.6e-225:
		tmp = (y * (t - x)) / a
	elif z <= 1.8e-68:
		tmp = x
	elif z <= 3.25e-6:
		tmp = t * (y / (a - z))
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -3.8e+125)
		tmp = t;
	elseif (z <= -4.4e+95)
		tmp = Float64(Float64(x * Float64(y - a)) / z);
	elseif (z <= -7e+27)
		tmp = t;
	elseif (z <= -2e-210)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	elseif (z <= 3.6e-225)
		tmp = Float64(Float64(y * Float64(t - x)) / a);
	elseif (z <= 1.8e-68)
		tmp = x;
	elseif (z <= 3.25e-6)
		tmp = Float64(t * Float64(y / Float64(a - z)));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -3.8e+125)
		tmp = t;
	elseif (z <= -4.4e+95)
		tmp = (x * (y - a)) / z;
	elseif (z <= -7e+27)
		tmp = t;
	elseif (z <= -2e-210)
		tmp = t * ((y - z) / a);
	elseif (z <= 3.6e-225)
		tmp = (y * (t - x)) / a;
	elseif (z <= 1.8e-68)
		tmp = x;
	elseif (z <= 3.25e-6)
		tmp = t * (y / (a - z));
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.8e+125], t, If[LessEqual[z, -4.4e+95], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -7e+27], t, If[LessEqual[z, -2e-210], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.6e-225], N[(N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[z, 1.8e-68], x, If[LessEqual[z, 3.25e-6], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]]]]

Derivation

1. Split input into 6 regimes

2. if z < -3.80000000000000002e125 or -4.3999999999999998e95 < z < -7.0000000000000004e27 or 3.2499999999999998e-6 < z

   1. Initial program 74.0%

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

   3. Taylor expanded in z around inf 53.5%

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

   if -3.80000000000000002e125 < z < -4.3999999999999998e95

   1. Initial program 45.1%

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

   3. Taylor expanded in z around inf 86.9%

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

      1. associate--l+ 86.9%

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

      2. distribute-lft-out-- 86.9%

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

      3. div-sub 86.9%

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

      4. mul-1-neg 86.9%

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

      5. unsub-neg 86.9%

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

      6. div-sub 86.9%

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

      7. associate-/l* 86.9%

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

      8. associate-/l* 86.7%

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

      9. distribute-rgt-out-- 86.7%

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

   5. Simplified 86.7%

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

   6. Taylor expanded in t around 0 82.2%

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

   if -7.0000000000000004e27 < z < -2.0000000000000001e-210

   1. Initial program 92.9%

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

   3. Taylor expanded in x around 0 42.6%

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

      1. associate-/l* 51.2%

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

   5. Simplified 51.2%

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

   6. Taylor expanded in a around inf 37.4%

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

      1. associate-/l* 48.8%

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

   8. Simplified 48.8%

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

   if -2.0000000000000001e-210 < z < 3.60000000000000009e-225

   1. Initial program 92.6%

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

   3. Taylor expanded in y around -inf 64.7%

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

      1. associate-*r/ 61.5%

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

      2. clear-num 59.8%

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

      3. div-inv 59.8%

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

      4. associate-/r/ 64.9%

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

   5. Applied egg-rr 64.9%

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

   6. Taylor expanded in a around inf 58.5%

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

   if 3.60000000000000009e-225 < z < 1.80000000000000004e-68

   1. Initial program 90.9%

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

   3. Taylor expanded in a around inf 48.6%

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

   if 1.80000000000000004e-68 < z < 3.2499999999999998e-6

   1. Initial program 99.7%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.7%

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

   5. Simplified 74.7%

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

   6. Taylor expanded in t around inf 45.1%

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

      1. associate-/l* 55.0%

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

   8. Simplified 55.0%

      \[\leadsto \color{blue}{t \cdot \frac{y}{a - z}} \]
3. Recombined 6 regimes into one program.

4. Final simplification 53.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.8 \cdot 10^{+125}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -4.4 \cdot 10^{+95}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -7 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -2 \cdot 10^{-210}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 3.6 \cdot 10^{-225}:\\ \;\;\;\;\frac{y \cdot \left(t - x\right)}{a}\\ \mathbf{elif}\;z \leq 1.8 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 3.25 \cdot 10^{-6}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 37.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \frac{y}{a - z}\\ \mathbf{if}\;z \leq -5.8 \cdot 10^{+26}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -8 \cdot 10^{-235}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 1.5 \cdot 10^{-306}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 1.05 \cdot 10^{-173}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.7 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 6.4 \cdot 10^{-5}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* t (/ y (- a z)))))
   (if (<= z -5.8e+26)
     t
     (if (<= z -8e-235)
       (* t (/ (- y z) a))
       (if (<= z 1.5e-306)
         x
         (if (<= z 1.05e-173)
           t_1
           (if (<= z 1.7e-69) x (if (<= z 6.4e-5) t_1 t))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = t * (y / (a - z));
	double tmp;
	if (z <= -5.8e+26) {
		tmp = t;
	} else if (z <= -8e-235) {
		tmp = t * ((y - z) / a);
	} else if (z <= 1.5e-306) {
		tmp = x;
	} else if (z <= 1.05e-173) {
		tmp = t_1;
	} else if (z <= 1.7e-69) {
		tmp = x;
	} else if (z <= 6.4e-5) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = t * (y / (a - z))
    if (z <= (-5.8d+26)) then
        tmp = t
    else if (z <= (-8d-235)) then
        tmp = t * ((y - z) / a)
    else if (z <= 1.5d-306) then
        tmp = x
    else if (z <= 1.05d-173) then
        tmp = t_1
    else if (z <= 1.7d-69) then
        tmp = x
    else if (z <= 6.4d-5) then
        tmp = t_1
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = t * (y / (a - z));
	double tmp;
	if (z <= -5.8e+26) {
		tmp = t;
	} else if (z <= -8e-235) {
		tmp = t * ((y - z) / a);
	} else if (z <= 1.5e-306) {
		tmp = x;
	} else if (z <= 1.05e-173) {
		tmp = t_1;
	} else if (z <= 1.7e-69) {
		tmp = x;
	} else if (z <= 6.4e-5) {
		tmp = t_1;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = t * (y / (a - z))
	tmp = 0
	if z <= -5.8e+26:
		tmp = t
	elif z <= -8e-235:
		tmp = t * ((y - z) / a)
	elif z <= 1.5e-306:
		tmp = x
	elif z <= 1.05e-173:
		tmp = t_1
	elif z <= 1.7e-69:
		tmp = x
	elif z <= 6.4e-5:
		tmp = t_1
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(t * Float64(y / Float64(a - z)))
	tmp = 0.0
	if (z <= -5.8e+26)
		tmp = t;
	elseif (z <= -8e-235)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	elseif (z <= 1.5e-306)
		tmp = x;
	elseif (z <= 1.05e-173)
		tmp = t_1;
	elseif (z <= 1.7e-69)
		tmp = x;
	elseif (z <= 6.4e-5)
		tmp = t_1;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = t * (y / (a - z));
	tmp = 0.0;
	if (z <= -5.8e+26)
		tmp = t;
	elseif (z <= -8e-235)
		tmp = t * ((y - z) / a);
	elseif (z <= 1.5e-306)
		tmp = x;
	elseif (z <= 1.05e-173)
		tmp = t_1;
	elseif (z <= 1.7e-69)
		tmp = x;
	elseif (z <= 6.4e-5)
		tmp = t_1;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.8e+26], t, If[LessEqual[z, -8e-235], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.5e-306], x, If[LessEqual[z, 1.05e-173], t$95$1, If[LessEqual[z, 1.7e-69], x, If[LessEqual[z, 6.4e-5], t$95$1, t]]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -5.8e26 or 6.39999999999999971e-5 < z

   1. Initial program 72.4%

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

   3. Taylor expanded in z around inf 50.6%

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

   if -5.8e26 < z < -7.9999999999999997e-235

   1. Initial program 93.2%

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

   3. Taylor expanded in x around 0 43.1%

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

      1. associate-/l* 51.2%

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

   5. Simplified 51.2%

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

   6. Taylor expanded in a around inf 38.1%

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

      1. associate-/l* 48.9%

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

   8. Simplified 48.9%

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

   if -7.9999999999999997e-235 < z < 1.50000000000000012e-306 or 1.05000000000000001e-173 < z < 1.70000000000000004e-69

   1. Initial program 91.0%

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

   3. Taylor expanded in a around inf 52.5%

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

   if 1.50000000000000012e-306 < z < 1.05000000000000001e-173 or 1.70000000000000004e-69 < z < 6.39999999999999971e-5

   1. Initial program 95.1%

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

   3. Taylor expanded in y around inf 66.8%

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

      1. div-sub 66.8%

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

   5. Simplified 66.8%

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

   6. Taylor expanded in t around inf 43.1%

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

      1. associate-/l* 51.2%

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

   8. Simplified 51.2%

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

4. Final simplification 50.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5.8 \cdot 10^{+26}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq -8 \cdot 10^{-235}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{elif}\;z \leq 1.5 \cdot 10^{-306}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 1.05 \cdot 10^{-173}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{elif}\;z \leq 1.7 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 6.4 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 46.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -2.52 \cdot 10^{+48}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq -1.6 \cdot 10^{-103}:\\ \;\;\;\;\frac{y \cdot \left(t - x\right)}{a}\\ \mathbf{elif}\;a \leq 5.3 \cdot 10^{+25}:\\ \;\;\;\;t \cdot \frac{z - y}{z}\\ \mathbf{elif}\;a \leq 6.5 \cdot 10^{+178}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.06 \cdot 10^{+219}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -2.52e+48)
   x
   (if (<= a -1.6e-103)
     (/ (* y (- t x)) a)
     (if (<= a 5.3e+25)
       (* t (/ (- z y) z))
       (if (<= a 6.5e+178) x (if (<= a 1.06e+219) (* t (/ (- y z) a)) x))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -2.52e+48) {
		tmp = x;
	} else if (a <= -1.6e-103) {
		tmp = (y * (t - x)) / a;
	} else if (a <= 5.3e+25) {
		tmp = t * ((z - y) / z);
	} else if (a <= 6.5e+178) {
		tmp = x;
	} else if (a <= 1.06e+219) {
		tmp = t * ((y - z) / a);
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (a <= (-2.52d+48)) then
        tmp = x
    else if (a <= (-1.6d-103)) then
        tmp = (y * (t - x)) / a
    else if (a <= 5.3d+25) then
        tmp = t * ((z - y) / z)
    else if (a <= 6.5d+178) then
        tmp = x
    else if (a <= 1.06d+219) then
        tmp = t * ((y - z) / a)
    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 tmp;
	if (a <= -2.52e+48) {
		tmp = x;
	} else if (a <= -1.6e-103) {
		tmp = (y * (t - x)) / a;
	} else if (a <= 5.3e+25) {
		tmp = t * ((z - y) / z);
	} else if (a <= 6.5e+178) {
		tmp = x;
	} else if (a <= 1.06e+219) {
		tmp = t * ((y - z) / a);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -2.52e+48:
		tmp = x
	elif a <= -1.6e-103:
		tmp = (y * (t - x)) / a
	elif a <= 5.3e+25:
		tmp = t * ((z - y) / z)
	elif a <= 6.5e+178:
		tmp = x
	elif a <= 1.06e+219:
		tmp = t * ((y - z) / a)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -2.52e+48)
		tmp = x;
	elseif (a <= -1.6e-103)
		tmp = Float64(Float64(y * Float64(t - x)) / a);
	elseif (a <= 5.3e+25)
		tmp = Float64(t * Float64(Float64(z - y) / z));
	elseif (a <= 6.5e+178)
		tmp = x;
	elseif (a <= 1.06e+219)
		tmp = Float64(t * Float64(Float64(y - z) / a));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -2.52e+48)
		tmp = x;
	elseif (a <= -1.6e-103)
		tmp = (y * (t - x)) / a;
	elseif (a <= 5.3e+25)
		tmp = t * ((z - y) / z);
	elseif (a <= 6.5e+178)
		tmp = x;
	elseif (a <= 1.06e+219)
		tmp = t * ((y - z) / a);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.52e+48], x, If[LessEqual[a, -1.6e-103], N[(N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[a, 5.3e+25], N[(t * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6.5e+178], x, If[LessEqual[a, 1.06e+219], N[(t * N[(N[(y - z), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], x]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -2.52000000000000001e48 or 5.29999999999999986e25 < a < 6.5000000000000005e178 or 1.06e219 < a

   1. Initial program 93.0%

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

   3. Taylor expanded in a around inf 52.7%

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

   if -2.52000000000000001e48 < a < -1.59999999999999988e-103

   1. Initial program 83.5%

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

   3. Taylor expanded in y around -inf 57.2%

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

      1. associate-*r/ 54.0%

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

      2. clear-num 54.0%

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

      3. div-inv 54.0%

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

      4. associate-/r/ 57.3%

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

   5. Applied egg-rr 57.3%

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

   6. Taylor expanded in a around inf 50.5%

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

   if -1.59999999999999988e-103 < a < 5.29999999999999986e25

   1. Initial program 72.7%

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

   3. Taylor expanded in x around 0 55.5%

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

      1. associate-/l* 70.3%

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

   5. Simplified 70.3%

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

   6. Taylor expanded in a around 0 48.2%

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

      1. associate-*r/ 48.2%

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

      2. neg-mul-1 48.2%

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

      3. distribute-rgt-neg-in 48.2%

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

      4. associate-/l* 62.1%

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

      5. sub-neg 62.1%

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

      6. distribute-neg-in 62.1%

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

      7. remove-double-neg 62.1%

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

   8. Simplified 62.1%

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

   if 6.5000000000000005e178 < a < 1.06e219

   1. Initial program 96.9%

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

   3. Taylor expanded in x around 0 13.9%

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

      1. associate-/l* 72.0%

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

   5. Simplified 72.0%

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

   6. Taylor expanded in a around inf 13.5%

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

      1. associate-/l* 55.0%

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

   8. Simplified 55.0%

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

4. Final simplification 56.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -2.52 \cdot 10^{+48}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq -1.6 \cdot 10^{-103}:\\ \;\;\;\;\frac{y \cdot \left(t - x\right)}{a}\\ \mathbf{elif}\;a \leq 5.3 \cdot 10^{+25}:\\ \;\;\;\;t \cdot \frac{z - y}{z}\\ \mathbf{elif}\;a \leq 6.5 \cdot 10^{+178}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.06 \cdot 10^{+219}:\\ \;\;\;\;t \cdot \frac{y - z}{a}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 65.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \frac{y - z}{a - z}\\ \mathbf{if}\;z \leq -3.8 \cdot 10^{+125}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -2.8 \cdot 10^{+98}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -1.2 \cdot 10^{+20} \lor \neg \left(z \leq 0.4\right):\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* t (/ (- y z) (- a z)))))
   (if (<= z -3.8e+125)
     t_1
     (if (<= z -2.8e+98)
       (/ (* x (- y a)) z)
       (if (or (<= z -1.2e+20) (not (<= z 0.4)))
         t_1
         (+ x (/ (- t x) (/ a y))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = t * ((y - z) / (a - z));
	double tmp;
	if (z <= -3.8e+125) {
		tmp = t_1;
	} else if (z <= -2.8e+98) {
		tmp = (x * (y - a)) / z;
	} else if ((z <= -1.2e+20) || !(z <= 0.4)) {
		tmp = t_1;
	} else {
		tmp = x + ((t - x) / (a / y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = t * ((y - z) / (a - z))
    if (z <= (-3.8d+125)) then
        tmp = t_1
    else if (z <= (-2.8d+98)) then
        tmp = (x * (y - a)) / z
    else if ((z <= (-1.2d+20)) .or. (.not. (z <= 0.4d0))) then
        tmp = t_1
    else
        tmp = x + ((t - x) / (a / y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = t * ((y - z) / (a - z));
	double tmp;
	if (z <= -3.8e+125) {
		tmp = t_1;
	} else if (z <= -2.8e+98) {
		tmp = (x * (y - a)) / z;
	} else if ((z <= -1.2e+20) || !(z <= 0.4)) {
		tmp = t_1;
	} else {
		tmp = x + ((t - x) / (a / y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = t * ((y - z) / (a - z))
	tmp = 0
	if z <= -3.8e+125:
		tmp = t_1
	elif z <= -2.8e+98:
		tmp = (x * (y - a)) / z
	elif (z <= -1.2e+20) or not (z <= 0.4):
		tmp = t_1
	else:
		tmp = x + ((t - x) / (a / y))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(t * Float64(Float64(y - z) / Float64(a - z)))
	tmp = 0.0
	if (z <= -3.8e+125)
		tmp = t_1;
	elseif (z <= -2.8e+98)
		tmp = Float64(Float64(x * Float64(y - a)) / z);
	elseif ((z <= -1.2e+20) || !(z <= 0.4))
		tmp = t_1;
	else
		tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = t * ((y - z) / (a - z));
	tmp = 0.0;
	if (z <= -3.8e+125)
		tmp = t_1;
	elseif (z <= -2.8e+98)
		tmp = (x * (y - a)) / z;
	elseif ((z <= -1.2e+20) || ~((z <= 0.4)))
		tmp = t_1;
	else
		tmp = x + ((t - x) / (a / y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.8e+125], t$95$1, If[LessEqual[z, -2.8e+98], N[(N[(x * N[(y - a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], If[Or[LessEqual[z, -1.2e+20], N[Not[LessEqual[z, 0.4]], $MachinePrecision]], t$95$1, N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -3.80000000000000002e125 or -2.8000000000000001e98 < z < -1.2e20 or 0.40000000000000002 < z

   1. Initial program 73.8%

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

   3. Taylor expanded in x around 0 41.8%

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

      1. associate-/l* 71.4%

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

   5. Simplified 71.4%

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

   if -3.80000000000000002e125 < z < -2.8000000000000001e98

   1. Initial program 45.1%

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

   3. Taylor expanded in z around inf 86.9%

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

      1. associate--l+ 86.9%

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

      2. distribute-lft-out-- 86.9%

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

      3. div-sub 86.9%

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

      4. mul-1-neg 86.9%

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

      5. unsub-neg 86.9%

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

      6. div-sub 86.9%

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

      7. associate-/l* 86.9%

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

      8. associate-/l* 86.7%

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

      9. distribute-rgt-out-- 86.7%

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

   5. Simplified 86.7%

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

   6. Taylor expanded in t around 0 82.2%

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

   if -1.2e20 < z < 0.40000000000000002

   1. Initial program 93.2%

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

      1. *-commutative 93.2%

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

      2. associate-*l/ 88.5%

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

      3. associate-*r/ 95.5%

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

      4. clear-num 95.4%

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

      5. un-div-inv 95.5%

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

   4. Applied egg-rr 95.5%

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

   5. Taylor expanded in z around 0 77.3%

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

4. Final simplification 74.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.8 \cdot 10^{+125}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{elif}\;z \leq -2.8 \cdot 10^{+98}:\\ \;\;\;\;\frac{x \cdot \left(y - a\right)}{z}\\ \mathbf{elif}\;z \leq -1.2 \cdot 10^{+20} \lor \neg \left(z \leq 0.4\right):\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{t - x}{\frac{a}{y}}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 37.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.2 \cdot 10^{-25}:\\ \;\;\;\;t \cdot \frac{y}{a}\\ \mathbf{elif}\;z \leq 0.06:\\ \;\;\;\;\frac{y}{z} \cdot \left(-t\right)\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -1.5e+27)
   t
   (if (<= z 7.2e-69)
     x
     (if (<= z 5.2e-25) (* t (/ y a)) (if (<= z 0.06) (* (/ y z) (- t)) t)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -1.5e+27) {
		tmp = t;
	} else if (z <= 7.2e-69) {
		tmp = x;
	} else if (z <= 5.2e-25) {
		tmp = t * (y / a);
	} else if (z <= 0.06) {
		tmp = (y / z) * -t;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-1.5d+27)) then
        tmp = t
    else if (z <= 7.2d-69) then
        tmp = x
    else if (z <= 5.2d-25) then
        tmp = t * (y / a)
    else if (z <= 0.06d0) then
        tmp = (y / z) * -t
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -1.5e+27) {
		tmp = t;
	} else if (z <= 7.2e-69) {
		tmp = x;
	} else if (z <= 5.2e-25) {
		tmp = t * (y / a);
	} else if (z <= 0.06) {
		tmp = (y / z) * -t;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -1.5e+27:
		tmp = t
	elif z <= 7.2e-69:
		tmp = x
	elif z <= 5.2e-25:
		tmp = t * (y / a)
	elif z <= 0.06:
		tmp = (y / z) * -t
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -1.5e+27)
		tmp = t;
	elseif (z <= 7.2e-69)
		tmp = x;
	elseif (z <= 5.2e-25)
		tmp = Float64(t * Float64(y / a));
	elseif (z <= 0.06)
		tmp = Float64(Float64(y / z) * Float64(-t));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -1.5e+27)
		tmp = t;
	elseif (z <= 7.2e-69)
		tmp = x;
	elseif (z <= 5.2e-25)
		tmp = t * (y / a);
	elseif (z <= 0.06)
		tmp = (y / z) * -t;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.5e+27], t, If[LessEqual[z, 7.2e-69], x, If[LessEqual[z, 5.2e-25], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.06], N[(N[(y / z), $MachinePrecision] * (-t)), $MachinePrecision], t]]]]

Derivation

1. Split input into 4 regimes

2. if z < -1.49999999999999988e27 or 0.059999999999999998 < z

   1. Initial program 71.9%

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

   3. Taylor expanded in z around inf 51.4%

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

   if -1.49999999999999988e27 < z < 7.20000000000000035e-69

   1. Initial program 92.1%

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

   3. Taylor expanded in a around inf 41.1%

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

   if 7.20000000000000035e-69 < z < 5.2e-25

   1. Initial program 99.6%

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

   3. Taylor expanded in y around inf 82.0%

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

      1. div-sub 82.1%

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

   5. Simplified 82.1%

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

   6. Taylor expanded in t around inf 47.7%

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

   7. Taylor expanded in a around inf 42.2%

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

      1. associate-/l* 59.1%

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

   9. Simplified 59.1%

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

   if 5.2e-25 < z < 0.059999999999999998

   1. Initial program 99.8%

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

   3. Taylor expanded in y around inf 61.9%

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

      1. div-sub 61.9%

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

   5. Simplified 61.9%

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

   6. Taylor expanded in a around 0 51.5%

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

      1. associate-*r/ 51.5%

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

      2. associate-*r* 51.5%

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

      3. neg-mul-1 51.5%

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

      4. *-commutative 51.5%

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

   8. Simplified 51.5%

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

   9. Taylor expanded in t around inf 33.1%

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

       1. mul-1-neg 33.1%

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

       2. associate-/l* 33.1%

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

       3. distribute-rgt-neg-in 33.1%

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

       4. mul-1-neg 33.1%

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

       5. associate-*r/ 33.1%

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

       6. mul-1-neg 33.1%

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

   11. Simplified 33.1%

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

4. Final simplification 46.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{-69}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 5.2 \cdot 10^{-25}:\\ \;\;\;\;t \cdot \frac{y}{a}\\ \mathbf{elif}\;z \leq 0.06:\\ \;\;\;\;\frac{y}{z} \cdot \left(-t\right)\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 55.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \frac{t - x}{a - z}\\ \mathbf{if}\;y \leq -3.1 \cdot 10^{+177}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-85}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{elif}\;y \leq 6.5 \cdot 10^{+54}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* y (/ (- t x) (- a z)))))
   (if (<= y -3.1e+177)
     t_1
     (if (<= y 1.9e-85) (* t (/ (- y z) (- a z))) (if (<= y 6.5e+54) x t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((t - x) / (a - z));
	double tmp;
	if (y <= -3.1e+177) {
		tmp = t_1;
	} else if (y <= 1.9e-85) {
		tmp = t * ((y - z) / (a - z));
	} else if (y <= 6.5e+54) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: t_1
    real(8) :: tmp
    t_1 = y * ((t - x) / (a - z))
    if (y <= (-3.1d+177)) then
        tmp = t_1
    else if (y <= 1.9d-85) then
        tmp = t * ((y - z) / (a - z))
    else if (y <= 6.5d+54) 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 t_1 = y * ((t - x) / (a - z));
	double tmp;
	if (y <= -3.1e+177) {
		tmp = t_1;
	} else if (y <= 1.9e-85) {
		tmp = t * ((y - z) / (a - z));
	} else if (y <= 6.5e+54) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * ((t - x) / (a - z))
	tmp = 0
	if y <= -3.1e+177:
		tmp = t_1
	elif y <= 1.9e-85:
		tmp = t * ((y - z) / (a - z))
	elif y <= 6.5e+54:
		tmp = x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(t - x) / Float64(a - z)))
	tmp = 0.0
	if (y <= -3.1e+177)
		tmp = t_1;
	elseif (y <= 1.9e-85)
		tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z)));
	elseif (y <= 6.5e+54)
		tmp = x;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * ((t - x) / (a - z));
	tmp = 0.0;
	if (y <= -3.1e+177)
		tmp = t_1;
	elseif (y <= 1.9e-85)
		tmp = t * ((y - z) / (a - z));
	elseif (y <= 6.5e+54)
		tmp = x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.1e+177], t$95$1, If[LessEqual[y, 1.9e-85], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.5e+54], x, t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if y < -3.0999999999999999e177 or 6.5e54 < y

   1. Initial program 93.1%

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

   3. Taylor expanded in y around inf 77.9%

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

      1. div-sub 77.9%

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

   5. Simplified 77.9%

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

   if -3.0999999999999999e177 < y < 1.8999999999999999e-85

   1. Initial program 78.3%

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

   3. Taylor expanded in x around 0 41.9%

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

      1. associate-/l* 59.5%

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

   5. Simplified 59.5%

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

   if 1.8999999999999999e-85 < y < 6.5e54

   1. Initial program 78.1%

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

   3. Taylor expanded in a around inf 44.7%

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

4. Final simplification 63.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -3.1 \cdot 10^{+177}:\\ \;\;\;\;y \cdot \frac{t - x}{a - z}\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-85}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{elif}\;y \leq 6.5 \cdot 10^{+54}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t - x}{a - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 55.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -2.55 \cdot 10^{+179}:\\ \;\;\;\;\left(x - t\right) \cdot \frac{y}{z - a}\\ \mathbf{elif}\;y \leq 3.7 \cdot 10^{-86}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+54}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t - x}{a - z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= y -2.55e+179)
   (* (- x t) (/ y (- z a)))
   (if (<= y 3.7e-86)
     (* t (/ (- y z) (- a z)))
     (if (<= y 5.2e+54) x (* y (/ (- t x) (- a z)))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (y <= -2.55e+179) {
		tmp = (x - t) * (y / (z - a));
	} else if (y <= 3.7e-86) {
		tmp = t * ((y - z) / (a - z));
	} else if (y <= 5.2e+54) {
		tmp = x;
	} else {
		tmp = y * ((t - x) / (a - z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (y <= (-2.55d+179)) then
        tmp = (x - t) * (y / (z - a))
    else if (y <= 3.7d-86) then
        tmp = t * ((y - z) / (a - z))
    else if (y <= 5.2d+54) then
        tmp = x
    else
        tmp = y * ((t - x) / (a - z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (y <= -2.55e+179) {
		tmp = (x - t) * (y / (z - a));
	} else if (y <= 3.7e-86) {
		tmp = t * ((y - z) / (a - z));
	} else if (y <= 5.2e+54) {
		tmp = x;
	} else {
		tmp = y * ((t - x) / (a - z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if y <= -2.55e+179:
		tmp = (x - t) * (y / (z - a))
	elif y <= 3.7e-86:
		tmp = t * ((y - z) / (a - z))
	elif y <= 5.2e+54:
		tmp = x
	else:
		tmp = y * ((t - x) / (a - z))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (y <= -2.55e+179)
		tmp = Float64(Float64(x - t) * Float64(y / Float64(z - a)));
	elseif (y <= 3.7e-86)
		tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z)));
	elseif (y <= 5.2e+54)
		tmp = x;
	else
		tmp = Float64(y * Float64(Float64(t - x) / Float64(a - z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (y <= -2.55e+179)
		tmp = (x - t) * (y / (z - a));
	elseif (y <= 3.7e-86)
		tmp = t * ((y - z) / (a - z));
	elseif (y <= 5.2e+54)
		tmp = x;
	else
		tmp = y * ((t - x) / (a - z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.55e+179], N[(N[(x - t), $MachinePrecision] * N[(y / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.7e-86], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.2e+54], x, N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if y < -2.5500000000000001e179

   1. Initial program 88.0%

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

   3. Taylor expanded in y around -inf 71.9%

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

      1. associate-*r/ 92.4%

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

      2. clear-num 88.8%

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

      3. div-inv 89.0%

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

      4. associate-/r/ 97.7%

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

   5. Applied egg-rr 97.7%

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

   if -2.5500000000000001e179 < y < 3.6999999999999998e-86

   1. Initial program 78.6%

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

   3. Taylor expanded in x around 0 42.0%

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

      1. associate-/l* 59.4%

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

   5. Simplified 59.4%

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

   if 3.6999999999999998e-86 < y < 5.20000000000000013e54

   1. Initial program 78.1%

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

   3. Taylor expanded in a around inf 44.7%

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

   if 5.20000000000000013e54 < y

   1. Initial program 94.3%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.6%

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

   5. Simplified 74.6%

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

4. Final simplification 63.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2.55 \cdot 10^{+179}:\\ \;\;\;\;\left(x - t\right) \cdot \frac{y}{z - a}\\ \mathbf{elif}\;y \leq 3.7 \cdot 10^{-86}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+54}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t - x}{a - z}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 38.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.1 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 4.6 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -2.1e+27)
   t
   (if (<= z 4.6e-68) x (if (<= z 4.8e-5) (* t (/ y (- a z))) t))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.1e+27) {
		tmp = t;
	} else if (z <= 4.6e-68) {
		tmp = x;
	} else if (z <= 4.8e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-2.1d+27)) then
        tmp = t
    else if (z <= 4.6d-68) then
        tmp = x
    else if (z <= 4.8d-5) then
        tmp = t * (y / (a - z))
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.1e+27) {
		tmp = t;
	} else if (z <= 4.6e-68) {
		tmp = x;
	} else if (z <= 4.8e-5) {
		tmp = t * (y / (a - z));
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -2.1e+27:
		tmp = t
	elif z <= 4.6e-68:
		tmp = x
	elif z <= 4.8e-5:
		tmp = t * (y / (a - z))
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -2.1e+27)
		tmp = t;
	elseif (z <= 4.6e-68)
		tmp = x;
	elseif (z <= 4.8e-5)
		tmp = Float64(t * Float64(y / Float64(a - z)));
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -2.1e+27)
		tmp = t;
	elseif (z <= 4.6e-68)
		tmp = x;
	elseif (z <= 4.8e-5)
		tmp = t * (y / (a - z));
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.1e+27], t, If[LessEqual[z, 4.6e-68], x, If[LessEqual[z, 4.8e-5], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.09999999999999995e27 or 4.8000000000000001e-5 < z

   1. Initial program 72.4%

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

   3. Taylor expanded in z around inf 50.6%

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

   if -2.09999999999999995e27 < z < 4.59999999999999994e-68

   1. Initial program 92.1%

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

   3. Taylor expanded in a around inf 41.1%

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

   if 4.59999999999999994e-68 < z < 4.8000000000000001e-5

   1. Initial program 99.7%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.7%

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

   5. Simplified 74.7%

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

   6. Taylor expanded in t around inf 45.1%

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

      1. associate-/l* 55.0%

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

   8. Simplified 55.0%

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

4. Final simplification 46.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.1 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 4.6 \cdot 10^{-68}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{-5}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 39.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -3.6 \cdot 10^{+109}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{-120}:\\ \;\;\;\;t \cdot \frac{z}{z - a}\\ \mathbf{elif}\;y \leq 3.9 \cdot 10^{+55}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= y -3.6e+109)
   (* t (/ y (- a z)))
   (if (<= y 4.2e-120)
     (* t (/ z (- z a)))
     (if (<= y 3.9e+55) x (* y (/ (- t x) a))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (y <= -3.6e+109) {
		tmp = t * (y / (a - z));
	} else if (y <= 4.2e-120) {
		tmp = t * (z / (z - a));
	} else if (y <= 3.9e+55) {
		tmp = x;
	} else {
		tmp = y * ((t - x) / a);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (y <= (-3.6d+109)) then
        tmp = t * (y / (a - z))
    else if (y <= 4.2d-120) then
        tmp = t * (z / (z - a))
    else if (y <= 3.9d+55) then
        tmp = x
    else
        tmp = y * ((t - x) / a)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (y <= -3.6e+109) {
		tmp = t * (y / (a - z));
	} else if (y <= 4.2e-120) {
		tmp = t * (z / (z - a));
	} else if (y <= 3.9e+55) {
		tmp = x;
	} else {
		tmp = y * ((t - x) / a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if y <= -3.6e+109:
		tmp = t * (y / (a - z))
	elif y <= 4.2e-120:
		tmp = t * (z / (z - a))
	elif y <= 3.9e+55:
		tmp = x
	else:
		tmp = y * ((t - x) / a)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (y <= -3.6e+109)
		tmp = Float64(t * Float64(y / Float64(a - z)));
	elseif (y <= 4.2e-120)
		tmp = Float64(t * Float64(z / Float64(z - a)));
	elseif (y <= 3.9e+55)
		tmp = x;
	else
		tmp = Float64(y * Float64(Float64(t - x) / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (y <= -3.6e+109)
		tmp = t * (y / (a - z));
	elseif (y <= 4.2e-120)
		tmp = t * (z / (z - a));
	elseif (y <= 3.9e+55)
		tmp = x;
	else
		tmp = y * ((t - x) / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[y, -3.6e+109], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.2e-120], N[(t * N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.9e+55], x, N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if y < -3.6e109

   1. Initial program 92.2%

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

   3. Taylor expanded in y around inf 77.9%

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

      1. div-sub 77.9%

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

   5. Simplified 77.9%

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

   6. Taylor expanded in t around inf 40.3%

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

      1. associate-/l* 59.9%

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

   8. Simplified 59.9%

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

   if -3.6e109 < y < 4.2000000000000001e-120

   1. Initial program 75.6%

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

   3. Taylor expanded in x around 0 42.3%

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

      1. associate-/l* 58.5%

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

   5. Simplified 58.5%

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

   6. Taylor expanded in y around 0 50.7%

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

      1. neg-mul-1 50.7%

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

      2. distribute-neg-frac2 50.7%

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

      3. neg-sub0 50.7%

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

      4. associate--r- 50.7%

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

      5. neg-sub0 50.7%

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

   8. Simplified 50.7%

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

   if 4.2000000000000001e-120 < y < 3.90000000000000027e55

   1. Initial program 80.3%

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

   3. Taylor expanded in a around inf 43.1%

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

   if 3.90000000000000027e55 < y

   1. Initial program 94.3%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.6%

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

   5. Simplified 74.6%

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

   6. Taylor expanded in a around inf 44.9%

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

4. Final simplification 48.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -3.6 \cdot 10^{+109}:\\ \;\;\;\;t \cdot \frac{y}{a - z}\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{-120}:\\ \;\;\;\;t \cdot \frac{z}{z - a}\\ \mathbf{elif}\;y \leq 3.9 \cdot 10^{+55}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t - x}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 38.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -5.4 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 2.45 \cdot 10^{-67}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 6.5 \cdot 10^{-7}:\\ \;\;\;\;t \cdot \frac{y}{a}\\ \mathbf{elif}\;z \leq 14:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -5.4e+27)
   t
   (if (<= z 2.45e-67)
     x
     (if (<= z 6.5e-7) (* t (/ y a)) (if (<= z 14.0) x t)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -5.4e+27) {
		tmp = t;
	} else if (z <= 2.45e-67) {
		tmp = x;
	} else if (z <= 6.5e-7) {
		tmp = t * (y / a);
	} else if (z <= 14.0) {
		tmp = x;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-5.4d+27)) then
        tmp = t
    else if (z <= 2.45d-67) then
        tmp = x
    else if (z <= 6.5d-7) then
        tmp = t * (y / a)
    else if (z <= 14.0d0) then
        tmp = x
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -5.4e+27) {
		tmp = t;
	} else if (z <= 2.45e-67) {
		tmp = x;
	} else if (z <= 6.5e-7) {
		tmp = t * (y / a);
	} else if (z <= 14.0) {
		tmp = x;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -5.4e+27:
		tmp = t
	elif z <= 2.45e-67:
		tmp = x
	elif z <= 6.5e-7:
		tmp = t * (y / a)
	elif z <= 14.0:
		tmp = x
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -5.4e+27)
		tmp = t;
	elseif (z <= 2.45e-67)
		tmp = x;
	elseif (z <= 6.5e-7)
		tmp = Float64(t * Float64(y / a));
	elseif (z <= 14.0)
		tmp = x;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -5.4e+27)
		tmp = t;
	elseif (z <= 2.45e-67)
		tmp = x;
	elseif (z <= 6.5e-7)
		tmp = t * (y / a);
	elseif (z <= 14.0)
		tmp = x;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -5.4e+27], t, If[LessEqual[z, 2.45e-67], x, If[LessEqual[z, 6.5e-7], N[(t * N[(y / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 14.0], x, t]]]]

Derivation

1. Split input into 3 regimes

2. if z < -5.3999999999999995e27 or 14 < z

   1. Initial program 71.9%

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

   3. Taylor expanded in z around inf 51.4%

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

   if -5.3999999999999995e27 < z < 2.44999999999999997e-67 or 6.50000000000000024e-7 < z < 14

   1. Initial program 92.2%

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

   3. Taylor expanded in a around inf 41.3%

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

   if 2.44999999999999997e-67 < z < 6.50000000000000024e-7

   1. Initial program 99.7%

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

   3. Taylor expanded in y around inf 74.6%

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

      1. div-sub 74.7%

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

   5. Simplified 74.7%

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

   6. Taylor expanded in t around inf 45.1%

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

   7. Taylor expanded in a around inf 35.9%

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

      1. associate-/l* 45.7%

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

   9. Simplified 45.7%

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

4. Final simplification 46.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5.4 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 2.45 \cdot 10^{-67}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 6.5 \cdot 10^{-7}:\\ \;\;\;\;t \cdot \frac{y}{a}\\ \mathbf{elif}\;z \leq 14:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 73.9% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -5.6e+26) (not (<= z 9.5e-21)))
   (+ t (* (/ (- t x) z) (- a y)))
   (+ x (/ (- t x) (/ a y)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -5.6e+26) || !(z <= 9.5e-21)) {
		tmp = t + (((t - x) / z) * (a - y));
	} else {
		tmp = x + ((t - x) / (a / y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((z <= (-5.6d+26)) .or. (.not. (z <= 9.5d-21))) then
        tmp = t + (((t - x) / z) * (a - y))
    else
        tmp = x + ((t - x) / (a / y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -5.6e+26) || !(z <= 9.5e-21)) {
		tmp = t + (((t - x) / z) * (a - y));
	} else {
		tmp = x + ((t - x) / (a / y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -5.6e+26) or not (z <= 9.5e-21):
		tmp = t + (((t - x) / z) * (a - y))
	else:
		tmp = x + ((t - x) / (a / y))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -5.6e+26) || !(z <= 9.5e-21))
		tmp = Float64(t + Float64(Float64(Float64(t - x) / z) * Float64(a - y)));
	else
		tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -5.6e+26) || ~((z <= 9.5e-21)))
		tmp = t + (((t - x) / z) * (a - y));
	else
		tmp = x + ((t - x) / (a / y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -5.6e+26], N[Not[LessEqual[z, 9.5e-21]], $MachinePrecision]], N[(t + N[(N[(N[(t - x), $MachinePrecision] / z), $MachinePrecision] * N[(a - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -5.59999999999999999e26 or 9.4999999999999994e-21 < z

   1. Initial program 73.4%

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

   3. Taylor expanded in z around inf 63.7%

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

      1. associate--l+ 63.7%

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

      2. distribute-lft-out-- 63.7%

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

      3. div-sub 63.7%

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

      4. mul-1-neg 63.7%

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

      5. unsub-neg 63.7%

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

      6. div-sub 63.7%

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

      7. associate-/l* 72.4%

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

      8. associate-/l* 76.6%

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

      9. distribute-rgt-out-- 76.7%

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

   5. Simplified 76.7%

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

   if -5.59999999999999999e26 < z < 9.4999999999999994e-21

   1. Initial program 92.9%

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

      1. *-commutative 92.9%

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

      2. associate-*l/ 87.2%

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

      3. associate-*r/ 95.3%

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

      4. clear-num 95.2%

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

      5. un-div-inv 95.3%

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

   4. Applied egg-rr 95.3%

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

   5. Taylor expanded in z around 0 77.8%

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

4. Final simplification 77.3%

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

Alternative 18: 62.8% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= a -3.7e-103) (not (<= a 7.2e+62)))
   (- x (* y (/ (- x t) a)))
   (* t (/ (- y z) (- a z)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((a <= -3.7e-103) || !(a <= 7.2e+62)) {
		tmp = x - (y * ((x - t) / a));
	} else {
		tmp = t * ((y - z) / (a - z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((a <= (-3.7d-103)) .or. (.not. (a <= 7.2d+62))) then
        tmp = x - (y * ((x - t) / a))
    else
        tmp = t * ((y - z) / (a - z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((a <= -3.7e-103) || !(a <= 7.2e+62)) {
		tmp = x - (y * ((x - t) / a));
	} else {
		tmp = t * ((y - z) / (a - z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (a <= -3.7e-103) or not (a <= 7.2e+62):
		tmp = x - (y * ((x - t) / a))
	else:
		tmp = t * ((y - z) / (a - z))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((a <= -3.7e-103) || !(a <= 7.2e+62))
		tmp = Float64(x - Float64(y * Float64(Float64(x - t) / a)));
	else
		tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((a <= -3.7e-103) || ~((a <= 7.2e+62)))
		tmp = x - (y * ((x - t) / a));
	else
		tmp = t * ((y - z) / (a - z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -3.7e-103], N[Not[LessEqual[a, 7.2e+62]], $MachinePrecision]], N[(x - N[(y * N[(N[(x - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -3.6999999999999999e-103 or 7.2e62 < a

   1. Initial program 91.7%

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

   3. Taylor expanded in z around 0 62.4%

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

      1. associate-/l* 71.1%

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

   5. Simplified 71.1%

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

   if -3.6999999999999999e-103 < a < 7.2e62

   1. Initial program 73.0%

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

   3. Taylor expanded in x around 0 55.7%

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

      1. associate-/l* 69.9%

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

   5. Simplified 69.9%

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

4. Final simplification 70.5%

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

Alternative 19: 68.3% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= a -3.3e-103) (not (<= a 2.05e-12)))
   (+ x (/ (- t x) (/ a y)))
   (+ t (* y (/ (- x t) z)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((a <= -3.3e-103) || !(a <= 2.05e-12)) {
		tmp = x + ((t - x) / (a / y));
	} else {
		tmp = t + (y * ((x - t) / z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if ((a <= (-3.3d-103)) .or. (.not. (a <= 2.05d-12))) then
        tmp = x + ((t - x) / (a / y))
    else
        tmp = t + (y * ((x - t) / z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((a <= -3.3e-103) || !(a <= 2.05e-12)) {
		tmp = x + ((t - x) / (a / y));
	} else {
		tmp = t + (y * ((x - t) / z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (a <= -3.3e-103) or not (a <= 2.05e-12):
		tmp = x + ((t - x) / (a / y))
	else:
		tmp = t + (y * ((x - t) / z))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((a <= -3.3e-103) || !(a <= 2.05e-12))
		tmp = Float64(x + Float64(Float64(t - x) / Float64(a / y)));
	else
		tmp = Float64(t + Float64(y * Float64(Float64(x - t) / z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((a <= -3.3e-103) || ~((a <= 2.05e-12)))
		tmp = x + ((t - x) / (a / y));
	else
		tmp = t + (y * ((x - t) / z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -3.3e-103], N[Not[LessEqual[a, 2.05e-12]], $MachinePrecision]], N[(x + N[(N[(t - x), $MachinePrecision] / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t + N[(y * N[(N[(x - t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -3.2999999999999999e-103 or 2.04999999999999995e-12 < a

   1. Initial program 91.7%

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

      1. *-commutative 91.7%

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

      2. associate-*l/ 70.5%

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

      3. associate-*r/ 93.9%

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

      4. clear-num 93.8%

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

      5. un-div-inv 93.8%

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

   4. Applied egg-rr 93.8%

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

   5. Taylor expanded in z around 0 70.9%

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

   if -3.2999999999999999e-103 < a < 2.04999999999999995e-12

   1. Initial program 70.9%

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

   3. Taylor expanded in z around inf 79.8%

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

      1. associate--l+ 79.8%

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

      2. distribute-lft-out-- 79.8%

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

      3. div-sub 80.8%

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

      4. mul-1-neg 80.8%

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

      5. unsub-neg 80.8%

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

      6. div-sub 79.8%

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

      7. associate-/l* 83.9%

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

      8. associate-/l* 80.9%

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

      9. distribute-rgt-out-- 84.9%

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

   5. Simplified 84.9%

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

   6. Taylor expanded in y around inf 78.1%

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

      1. associate-/l* 82.2%

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

   8. Simplified 82.2%

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

4. Final simplification 75.6%

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

Alternative 20: 54.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3.2 \cdot 10^{+94}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 3.5 \cdot 10^{+157}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= x -3.2e+94) x (if (<= x 3.5e+157) (* t (/ (- y z) (- a z))) x)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (x <= -3.2e+94) {
		tmp = x;
	} else if (x <= 3.5e+157) {
		tmp = t * ((y - z) / (a - z));
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (x <= (-3.2d+94)) then
        tmp = x
    else if (x <= 3.5d+157) then
        tmp = t * ((y - z) / (a - z))
    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 tmp;
	if (x <= -3.2e+94) {
		tmp = x;
	} else if (x <= 3.5e+157) {
		tmp = t * ((y - z) / (a - z));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if x <= -3.2e+94:
		tmp = x
	elif x <= 3.5e+157:
		tmp = t * ((y - z) / (a - z))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (x <= -3.2e+94)
		tmp = x;
	elseif (x <= 3.5e+157)
		tmp = Float64(t * Float64(Float64(y - z) / Float64(a - z)));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (x <= -3.2e+94)
		tmp = x;
	elseif (x <= 3.5e+157)
		tmp = t * ((y - z) / (a - z));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[x, -3.2e+94], x, If[LessEqual[x, 3.5e+157], N[(t * N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -3.20000000000000014e94 or 3.50000000000000002e157 < x

   1. Initial program 76.5%

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

   3. Taylor expanded in a around inf 43.8%

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

   if -3.20000000000000014e94 < x < 3.50000000000000002e157

   1. Initial program 85.7%

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

   3. Taylor expanded in x around 0 50.3%

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

      1. associate-/l* 68.3%

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

   5. Simplified 68.3%

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

4. Final simplification 61.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.2 \cdot 10^{+94}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 3.5 \cdot 10^{+157}:\\ \;\;\;\;t \cdot \frac{y - z}{a - z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 38.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.16 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 82:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -1.16e+27) t (if (<= z 82.0) x t)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -1.16e+27) {
		tmp = t;
	} else if (z <= 82.0) {
		tmp = x;
	} else {
		tmp = t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    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) :: tmp
    if (z <= (-1.16d+27)) then
        tmp = t
    else if (z <= 82.0d0) then
        tmp = x
    else
        tmp = t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -1.16e+27) {
		tmp = t;
	} else if (z <= 82.0) {
		tmp = x;
	} else {
		tmp = t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -1.16e+27:
		tmp = t
	elif z <= 82.0:
		tmp = x
	else:
		tmp = t
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -1.16e+27)
		tmp = t;
	elseif (z <= 82.0)
		tmp = x;
	else
		tmp = t;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -1.16e+27)
		tmp = t;
	elseif (z <= 82.0)
		tmp = x;
	else
		tmp = t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.16e+27], t, If[LessEqual[z, 82.0], x, t]]

Derivation

1. Split input into 2 regimes

2. if z < -1.16e27 or 82 < z

   1. Initial program 71.9%

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

   3. Taylor expanded in z around inf 51.4%

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

   if -1.16e27 < z < 82

   1. Initial program 93.3%

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

   3. Taylor expanded in a around inf 38.3%

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

4. Final simplification 44.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.16 \cdot 10^{+27}:\\ \;\;\;\;t\\ \mathbf{elif}\;z \leq 82:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 25.5% accurate, 13.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a)
    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
    code = t
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_] := t

Derivation

1. Initial program 83.1%

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

3. Taylor expanded in z around inf 27.2%

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

4. Final simplification 27.2%

   \[\leadsto t \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024079 
(FPCore (x y z t a)
  :name "Numeric.Signal:interpolate   from hsignal-0.2.7.1"
  :precision binary64
  (+ x (* (- y z) (/ (- t x) (- a z)))))