Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3

Percentage Accurate: 67.5% → 88.2%

Time: 24.7s

Alternatives: 20

Speedup: 0.8×

Specification

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 67.5% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 88.2% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (/ (* (- y x) (- z t)) (- a t)))))
   (if (<= t_1 -5e-288)
     (+ x (/ (- y x) (/ (- a t) (- z t))))
     (if (<= t_1 0.0)
       (+ y (/ (* (- y x) (- a z)) t))
       (+ x (* (- z t) (/ (- y x) (- a t))))))))

C

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

Python

def code(x, y, z, t, a):
	t_1 = x + (((y - x) * (z - t)) / (a - t))
	tmp = 0
	if t_1 <= -5e-288:
		tmp = x + ((y - x) / ((a - t) / (z - t)))
	elif t_1 <= 0.0:
		tmp = y + (((y - x) * (a - z)) / t)
	else:
		tmp = x + ((z - t) * ((y - x) / (a - t)))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -5.00000000000000011e-288

   1. Initial program 80.4%

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

      1. associate-/l* 90.9%

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

   3. Simplified 90.9%

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

   if -5.00000000000000011e-288 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0

   1. Initial program 4.7%

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

      1. +-commutative 4.7%

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

      2. *-commutative 4.7%

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

      3. associate-/l* 4.3%

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

      4. associate-/r/ 4.7%

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

      5. fma-def 4.7%

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

   3. Simplified 4.7%

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

   4. Taylor expanded in t around -inf 99.7%

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

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

   1. Initial program 70.1%

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

      1. associate-*l/ 89.3%

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

   3. Simplified 89.3%

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

4. Final simplification 90.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t} \leq -5 \cdot 10^{-288}:\\ \;\;\;\;x + \frac{y - x}{\frac{a - t}{z - t}}\\ \mathbf{elif}\;x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t} \leq 0:\\ \;\;\;\;y + \frac{\left(y - x\right) \cdot \left(a - z\right)}{t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a - t}\\ \end{array} \]

Alternative 2: 88.2% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (/ (* (- y x) (- z t)) (- a t)))))
   (if (<= t_1 -5e-288)
     (+ x (/ (- y x) (/ (- a t) (- z t))))
     (if (<= t_1 0.0)
       (+ y (* (- y x) (/ (- a z) t)))
       (+ x (* (- z t) (/ (- y x) (- a t))))))))

C

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

Python

def code(x, y, z, t, a):
	t_1 = x + (((y - x) * (z - t)) / (a - t))
	tmp = 0
	if t_1 <= -5e-288:
		tmp = x + ((y - x) / ((a - t) / (z - t)))
	elif t_1 <= 0.0:
		tmp = y + ((y - x) * ((a - z) / t))
	else:
		tmp = x + ((z - t) * ((y - x) / (a - t)))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -5.00000000000000011e-288

   1. Initial program 80.4%

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

      1. associate-/l* 90.9%

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

   3. Simplified 90.9%

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

   if -5.00000000000000011e-288 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0

   1. Initial program 4.7%

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

      1. associate-*l/ 4.1%

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

   3. Simplified 4.1%

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

      1. associate-/r/ 4.7%

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

      2. div-inv 3.9%

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

      3. associate-/r* 4.6%

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

   5. Applied egg-rr 4.6%

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

   6. Taylor expanded in t around inf 99.8%

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

      1. associate--l+ 99.8%

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

      2. associate-*r/ 99.8%

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

      3. associate-*r/ 99.8%

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

      4. div-sub 99.8%

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

      5. distribute-lft-out-- 99.8%

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

      6. distribute-rgt-out-- 99.7%

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

      7. associate-*r/ 99.7%

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

      8. distribute-rgt-out-- 99.8%

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

      9. mul-1-neg 99.8%

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

      10. distribute-rgt-out-- 99.7%

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

      11. *-commutative 99.7%

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

      12. associate-*r/ 92.4%

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

      13. div-sub 92.4%

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

   8. Simplified 99.7%

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

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

   1. Initial program 70.1%

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

      1. associate-*l/ 89.3%

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

   3. Simplified 89.3%

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

4. Final simplification 90.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t} \leq -5 \cdot 10^{-288}:\\ \;\;\;\;x + \frac{y - x}{\frac{a - t}{z - t}}\\ \mathbf{elif}\;x + \frac{\left(y - x\right) \cdot \left(z - t\right)}{a - t} \leq 0:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a - t}\\ \end{array} \]

Alternative 3: 67.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \frac{z - t}{a - t}\\ t_2 := x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{if}\;a \leq -3.5 \cdot 10^{+37}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;a \leq -1 \cdot 10^{-96}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -1.9 \cdot 10^{-120}:\\ \;\;\;\;\frac{\left(y - x\right) \cdot z}{a - t}\\ \mathbf{elif}\;a \leq 2.9 \cdot 10^{+27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ x (* (- z t) (/ (- y x) a)))))
   (if (<= a -3.5e+37)
     t_2
     (if (<= a -1e-96)
       t_1
       (if (<= a -1.9e-120)
         (/ (* (- y x) z) (- a t))
         (if (<= a 2.9e+27) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -3.5e+37) {
		tmp = t_2;
	} else if (a <= -1e-96) {
		tmp = t_1;
	} else if (a <= -1.9e-120) {
		tmp = ((y - x) * z) / (a - t);
	} else if (a <= 2.9e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = y * ((z - t) / (a - t))
    t_2 = x + ((z - t) * ((y - x) / a))
    if (a <= (-3.5d+37)) then
        tmp = t_2
    else if (a <= (-1d-96)) then
        tmp = t_1
    else if (a <= (-1.9d-120)) then
        tmp = ((y - x) * z) / (a - t)
    else if (a <= 2.9d+27) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -3.5e+37) {
		tmp = t_2;
	} else if (a <= -1e-96) {
		tmp = t_1;
	} else if (a <= -1.9e-120) {
		tmp = ((y - x) * z) / (a - t);
	} else if (a <= 2.9e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * ((z - t) / (a - t))
	t_2 = x + ((z - t) * ((y - x) / a))
	tmp = 0
	if a <= -3.5e+37:
		tmp = t_2
	elif a <= -1e-96:
		tmp = t_1
	elif a <= -1.9e-120:
		tmp = ((y - x) * z) / (a - t)
	elif a <= 2.9e+27:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t)))
	t_2 = Float64(x + Float64(Float64(z - t) * Float64(Float64(y - x) / a)))
	tmp = 0.0
	if (a <= -3.5e+37)
		tmp = t_2;
	elseif (a <= -1e-96)
		tmp = t_1;
	elseif (a <= -1.9e-120)
		tmp = Float64(Float64(Float64(y - x) * z) / Float64(a - t));
	elseif (a <= 2.9e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * ((z - t) / (a - t));
	t_2 = x + ((z - t) * ((y - x) / a));
	tmp = 0.0;
	if (a <= -3.5e+37)
		tmp = t_2;
	elseif (a <= -1e-96)
		tmp = t_1;
	elseif (a <= -1.9e-120)
		tmp = ((y - x) * z) / (a - t);
	elseif (a <= 2.9e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.5e+37], t$95$2, If[LessEqual[a, -1e-96], t$95$1, If[LessEqual[a, -1.9e-120], N[(N[(N[(y - x), $MachinePrecision] * z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.9e+27], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -3.5e37 or 2.9000000000000001e27 < a

   1. Initial program 73.2%

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

      1. associate-*l/ 91.1%

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

   3. Simplified 91.1%

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

   4. Taylor expanded in a around inf 85.4%

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

   if -3.5e37 < a < -9.9999999999999991e-97 or -1.8999999999999999e-120 < a < 2.9000000000000001e27

   1. Initial program 67.4%

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

      1. associate-/l* 78.1%

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

   3. Simplified 78.1%

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

   4. Taylor expanded in x around 0 59.8%

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

      1. associate-*r/ 69.5%

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

   6. Simplified 69.5%

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

   if -9.9999999999999991e-97 < a < -1.8999999999999999e-120

   1. Initial program 71.3%

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

      1. associate-/l* 65.0%

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

   3. Simplified 65.0%

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

   4. Taylor expanded in z around -inf 80.8%

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

4. Final simplification 76.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -3.5 \cdot 10^{+37}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{elif}\;a \leq -1 \cdot 10^{-96}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{elif}\;a \leq -1.9 \cdot 10^{-120}:\\ \;\;\;\;\frac{\left(y - x\right) \cdot z}{a - t}\\ \mathbf{elif}\;a \leq 2.9 \cdot 10^{+27}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \end{array} \]

Alternative 4: 75.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + \left(y - x\right) \cdot \frac{a - z}{t}\\ t_2 := x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{if}\;a \leq -6.2 \cdot 10^{+30}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{-55}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq 6 \cdot 10^{-31}:\\ \;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\ \mathbf{elif}\;a \leq 1.6 \cdot 10^{+27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ y (* (- y x) (/ (- a z) t))))
        (t_2 (+ x (* (- z t) (/ (- y x) a)))))
   (if (<= a -6.2e+30)
     t_2
     (if (<= a 3.6e-55)
       t_1
       (if (<= a 6e-31)
         (+ x (/ z (/ a (- y x))))
         (if (<= a 1.6e+27) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y + ((y - x) * ((a - z) / t));
	double t_2 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -6.2e+30) {
		tmp = t_2;
	} else if (a <= 3.6e-55) {
		tmp = t_1;
	} else if (a <= 6e-31) {
		tmp = x + (z / (a / (y - x)));
	} else if (a <= 1.6e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = y + ((y - x) * ((a - z) / t))
    t_2 = x + ((z - t) * ((y - x) / a))
    if (a <= (-6.2d+30)) then
        tmp = t_2
    else if (a <= 3.6d-55) then
        tmp = t_1
    else if (a <= 6d-31) then
        tmp = x + (z / (a / (y - x)))
    else if (a <= 1.6d+27) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y + ((y - x) * ((a - z) / t));
	double t_2 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -6.2e+30) {
		tmp = t_2;
	} else if (a <= 3.6e-55) {
		tmp = t_1;
	} else if (a <= 6e-31) {
		tmp = x + (z / (a / (y - x)));
	} else if (a <= 1.6e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y + ((y - x) * ((a - z) / t))
	t_2 = x + ((z - t) * ((y - x) / a))
	tmp = 0
	if a <= -6.2e+30:
		tmp = t_2
	elif a <= 3.6e-55:
		tmp = t_1
	elif a <= 6e-31:
		tmp = x + (z / (a / (y - x)))
	elif a <= 1.6e+27:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t)))
	t_2 = Float64(x + Float64(Float64(z - t) * Float64(Float64(y - x) / a)))
	tmp = 0.0
	if (a <= -6.2e+30)
		tmp = t_2;
	elseif (a <= 3.6e-55)
		tmp = t_1;
	elseif (a <= 6e-31)
		tmp = Float64(x + Float64(z / Float64(a / Float64(y - x))));
	elseif (a <= 1.6e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y + ((y - x) * ((a - z) / t));
	t_2 = x + ((z - t) * ((y - x) / a));
	tmp = 0.0;
	if (a <= -6.2e+30)
		tmp = t_2;
	elseif (a <= 3.6e-55)
		tmp = t_1;
	elseif (a <= 6e-31)
		tmp = x + (z / (a / (y - x)));
	elseif (a <= 1.6e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6.2e+30], t$95$2, If[LessEqual[a, 3.6e-55], t$95$1, If[LessEqual[a, 6e-31], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.6e+27], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -6.1999999999999995e30 or 1.60000000000000008e27 < a

   1. Initial program 73.4%

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

      1. associate-*l/ 91.1%

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

   3. Simplified 91.1%

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

   4. Taylor expanded in a around inf 85.5%

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

   if -6.1999999999999995e30 < a < 3.6000000000000001e-55 or 5.99999999999999962e-31 < a < 1.60000000000000008e27

   1. Initial program 65.8%

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

      1. associate-*l/ 72.0%

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

   3. Simplified 72.0%

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

      1. associate-/r/ 76.3%

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

      2. div-inv 76.1%

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

      3. associate-/r* 72.0%

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

   5. Applied egg-rr 72.0%

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

   6. Taylor expanded in t around inf 72.9%

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

      1. associate--l+ 72.9%

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

      2. associate-*r/ 72.9%

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

      3. associate-*r/ 72.9%

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

      4. div-sub 73.7%

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

      5. distribute-lft-out-- 73.7%

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

      6. distribute-rgt-out-- 73.6%

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

      7. associate-*r/ 73.6%

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

      8. distribute-rgt-out-- 73.7%

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

      9. mul-1-neg 73.7%

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

      10. distribute-rgt-out-- 73.6%

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

      11. *-commutative 73.6%

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

      12. associate-*r/ 77.5%

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

      13. div-sub 76.7%

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

   8. Simplified 79.1%

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

   if 3.6000000000000001e-55 < a < 5.99999999999999962e-31

   1. Initial program 96.7%

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

      1. associate-/l* 96.7%

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

   3. Simplified 96.7%

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

   4. Taylor expanded in t around 0 87.4%

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

      1. associate-/l* 87.4%

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

   6. Simplified 87.4%

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

4. Final simplification 82.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -6.2 \cdot 10^{+30}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{-55}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{elif}\;a \leq 6 \cdot 10^{-31}:\\ \;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\ \mathbf{elif}\;a \leq 1.6 \cdot 10^{+27}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \end{array} \]

Alternative 5: 75.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{if}\;a \leq -9.8 \cdot 10^{+30}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq 5.5 \cdot 10^{-55}:\\ \;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\ \mathbf{elif}\;a \leq 2.85 \cdot 10^{-28}:\\ \;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\ \mathbf{elif}\;a \leq 1.6 \cdot 10^{+27}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (- z t) (/ (- y x) a)))))
   (if (<= a -9.8e+30)
     t_1
     (if (<= a 5.5e-55)
       (+ y (/ (- x y) (/ t (- z a))))
       (if (<= a 2.85e-28)
         (+ x (/ z (/ a (- y x))))
         (if (<= a 1.6e+27) (+ y (* (- y x) (/ (- a z) t))) t_1))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -9.8e+30) {
		tmp = t_1;
	} else if (a <= 5.5e-55) {
		tmp = y + ((x - y) / (t / (z - a)));
	} else if (a <= 2.85e-28) {
		tmp = x + (z / (a / (y - x)));
	} else if (a <= 1.6e+27) {
		tmp = y + ((y - x) * ((a - z) / t));
	} 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 = x + ((z - t) * ((y - x) / a))
    if (a <= (-9.8d+30)) then
        tmp = t_1
    else if (a <= 5.5d-55) then
        tmp = y + ((x - y) / (t / (z - a)))
    else if (a <= 2.85d-28) then
        tmp = x + (z / (a / (y - x)))
    else if (a <= 1.6d+27) then
        tmp = y + ((y - x) * ((a - z) / t))
    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 = x + ((z - t) * ((y - x) / a));
	double tmp;
	if (a <= -9.8e+30) {
		tmp = t_1;
	} else if (a <= 5.5e-55) {
		tmp = y + ((x - y) / (t / (z - a)));
	} else if (a <= 2.85e-28) {
		tmp = x + (z / (a / (y - x)));
	} else if (a <= 1.6e+27) {
		tmp = y + ((y - x) * ((a - z) / t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + ((z - t) * ((y - x) / a))
	tmp = 0
	if a <= -9.8e+30:
		tmp = t_1
	elif a <= 5.5e-55:
		tmp = y + ((x - y) / (t / (z - a)))
	elif a <= 2.85e-28:
		tmp = x + (z / (a / (y - x)))
	elif a <= 1.6e+27:
		tmp = y + ((y - x) * ((a - z) / t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(z - t) * Float64(Float64(y - x) / a)))
	tmp = 0.0
	if (a <= -9.8e+30)
		tmp = t_1;
	elseif (a <= 5.5e-55)
		tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a))));
	elseif (a <= 2.85e-28)
		tmp = Float64(x + Float64(z / Float64(a / Float64(y - x))));
	elseif (a <= 1.6e+27)
		tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + ((z - t) * ((y - x) / a));
	tmp = 0.0;
	if (a <= -9.8e+30)
		tmp = t_1;
	elseif (a <= 5.5e-55)
		tmp = y + ((x - y) / (t / (z - a)));
	elseif (a <= 2.85e-28)
		tmp = x + (z / (a / (y - x)));
	elseif (a <= 1.6e+27)
		tmp = y + ((y - x) * ((a - z) / t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -9.8e+30], t$95$1, If[LessEqual[a, 5.5e-55], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.85e-28], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.6e+27], N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -9.79999999999999969e30 or 1.60000000000000008e27 < a

   1. Initial program 73.4%

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

      1. associate-*l/ 91.1%

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

   3. Simplified 91.1%

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

   4. Taylor expanded in a around inf 85.5%

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

   if -9.79999999999999969e30 < a < 5.4999999999999999e-55

   1. Initial program 67.4%

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

      1. associate-/l* 77.3%

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

   3. Simplified 77.3%

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

   4. Taylor expanded in t around inf 73.6%

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

      1. associate--l+ 73.6%

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

      2. associate-*r/ 73.6%

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

      3. associate-*r/ 73.6%

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

      4. div-sub 74.4%

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

      5. distribute-lft-out-- 74.4%

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

      6. associate-*r/ 74.4%

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

      7. mul-1-neg 74.4%

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

      8. unsub-neg 74.4%

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

      9. distribute-rgt-out-- 74.4%

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

      10. associate-/l* 80.5%

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

   6. Simplified 80.5%

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

   if 5.4999999999999999e-55 < a < 2.8500000000000002e-28

   1. Initial program 96.7%

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

      1. associate-/l* 96.7%

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

   3. Simplified 96.7%

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

   4. Taylor expanded in t around 0 87.4%

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

      1. associate-/l* 87.4%

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

   6. Simplified 87.4%

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

   if 2.8500000000000002e-28 < a < 1.60000000000000008e27

   1. Initial program 47.7%

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

      1. associate-*l/ 64.7%

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

   3. Simplified 64.7%

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

      1. associate-/r/ 64.9%

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

      2. div-inv 64.5%

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

      3. associate-/r* 64.4%

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

   5. Applied egg-rr 64.4%

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

   6. Taylor expanded in t around inf 64.9%

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

      1. associate--l+ 64.9%

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

      2. associate-*r/ 64.9%

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

      3. associate-*r/ 64.9%

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

      4. div-sub 64.9%

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

      5. distribute-lft-out-- 64.9%

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

      6. distribute-rgt-out-- 64.9%

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

      7. associate-*r/ 64.9%

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

      8. distribute-rgt-out-- 64.9%

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

      9. mul-1-neg 64.9%

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

      10. distribute-rgt-out-- 64.9%

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

      11. *-commutative 64.9%

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

      12. associate-*r/ 73.6%

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

      13. div-sub 73.6%

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

   8. Simplified 73.8%

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

4. Final simplification 82.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -9.8 \cdot 10^{+30}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \mathbf{elif}\;a \leq 5.5 \cdot 10^{-55}:\\ \;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\ \mathbf{elif}\;a \leq 2.85 \cdot 10^{-28}:\\ \;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\ \mathbf{elif}\;a \leq 1.6 \cdot 10^{+27}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a}\\ \end{array} \]

Alternative 6: 64.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \frac{z - t}{a - t}\\ t_2 := x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{if}\;a \leq -2.1 \cdot 10^{+41}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;a \leq -1.2 \cdot 10^{-96}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -7.2 \cdot 10^{-122}:\\ \;\;\;\;\frac{z}{\frac{a - t}{y - x}}\\ \mathbf{elif}\;a \leq 2.02 \cdot 10^{+27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ x (/ (- y x) (/ a z)))))
   (if (<= a -2.1e+41)
     t_2
     (if (<= a -1.2e-96)
       t_1
       (if (<= a -7.2e-122)
         (/ z (/ (- a t) (- y x)))
         (if (<= a 2.02e+27) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -2.1e+41) {
		tmp = t_2;
	} else if (a <= -1.2e-96) {
		tmp = t_1;
	} else if (a <= -7.2e-122) {
		tmp = z / ((a - t) / (y - x));
	} else if (a <= 2.02e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = y * ((z - t) / (a - t))
    t_2 = x + ((y - x) / (a / z))
    if (a <= (-2.1d+41)) then
        tmp = t_2
    else if (a <= (-1.2d-96)) then
        tmp = t_1
    else if (a <= (-7.2d-122)) then
        tmp = z / ((a - t) / (y - x))
    else if (a <= 2.02d+27) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -2.1e+41) {
		tmp = t_2;
	} else if (a <= -1.2e-96) {
		tmp = t_1;
	} else if (a <= -7.2e-122) {
		tmp = z / ((a - t) / (y - x));
	} else if (a <= 2.02e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * ((z - t) / (a - t))
	t_2 = x + ((y - x) / (a / z))
	tmp = 0
	if a <= -2.1e+41:
		tmp = t_2
	elif a <= -1.2e-96:
		tmp = t_1
	elif a <= -7.2e-122:
		tmp = z / ((a - t) / (y - x))
	elif a <= 2.02e+27:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t)))
	t_2 = Float64(x + Float64(Float64(y - x) / Float64(a / z)))
	tmp = 0.0
	if (a <= -2.1e+41)
		tmp = t_2;
	elseif (a <= -1.2e-96)
		tmp = t_1;
	elseif (a <= -7.2e-122)
		tmp = Float64(z / Float64(Float64(a - t) / Float64(y - x)));
	elseif (a <= 2.02e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * ((z - t) / (a - t));
	t_2 = x + ((y - x) / (a / z));
	tmp = 0.0;
	if (a <= -2.1e+41)
		tmp = t_2;
	elseif (a <= -1.2e-96)
		tmp = t_1;
	elseif (a <= -7.2e-122)
		tmp = z / ((a - t) / (y - x));
	elseif (a <= 2.02e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.1e+41], t$95$2, If[LessEqual[a, -1.2e-96], t$95$1, If[LessEqual[a, -7.2e-122], N[(z / N[(N[(a - t), $MachinePrecision] / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.02e+27], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -2.1e41 or 2.02e27 < a

   1. Initial program 73.2%

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

      1. associate-/l* 92.2%

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

   3. Simplified 92.2%

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

   4. Taylor expanded in t around 0 78.5%

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

   if -2.1e41 < a < -1.2000000000000001e-96 or -7.19999999999999989e-122 < a < 2.02e27

   1. Initial program 67.4%

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

      1. associate-/l* 78.1%

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

   3. Simplified 78.1%

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

   4. Taylor expanded in x around 0 59.8%

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

      1. associate-*r/ 69.5%

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

   6. Simplified 69.5%

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

   if -1.2000000000000001e-96 < a < -7.19999999999999989e-122

   1. Initial program 71.3%

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

      1. associate-/l* 65.0%

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

   3. Simplified 65.0%

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

   4. Taylor expanded in z around inf 80.8%

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

      1. div-sub 80.8%

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

      2. associate-*r/ 80.8%

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

      3. associate-/l* 80.5%

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

   6. Simplified 80.5%

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

4. Final simplification 73.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -2.1 \cdot 10^{+41}:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{elif}\;a \leq -1.2 \cdot 10^{-96}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{elif}\;a \leq -7.2 \cdot 10^{-122}:\\ \;\;\;\;\frac{z}{\frac{a - t}{y - x}}\\ \mathbf{elif}\;a \leq 2.02 \cdot 10^{+27}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \end{array} \]

Alternative 7: 64.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \frac{z - t}{a - t}\\ t_2 := x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{if}\;a \leq -2.4 \cdot 10^{+41}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;a \leq -9.5 \cdot 10^{-97}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -3 \cdot 10^{-118}:\\ \;\;\;\;\frac{\left(y - x\right) \cdot z}{a - t}\\ \mathbf{elif}\;a \leq 1.35 \cdot 10^{+27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* y (/ (- z t) (- a t)))) (t_2 (+ x (/ (- y x) (/ a z)))))
   (if (<= a -2.4e+41)
     t_2
     (if (<= a -9.5e-97)
       t_1
       (if (<= a -3e-118)
         (/ (* (- y x) z) (- a t))
         (if (<= a 1.35e+27) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -2.4e+41) {
		tmp = t_2;
	} else if (a <= -9.5e-97) {
		tmp = t_1;
	} else if (a <= -3e-118) {
		tmp = ((y - x) * z) / (a - t);
	} else if (a <= 1.35e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = y * ((z - t) / (a - t))
    t_2 = x + ((y - x) / (a / z))
    if (a <= (-2.4d+41)) then
        tmp = t_2
    else if (a <= (-9.5d-97)) then
        tmp = t_1
    else if (a <= (-3d-118)) then
        tmp = ((y - x) * z) / (a - t)
    else if (a <= 1.35d+27) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -2.4e+41) {
		tmp = t_2;
	} else if (a <= -9.5e-97) {
		tmp = t_1;
	} else if (a <= -3e-118) {
		tmp = ((y - x) * z) / (a - t);
	} else if (a <= 1.35e+27) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * ((z - t) / (a - t))
	t_2 = x + ((y - x) / (a / z))
	tmp = 0
	if a <= -2.4e+41:
		tmp = t_2
	elif a <= -9.5e-97:
		tmp = t_1
	elif a <= -3e-118:
		tmp = ((y - x) * z) / (a - t)
	elif a <= 1.35e+27:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t)))
	t_2 = Float64(x + Float64(Float64(y - x) / Float64(a / z)))
	tmp = 0.0
	if (a <= -2.4e+41)
		tmp = t_2;
	elseif (a <= -9.5e-97)
		tmp = t_1;
	elseif (a <= -3e-118)
		tmp = Float64(Float64(Float64(y - x) * z) / Float64(a - t));
	elseif (a <= 1.35e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * ((z - t) / (a - t));
	t_2 = x + ((y - x) / (a / z));
	tmp = 0.0;
	if (a <= -2.4e+41)
		tmp = t_2;
	elseif (a <= -9.5e-97)
		tmp = t_1;
	elseif (a <= -3e-118)
		tmp = ((y - x) * z) / (a - t);
	elseif (a <= 1.35e+27)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.4e+41], t$95$2, If[LessEqual[a, -9.5e-97], t$95$1, If[LessEqual[a, -3e-118], N[(N[(N[(y - x), $MachinePrecision] * z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.35e+27], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -2.4000000000000002e41 or 1.3499999999999999e27 < a

   1. Initial program 73.2%

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

      1. associate-/l* 92.2%

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

   3. Simplified 92.2%

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

   4. Taylor expanded in t around 0 78.5%

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

   if -2.4000000000000002e41 < a < -9.5000000000000001e-97 or -3.00000000000000018e-118 < a < 1.3499999999999999e27

   1. Initial program 67.4%

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

      1. associate-/l* 78.1%

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

   3. Simplified 78.1%

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

   4. Taylor expanded in x around 0 59.8%

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

      1. associate-*r/ 69.5%

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

   6. Simplified 69.5%

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

   if -9.5000000000000001e-97 < a < -3.00000000000000018e-118

   1. Initial program 71.3%

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

      1. associate-/l* 65.0%

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

   3. Simplified 65.0%

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

   4. Taylor expanded in z around -inf 80.8%

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

4. Final simplification 73.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -2.4 \cdot 10^{+41}:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{elif}\;a \leq -9.5 \cdot 10^{-97}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{elif}\;a \leq -3 \cdot 10^{-118}:\\ \;\;\;\;\frac{\left(y - x\right) \cdot z}{a - t}\\ \mathbf{elif}\;a \leq 1.35 \cdot 10^{+27}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \end{array} \]

Alternative 8: 87.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -7.5 \cdot 10^{+189}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{elif}\;t \leq 6.4 \cdot 10^{+131}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a - t}\\ \mathbf{else}:\\ \;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -7.5e+189)
   (+ y (* (- y x) (/ (- a z) t)))
   (if (<= t 6.4e+131)
     (+ x (* (- z t) (/ (- y x) (- a t))))
     (+ y (/ (- x y) (/ t (- z a)))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -7.5e+189) {
		tmp = y + ((y - x) * ((a - z) / t));
	} else if (t <= 6.4e+131) {
		tmp = x + ((z - t) * ((y - x) / (a - t)));
	} else {
		tmp = y + ((x - y) / (t / (z - 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 (t <= (-7.5d+189)) then
        tmp = y + ((y - x) * ((a - z) / t))
    else if (t <= 6.4d+131) then
        tmp = x + ((z - t) * ((y - x) / (a - t)))
    else
        tmp = y + ((x - y) / (t / (z - 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 (t <= -7.5e+189) {
		tmp = y + ((y - x) * ((a - z) / t));
	} else if (t <= 6.4e+131) {
		tmp = x + ((z - t) * ((y - x) / (a - t)));
	} else {
		tmp = y + ((x - y) / (t / (z - a)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -7.5e+189:
		tmp = y + ((y - x) * ((a - z) / t))
	elif t <= 6.4e+131:
		tmp = x + ((z - t) * ((y - x) / (a - t)))
	else:
		tmp = y + ((x - y) / (t / (z - a)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -7.5e+189)
		tmp = Float64(y + Float64(Float64(y - x) * Float64(Float64(a - z) / t)));
	elseif (t <= 6.4e+131)
		tmp = Float64(x + Float64(Float64(z - t) * Float64(Float64(y - x) / Float64(a - t))));
	else
		tmp = Float64(y + Float64(Float64(x - y) / Float64(t / Float64(z - a))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -7.5e+189)
		tmp = y + ((y - x) * ((a - z) / t));
	elseif (t <= 6.4e+131)
		tmp = x + ((z - t) * ((y - x) / (a - t)));
	else
		tmp = y + ((x - y) / (t / (z - a)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -7.5e+189], N[(y + N[(N[(y - x), $MachinePrecision] * N[(N[(a - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.4e+131], N[(x + N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y + N[(N[(x - y), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -7.49999999999999955e189

   1. Initial program 37.4%

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

      1. associate-*l/ 48.3%

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

   3. Simplified 48.3%

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

      1. associate-/r/ 66.2%

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

      2. div-inv 65.8%

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

      3. associate-/r* 48.2%

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

   5. Applied egg-rr 48.2%

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

   6. Taylor expanded in t around inf 62.8%

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

      1. associate--l+ 62.8%

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

      2. associate-*r/ 62.8%

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

      3. associate-*r/ 62.8%

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

      4. div-sub 62.8%

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

      5. distribute-lft-out-- 62.8%

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

      6. distribute-rgt-out-- 62.8%

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

      7. associate-*r/ 62.8%

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

      8. distribute-rgt-out-- 62.8%

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

      9. mul-1-neg 62.8%

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

      10. distribute-rgt-out-- 62.8%

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

      11. *-commutative 62.8%

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

      12. associate-*r/ 84.8%

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

      13. div-sub 84.8%

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

   8. Simplified 92.4%

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

   if -7.49999999999999955e189 < t < 6.4000000000000004e131

   1. Initial program 78.2%

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

      1. associate-*l/ 89.5%

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

   3. Simplified 89.5%

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

   if 6.4000000000000004e131 < t

   1. Initial program 36.5%

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

      1. associate-/l* 52.2%

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

   3. Simplified 52.2%

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

   4. Taylor expanded in t around inf 72.6%

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

      1. associate--l+ 72.6%

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

      2. associate-*r/ 72.6%

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

      3. associate-*r/ 72.6%

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

      4. div-sub 72.6%

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

      5. distribute-lft-out-- 72.6%

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

      6. associate-*r/ 72.6%

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

      7. mul-1-neg 72.6%

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

      8. unsub-neg 72.6%

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

      9. distribute-rgt-out-- 73.0%

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

      10. associate-/l* 91.2%

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

   6. Simplified 91.2%

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

4. Final simplification 89.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -7.5 \cdot 10^{+189}:\\ \;\;\;\;y + \left(y - x\right) \cdot \frac{a - z}{t}\\ \mathbf{elif}\;t \leq 6.4 \cdot 10^{+131}:\\ \;\;\;\;x + \left(z - t\right) \cdot \frac{y - x}{a - t}\\ \mathbf{else}:\\ \;\;\;\;y + \frac{x - y}{\frac{t}{z - a}}\\ \end{array} \]

Alternative 9: 58.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{t}{\frac{a}{y}}\\ \mathbf{if}\;a \leq -2.8 \cdot 10^{+100}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -2.1 \cdot 10^{+44}:\\ \;\;\;\;x \cdot \frac{-z}{a - t}\\ \mathbf{elif}\;a \leq 3.3 \cdot 10^{+80}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (/ t (/ a y)))))
   (if (<= a -2.8e+100)
     t_1
     (if (<= a -2.1e+44)
       (* x (/ (- z) (- a t)))
       (if (<= a 3.3e+80) (* y (/ (- z t) (- a t))) t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (t / (a / y));
	double tmp;
	if (a <= -2.8e+100) {
		tmp = t_1;
	} else if (a <= -2.1e+44) {
		tmp = x * (-z / (a - t));
	} else if (a <= 3.3e+80) {
		tmp = y * ((z - t) / (a - t));
	} 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 = x - (t / (a / y))
    if (a <= (-2.8d+100)) then
        tmp = t_1
    else if (a <= (-2.1d+44)) then
        tmp = x * (-z / (a - t))
    else if (a <= 3.3d+80) then
        tmp = y * ((z - t) / (a - t))
    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 = x - (t / (a / y));
	double tmp;
	if (a <= -2.8e+100) {
		tmp = t_1;
	} else if (a <= -2.1e+44) {
		tmp = x * (-z / (a - t));
	} else if (a <= 3.3e+80) {
		tmp = y * ((z - t) / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (t / (a / y))
	tmp = 0
	if a <= -2.8e+100:
		tmp = t_1
	elif a <= -2.1e+44:
		tmp = x * (-z / (a - t))
	elif a <= 3.3e+80:
		tmp = y * ((z - t) / (a - t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(t / Float64(a / y)))
	tmp = 0.0
	if (a <= -2.8e+100)
		tmp = t_1;
	elseif (a <= -2.1e+44)
		tmp = Float64(x * Float64(Float64(-z) / Float64(a - t)));
	elseif (a <= 3.3e+80)
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (t / (a / y));
	tmp = 0.0;
	if (a <= -2.8e+100)
		tmp = t_1;
	elseif (a <= -2.1e+44)
		tmp = x * (-z / (a - t));
	elseif (a <= 3.3e+80)
		tmp = y * ((z - t) / (a - t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.8e+100], t$95$1, If[LessEqual[a, -2.1e+44], N[(x * N[((-z) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.3e+80], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if a < -2.7999999999999998e100 or 3.29999999999999991e80 < a

   1. Initial program 74.0%

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

      1. associate-/l* 93.5%

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

   3. Simplified 93.5%

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

   4. Taylor expanded in z around 0 59.8%

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

      1. mul-1-neg 59.8%

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

      2. unsub-neg 59.8%

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

      3. associate-/l* 65.9%

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

   6. Simplified 65.9%

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

   7. Taylor expanded in a around inf 61.4%

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

   8. Taylor expanded in y around inf 61.4%

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

   if -2.7999999999999998e100 < a < -2.09999999999999987e44

   1. Initial program 64.5%

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

      1. associate-/l* 87.8%

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

   3. Simplified 87.8%

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

   4. Taylor expanded in z around inf 73.1%

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

      1. div-sub 73.1%

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

      2. associate-*r/ 52.6%

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

      3. associate-/l* 72.9%

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

   6. Simplified 72.9%

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

   7. Taylor expanded in y around 0 46.1%

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

      1. mul-1-neg 46.1%

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

      2. distribute-neg-frac 46.1%

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

      3. distribute-lft-neg-out 46.1%

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

      4. associate-*r/ 63.6%

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

      5. distribute-lft-neg-out 63.6%

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

      6. distribute-rgt-neg-in 63.6%

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

   9. Simplified 63.6%

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

   if -2.09999999999999987e44 < a < 3.29999999999999991e80

   1. Initial program 68.2%

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

      1. associate-/l* 77.7%

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

   3. Simplified 77.7%

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

   4. Taylor expanded in x around 0 56.8%

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

      1. associate-*r/ 65.6%

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

   6. Simplified 65.6%

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

4. Final simplification 64.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -2.8 \cdot 10^{+100}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;a \leq -2.1 \cdot 10^{+44}:\\ \;\;\;\;x \cdot \frac{-z}{a - t}\\ \mathbf{elif}\;a \leq 3.3 \cdot 10^{+80}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \end{array} \]

Alternative 10: 58.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{t}{\frac{a}{y}}\\ \mathbf{if}\;a \leq -1.4 \cdot 10^{+101}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -2.2 \cdot 10^{+26}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{elif}\;a \leq 1.05 \cdot 10^{+81}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (/ t (/ a y)))))
   (if (<= a -1.4e+101)
     t_1
     (if (<= a -2.2e+26)
       (* (- y x) (/ z (- a t)))
       (if (<= a 1.05e+81) (* y (/ (- z t) (- a t))) t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (t / (a / y));
	double tmp;
	if (a <= -1.4e+101) {
		tmp = t_1;
	} else if (a <= -2.2e+26) {
		tmp = (y - x) * (z / (a - t));
	} else if (a <= 1.05e+81) {
		tmp = y * ((z - t) / (a - t));
	} 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 = x - (t / (a / y))
    if (a <= (-1.4d+101)) then
        tmp = t_1
    else if (a <= (-2.2d+26)) then
        tmp = (y - x) * (z / (a - t))
    else if (a <= 1.05d+81) then
        tmp = y * ((z - t) / (a - t))
    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 = x - (t / (a / y));
	double tmp;
	if (a <= -1.4e+101) {
		tmp = t_1;
	} else if (a <= -2.2e+26) {
		tmp = (y - x) * (z / (a - t));
	} else if (a <= 1.05e+81) {
		tmp = y * ((z - t) / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (t / (a / y))
	tmp = 0
	if a <= -1.4e+101:
		tmp = t_1
	elif a <= -2.2e+26:
		tmp = (y - x) * (z / (a - t))
	elif a <= 1.05e+81:
		tmp = y * ((z - t) / (a - t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(t / Float64(a / y)))
	tmp = 0.0
	if (a <= -1.4e+101)
		tmp = t_1;
	elseif (a <= -2.2e+26)
		tmp = Float64(Float64(y - x) * Float64(z / Float64(a - t)));
	elseif (a <= 1.05e+81)
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (t / (a / y));
	tmp = 0.0;
	if (a <= -1.4e+101)
		tmp = t_1;
	elseif (a <= -2.2e+26)
		tmp = (y - x) * (z / (a - t));
	elseif (a <= 1.05e+81)
		tmp = y * ((z - t) / (a - t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.4e+101], t$95$1, If[LessEqual[a, -2.2e+26], N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.05e+81], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if a < -1.39999999999999991e101 or 1.0499999999999999e81 < a

   1. Initial program 74.0%

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

      1. associate-/l* 93.5%

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

   3. Simplified 93.5%

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

   4. Taylor expanded in z around 0 59.8%

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

      1. mul-1-neg 59.8%

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

      2. unsub-neg 59.8%

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

      3. associate-/l* 65.9%

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

   6. Simplified 65.9%

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

   7. Taylor expanded in a around inf 61.4%

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

   8. Taylor expanded in y around inf 61.4%

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

   if -1.39999999999999991e101 < a < -2.20000000000000007e26

   1. Initial program 68.4%

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

      1. associate-/l* 89.0%

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

   3. Simplified 89.0%

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

   4. Taylor expanded in z around inf 76.1%

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

      1. div-sub 76.1%

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

      2. associate-*r/ 57.9%

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

      3. associate-/l* 75.9%

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

   6. Simplified 75.9%

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

      1. associate-/r/ 75.9%

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

   8. Applied egg-rr 75.9%

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

   if -2.20000000000000007e26 < a < 1.0499999999999999e81

   1. Initial program 67.8%

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

      1. associate-/l* 77.4%

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

   3. Simplified 77.4%

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

   4. Taylor expanded in x around 0 56.8%

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

      1. associate-*r/ 65.7%

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

   6. Simplified 65.7%

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

4. Final simplification 64.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.4 \cdot 10^{+101}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;a \leq -2.2 \cdot 10^{+26}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{elif}\;a \leq 1.05 \cdot 10^{+81}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \end{array} \]

Alternative 11: 46.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \frac{-t}{a - t}\\ \mathbf{if}\;t \leq -1.52 \cdot 10^{+88}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -5 \cdot 10^{-175}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{+33}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* y (/ (- t) (- a t)))))
   (if (<= t -1.52e+88)
     t_1
     (if (<= t -5e-175)
       (- x (/ t (/ a y)))
       (if (<= t 1.4e+33) (* (- y x) (/ z a)) t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * (-t / (a - t));
	double tmp;
	if (t <= -1.52e+88) {
		tmp = t_1;
	} else if (t <= -5e-175) {
		tmp = x - (t / (a / y));
	} else if (t <= 1.4e+33) {
		tmp = (y - x) * (z / a);
	} 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 / (a - t))
    if (t <= (-1.52d+88)) then
        tmp = t_1
    else if (t <= (-5d-175)) then
        tmp = x - (t / (a / y))
    else if (t <= 1.4d+33) then
        tmp = (y - x) * (z / a)
    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 / (a - t));
	double tmp;
	if (t <= -1.52e+88) {
		tmp = t_1;
	} else if (t <= -5e-175) {
		tmp = x - (t / (a / y));
	} else if (t <= 1.4e+33) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * (-t / (a - t))
	tmp = 0
	if t <= -1.52e+88:
		tmp = t_1
	elif t <= -5e-175:
		tmp = x - (t / (a / y))
	elif t <= 1.4e+33:
		tmp = (y - x) * (z / a)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(-t) / Float64(a - t)))
	tmp = 0.0
	if (t <= -1.52e+88)
		tmp = t_1;
	elseif (t <= -5e-175)
		tmp = Float64(x - Float64(t / Float64(a / y)));
	elseif (t <= 1.4e+33)
		tmp = Float64(Float64(y - x) * Float64(z / a));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * (-t / (a - t));
	tmp = 0.0;
	if (t <= -1.52e+88)
		tmp = t_1;
	elseif (t <= -5e-175)
		tmp = x - (t / (a / y));
	elseif (t <= 1.4e+33)
		tmp = (y - x) * (z / a);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[((-t) / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.52e+88], t$95$1, If[LessEqual[t, -5e-175], N[(x - N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.4e+33], N[(N[(y - x), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.52000000000000004e88 or 1.4e33 < t

   1. Initial program 39.3%

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

      1. associate-/l* 65.9%

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

   3. Simplified 65.9%

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

   4. Taylor expanded in z around 0 24.9%

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

      1. mul-1-neg 24.9%

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

      2. unsub-neg 24.9%

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

      3. associate-/l* 37.0%

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

   6. Simplified 37.0%

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

   7. Taylor expanded in x around 0 34.3%

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

      1. mul-1-neg 34.3%

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

      2. associate-*l/ 49.8%

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

      3. *-commutative 49.8%

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

      4. distribute-rgt-neg-in 49.8%

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

      5. distribute-frac-neg 49.8%

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

   9. Simplified 49.8%

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

   if -1.52000000000000004e88 < t < -5e-175

   1. Initial program 86.0%

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

      1. associate-/l* 92.6%

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

   3. Simplified 92.6%

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

   4. Taylor expanded in z around 0 53.9%

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

      1. mul-1-neg 53.9%

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

      2. unsub-neg 53.9%

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

      3. associate-/l* 59.3%

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

   6. Simplified 59.3%

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

   7. Taylor expanded in a around inf 48.3%

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

   8. Taylor expanded in y around inf 46.9%

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

   if -5e-175 < t < 1.4e33

   1. Initial program 84.9%

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

      1. associate-/l* 93.3%

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

   3. Simplified 93.3%

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

   4. Taylor expanded in z around inf 55.1%

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

      1. div-sub 56.2%

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

      2. associate-*r/ 52.6%

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

      3. associate-/l* 56.2%

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

   6. Simplified 56.2%

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

      1. associate-/r/ 59.5%

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

   8. Applied egg-rr 59.5%

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

   9. Taylor expanded in a around inf 52.1%

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

4. Final simplification 49.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.52 \cdot 10^{+88}:\\ \;\;\;\;y \cdot \frac{-t}{a - t}\\ \mathbf{elif}\;t \leq -5 \cdot 10^{-175}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{+33}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{-t}{a - t}\\ \end{array} \]

Alternative 12: 39.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -9.5 \cdot 10^{+73}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 4 \cdot 10^{-114}:\\ \;\;\;\;y\\ \mathbf{elif}\;a \leq 4 \cdot 10^{+79}:\\ \;\;\;\;y \cdot \frac{z}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -9.5e+73)
   x
   (if (<= a 4e-114) y (if (<= a 4e+79) (* y (/ z (- a t))) x))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -9.5e+73) {
		tmp = x;
	} else if (a <= 4e-114) {
		tmp = y;
	} else if (a <= 4e+79) {
		tmp = y * (z / (a - t));
	} 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 <= (-9.5d+73)) then
        tmp = x
    else if (a <= 4d-114) then
        tmp = y
    else if (a <= 4d+79) then
        tmp = y * (z / (a - t))
    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 <= -9.5e+73) {
		tmp = x;
	} else if (a <= 4e-114) {
		tmp = y;
	} else if (a <= 4e+79) {
		tmp = y * (z / (a - t));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -9.5e+73:
		tmp = x
	elif a <= 4e-114:
		tmp = y
	elif a <= 4e+79:
		tmp = y * (z / (a - t))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -9.5e+73)
		tmp = x;
	elseif (a <= 4e-114)
		tmp = y;
	elseif (a <= 4e+79)
		tmp = Float64(y * Float64(z / Float64(a - t)));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -9.5e+73)
		tmp = x;
	elseif (a <= 4e-114)
		tmp = y;
	elseif (a <= 4e+79)
		tmp = y * (z / (a - t));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9.5e+73], x, If[LessEqual[a, 4e-114], y, If[LessEqual[a, 4e+79], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]

Derivation

1. Split input into 3 regimes

2. if a < -9.4999999999999996e73 or 3.99999999999999987e79 < a

   1. Initial program 74.0%

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

      1. associate-/l* 93.3%

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

   3. Simplified 93.3%

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

   4. Taylor expanded in a around inf 47.4%

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

   if -9.4999999999999996e73 < a < 4.0000000000000002e-114

   1. Initial program 66.6%

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

      1. associate-/l* 76.7%

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

   3. Simplified 76.7%

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

   4. Taylor expanded in t around inf 37.5%

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

   if 4.0000000000000002e-114 < a < 3.99999999999999987e79

   1. Initial program 70.3%

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

      1. associate-/l* 81.7%

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

   3. Simplified 81.7%

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

   4. Taylor expanded in z around inf 58.1%

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

      1. div-sub 58.1%

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

      2. associate-*r/ 53.4%

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

      3. associate-/l* 58.3%

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

   6. Simplified 58.3%

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

   7. Taylor expanded in y around inf 36.6%

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

      1. associate-/l* 41.7%

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

   9. Simplified 41.7%

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

       1. div-inv 41.6%

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

       2. clear-num 41.6%

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

   11. Applied egg-rr 41.6%

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

4. Final simplification 42.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -9.5 \cdot 10^{+73}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 4 \cdot 10^{-114}:\\ \;\;\;\;y\\ \mathbf{elif}\;a \leq 4 \cdot 10^{+79}:\\ \;\;\;\;y \cdot \frac{z}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 13: 42.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -4.2 \cdot 10^{+59}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -5 \cdot 10^{-41}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 1.24 \cdot 10^{+33}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -4.2e+59)
   y
   (if (<= t -5e-41) x (if (<= t 1.24e+33) (* (- y x) (/ z a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -4.2e+59) {
		tmp = y;
	} else if (t <= -5e-41) {
		tmp = x;
	} else if (t <= 1.24e+33) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = 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 (t <= (-4.2d+59)) then
        tmp = y
    else if (t <= (-5d-41)) then
        tmp = x
    else if (t <= 1.24d+33) then
        tmp = (y - x) * (z / a)
    else
        tmp = 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 (t <= -4.2e+59) {
		tmp = y;
	} else if (t <= -5e-41) {
		tmp = x;
	} else if (t <= 1.24e+33) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -4.2e+59:
		tmp = y
	elif t <= -5e-41:
		tmp = x
	elif t <= 1.24e+33:
		tmp = (y - x) * (z / a)
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -4.2e+59)
		tmp = y;
	elseif (t <= -5e-41)
		tmp = x;
	elseif (t <= 1.24e+33)
		tmp = Float64(Float64(y - x) * Float64(z / a));
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -4.2e+59)
		tmp = y;
	elseif (t <= -5e-41)
		tmp = x;
	elseif (t <= 1.24e+33)
		tmp = (y - x) * (z / a);
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -4.2e+59], y, If[LessEqual[t, -5e-41], x, If[LessEqual[t, 1.24e+33], N[(N[(y - x), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision], y]]]

Derivation

1. Split input into 3 regimes

2. if t < -4.19999999999999968e59 or 1.23999999999999997e33 < t

   1. Initial program 40.3%

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

      1. associate-/l* 68.1%

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

   3. Simplified 68.1%

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

   4. Taylor expanded in t around inf 46.1%

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

   if -4.19999999999999968e59 < t < -4.9999999999999996e-41

   1. Initial program 91.4%

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

      1. associate-/l* 93.3%

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

   3. Simplified 93.3%

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

   4. Taylor expanded in a around inf 45.4%

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

   if -4.9999999999999996e-41 < t < 1.23999999999999997e33

   1. Initial program 85.6%

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

      1. associate-/l* 92.7%

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

   3. Simplified 92.7%

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

   4. Taylor expanded in z around inf 53.0%

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

      1. div-sub 54.5%

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

      2. associate-*r/ 50.4%

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

      3. associate-/l* 54.5%

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

   6. Simplified 54.5%

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

      1. associate-/r/ 56.2%

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

   8. Applied egg-rr 56.2%

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

   9. Taylor expanded in a around inf 47.0%

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

4. Final simplification 46.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -4.2 \cdot 10^{+59}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -5 \cdot 10^{-41}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 1.24 \cdot 10^{+33}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \]

Alternative 14: 42.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.45 \cdot 10^{+51}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -3 \cdot 10^{-44}:\\ \;\;\;\;x + \frac{x \cdot t}{a}\\ \mathbf{elif}\;t \leq 4.9 \cdot 10^{+32}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -1.45e+51)
   y
   (if (<= t -3e-44)
     (+ x (/ (* x t) a))
     (if (<= t 4.9e+32) (* (- y x) (/ z a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -1.45e+51) {
		tmp = y;
	} else if (t <= -3e-44) {
		tmp = x + ((x * t) / a);
	} else if (t <= 4.9e+32) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = 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 (t <= (-1.45d+51)) then
        tmp = y
    else if (t <= (-3d-44)) then
        tmp = x + ((x * t) / a)
    else if (t <= 4.9d+32) then
        tmp = (y - x) * (z / a)
    else
        tmp = 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 (t <= -1.45e+51) {
		tmp = y;
	} else if (t <= -3e-44) {
		tmp = x + ((x * t) / a);
	} else if (t <= 4.9e+32) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -1.45e+51:
		tmp = y
	elif t <= -3e-44:
		tmp = x + ((x * t) / a)
	elif t <= 4.9e+32:
		tmp = (y - x) * (z / a)
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -1.45e+51)
		tmp = y;
	elseif (t <= -3e-44)
		tmp = Float64(x + Float64(Float64(x * t) / a));
	elseif (t <= 4.9e+32)
		tmp = Float64(Float64(y - x) * Float64(z / a));
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -1.45e+51)
		tmp = y;
	elseif (t <= -3e-44)
		tmp = x + ((x * t) / a);
	elseif (t <= 4.9e+32)
		tmp = (y - x) * (z / a);
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.45e+51], y, If[LessEqual[t, -3e-44], N[(x + N[(N[(x * t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.9e+32], N[(N[(y - x), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision], y]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.4499999999999999e51 or 4.9000000000000001e32 < t

   1. Initial program 41.2%

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

      1. associate-/l* 69.2%

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

   3. Simplified 69.2%

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

   4. Taylor expanded in t around inf 45.8%

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

   if -1.4499999999999999e51 < t < -3.0000000000000002e-44

   1. Initial program 94.5%

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

      1. associate-/l* 92.3%

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

   3. Simplified 92.3%

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

   4. Taylor expanded in z around 0 67.0%

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

      1. mul-1-neg 67.0%

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

      2. unsub-neg 67.0%

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

      3. associate-/l* 67.0%

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

   6. Simplified 67.0%

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

   7. Taylor expanded in x around inf 42.3%

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

      1. sub-neg 42.3%

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

      2. mul-1-neg 42.3%

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

      3. remove-double-neg 42.3%

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

   9. Simplified 42.3%

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

   10. Taylor expanded in t around 0 46.6%

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

   if -3.0000000000000002e-44 < t < 4.9000000000000001e32

   1. Initial program 85.6%

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

      1. associate-/l* 92.7%

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

   3. Simplified 92.7%

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

   4. Taylor expanded in z around inf 53.0%

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

      1. div-sub 54.5%

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

      2. associate-*r/ 50.4%

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

      3. associate-/l* 54.5%

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

   6. Simplified 54.5%

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

      1. associate-/r/ 56.2%

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

   8. Applied egg-rr 56.2%

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

   9. Taylor expanded in a around inf 47.0%

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

4. Final simplification 46.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.45 \cdot 10^{+51}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -3 \cdot 10^{-44}:\\ \;\;\;\;x + \frac{x \cdot t}{a}\\ \mathbf{elif}\;t \leq 4.9 \cdot 10^{+32}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \]

Alternative 15: 43.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -8.5 \cdot 10^{+138}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -7 \cdot 10^{-174}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;t \leq 2.3 \cdot 10^{+32}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -8.5e+138)
   y
   (if (<= t -7e-174)
     (- x (/ t (/ a y)))
     (if (<= t 2.3e+32) (* (- y x) (/ z a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -8.5e+138) {
		tmp = y;
	} else if (t <= -7e-174) {
		tmp = x - (t / (a / y));
	} else if (t <= 2.3e+32) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = 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 (t <= (-8.5d+138)) then
        tmp = y
    else if (t <= (-7d-174)) then
        tmp = x - (t / (a / y))
    else if (t <= 2.3d+32) then
        tmp = (y - x) * (z / a)
    else
        tmp = 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 (t <= -8.5e+138) {
		tmp = y;
	} else if (t <= -7e-174) {
		tmp = x - (t / (a / y));
	} else if (t <= 2.3e+32) {
		tmp = (y - x) * (z / a);
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -8.5e+138:
		tmp = y
	elif t <= -7e-174:
		tmp = x - (t / (a / y))
	elif t <= 2.3e+32:
		tmp = (y - x) * (z / a)
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -8.5e+138)
		tmp = y;
	elseif (t <= -7e-174)
		tmp = Float64(x - Float64(t / Float64(a / y)));
	elseif (t <= 2.3e+32)
		tmp = Float64(Float64(y - x) * Float64(z / a));
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -8.5e+138)
		tmp = y;
	elseif (t <= -7e-174)
		tmp = x - (t / (a / y));
	elseif (t <= 2.3e+32)
		tmp = (y - x) * (z / a);
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -8.5e+138], y, If[LessEqual[t, -7e-174], N[(x - N[(t / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.3e+32], N[(N[(y - x), $MachinePrecision] * N[(z / a), $MachinePrecision]), $MachinePrecision], y]]]

Derivation

1. Split input into 3 regimes

2. if t < -8.5000000000000006e138 or 2.3e32 < t

   1. Initial program 39.7%

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

      1. associate-/l* 64.6%

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

   3. Simplified 64.6%

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

   4. Taylor expanded in t around inf 49.5%

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

   if -8.5000000000000006e138 < t < -6.99999999999999975e-174

   1. Initial program 80.3%

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

      1. associate-/l* 90.9%

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

   3. Simplified 90.9%

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

   4. Taylor expanded in z around 0 49.4%

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

      1. mul-1-neg 49.4%

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

      2. unsub-neg 49.4%

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

      3. associate-/l* 59.0%

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

   6. Simplified 59.0%

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

   7. Taylor expanded in a around inf 46.7%

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

   8. Taylor expanded in y around inf 45.5%

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

   if -6.99999999999999975e-174 < t < 2.3e32

   1. Initial program 84.9%

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

      1. associate-/l* 93.3%

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

   3. Simplified 93.3%

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

   4. Taylor expanded in z around inf 55.1%

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

      1. div-sub 56.2%

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

      2. associate-*r/ 52.6%

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

      3. associate-/l* 56.2%

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

   6. Simplified 56.2%

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

      1. associate-/r/ 59.5%

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

   8. Applied egg-rr 59.5%

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

   9. Taylor expanded in a around inf 52.1%

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

4. Final simplification 49.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -8.5 \cdot 10^{+138}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -7 \cdot 10^{-174}:\\ \;\;\;\;x - \frac{t}{\frac{a}{y}}\\ \mathbf{elif}\;t \leq 2.3 \cdot 10^{+32}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \]

Alternative 16: 64.6% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= a -1.5e+41) (not (<= a 2.85e+27)))
   (+ x (/ z (/ a (- y x))))
   (* y (/ (- z t) (- a t)))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if (a <= -1.5e+41) or not (a <= 2.85e+27):
		tmp = x + (z / (a / (y - x)))
	else:
		tmp = y * ((z - t) / (a - t))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((a <= -1.5e+41) || !(a <= 2.85e+27))
		tmp = Float64(x + Float64(z / Float64(a / Float64(y - x))));
	else
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((a <= -1.5e+41) || ~((a <= 2.85e+27)))
		tmp = x + (z / (a / (y - x)));
	else
		tmp = y * ((z - t) / (a - t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -1.5e+41], N[Not[LessEqual[a, 2.85e+27]], $MachinePrecision]], N[(x + N[(z / N[(a / N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -1.4999999999999999e41 or 2.85000000000000002e27 < a

   1. Initial program 73.2%

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

      1. associate-/l* 92.2%

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

   3. Simplified 92.2%

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

   4. Taylor expanded in t around 0 64.4%

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

      1. associate-/l* 76.8%

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

   6. Simplified 76.8%

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

   if -1.4999999999999999e41 < a < 2.85000000000000002e27

   1. Initial program 67.6%

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

      1. associate-/l* 77.4%

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

   3. Simplified 77.4%

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

   4. Taylor expanded in x around 0 57.7%

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

      1. associate-*r/ 66.9%

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

   6. Simplified 66.9%

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

4. Final simplification 71.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.5 \cdot 10^{+41} \lor \neg \left(a \leq 2.85 \cdot 10^{+27}\right):\\ \;\;\;\;x + \frac{z}{\frac{a}{y - x}}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \end{array} \]

Alternative 17: 65.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= a -1.75e+40) (not (<= a 7.6e+27)))
   (+ x (/ (- y x) (/ a z)))
   (* y (/ (- z t) (- a t)))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if (a <= -1.75e+40) or not (a <= 7.6e+27):
		tmp = x + ((y - x) / (a / z))
	else:
		tmp = y * ((z - t) / (a - t))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((a <= -1.75e+40) || !(a <= 7.6e+27))
		tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z)));
	else
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((a <= -1.75e+40) || ~((a <= 7.6e+27)))
		tmp = x + ((y - x) / (a / z));
	else
		tmp = y * ((z - t) / (a - t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[a, -1.75e+40], N[Not[LessEqual[a, 7.6e+27]], $MachinePrecision]], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -1.75e40 or 7.60000000000000043e27 < a

   1. Initial program 73.2%

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

      1. associate-/l* 92.2%

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

   3. Simplified 92.2%

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

   4. Taylor expanded in t around 0 78.5%

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

   if -1.75e40 < a < 7.60000000000000043e27

   1. Initial program 67.6%

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

      1. associate-/l* 77.4%

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

   3. Simplified 77.4%

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

   4. Taylor expanded in x around 0 57.7%

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

      1. associate-*r/ 66.9%

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

   6. Simplified 66.9%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.75 \cdot 10^{+40} \lor \neg \left(a \leq 7.6 \cdot 10^{+27}\right):\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \end{array} \]

Alternative 18: 37.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -4.9 \cdot 10^{+58}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -8.2 \cdot 10^{-249}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 3.4 \cdot 10^{-20}:\\ \;\;\;\;\frac{y}{\frac{a}{z}}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -4.9e+58)
   y
   (if (<= t -8.2e-249) x (if (<= t 3.4e-20) (/ y (/ a z)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -4.9e+58) {
		tmp = y;
	} else if (t <= -8.2e-249) {
		tmp = x;
	} else if (t <= 3.4e-20) {
		tmp = y / (a / z);
	} else {
		tmp = 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 (t <= (-4.9d+58)) then
        tmp = y
    else if (t <= (-8.2d-249)) then
        tmp = x
    else if (t <= 3.4d-20) then
        tmp = y / (a / z)
    else
        tmp = 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 (t <= -4.9e+58) {
		tmp = y;
	} else if (t <= -8.2e-249) {
		tmp = x;
	} else if (t <= 3.4e-20) {
		tmp = y / (a / z);
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -4.9e+58:
		tmp = y
	elif t <= -8.2e-249:
		tmp = x
	elif t <= 3.4e-20:
		tmp = y / (a / z)
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -4.9e+58)
		tmp = y;
	elseif (t <= -8.2e-249)
		tmp = x;
	elseif (t <= 3.4e-20)
		tmp = Float64(y / Float64(a / z));
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -4.9e+58)
		tmp = y;
	elseif (t <= -8.2e-249)
		tmp = x;
	elseif (t <= 3.4e-20)
		tmp = y / (a / z);
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -4.9e+58], y, If[LessEqual[t, -8.2e-249], x, If[LessEqual[t, 3.4e-20], N[(y / N[(a / z), $MachinePrecision]), $MachinePrecision], y]]]

Derivation

1. Split input into 3 regimes

2. if t < -4.90000000000000018e58 or 3.3999999999999997e-20 < t

   1. Initial program 41.6%

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

      1. associate-/l* 69.1%

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

   3. Simplified 69.1%

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

   4. Taylor expanded in t around inf 44.1%

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

   if -4.90000000000000018e58 < t < -8.20000000000000007e-249

   1. Initial program 91.7%

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

      1. associate-/l* 93.9%

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

   3. Simplified 93.9%

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

   4. Taylor expanded in a around inf 36.9%

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

   if -8.20000000000000007e-249 < t < 3.3999999999999997e-20

   1. Initial program 86.3%

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

      1. associate-/l* 94.3%

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

   3. Simplified 94.3%

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

   4. Taylor expanded in z around inf 57.0%

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

      1. div-sub 57.0%

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

      2. associate-*r/ 53.1%

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

      3. associate-/l* 57.0%

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

   6. Simplified 57.0%

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

   7. Taylor expanded in y around inf 39.3%

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

      1. associate-/l* 43.9%

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

   9. Simplified 43.9%

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

   10. Taylor expanded in a around inf 36.5%

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

       1. associate-/l* 39.9%

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

   12. Simplified 39.9%

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

4. Final simplification 40.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -4.9 \cdot 10^{+58}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -8.2 \cdot 10^{-249}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 3.4 \cdot 10^{-20}:\\ \;\;\;\;\frac{y}{\frac{a}{z}}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \]

Alternative 19: 39.4% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -9.5 \cdot 10^{+73}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.22 \cdot 10^{+28}:\\ \;\;\;\;y\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -9.5e+73) x (if (<= a 1.22e+28) y x)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -9.5e+73) {
		tmp = x;
	} else if (a <= 1.22e+28) {
		tmp = y;
	} 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 <= (-9.5d+73)) then
        tmp = x
    else if (a <= 1.22d+28) then
        tmp = y
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -9.5e+73) {
		tmp = x;
	} else if (a <= 1.22e+28) {
		tmp = y;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -9.5e+73:
		tmp = x
	elif a <= 1.22e+28:
		tmp = y
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -9.5e+73)
		tmp = x;
	elseif (a <= 1.22e+28)
		tmp = y;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -9.5e+73)
		tmp = x;
	elseif (a <= 1.22e+28)
		tmp = y;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -9.5e+73], x, If[LessEqual[a, 1.22e+28], y, x]]

Derivation

1. Split input into 2 regimes

2. if a < -9.4999999999999996e73 or 1.2199999999999999e28 < a

   1. Initial program 74.5%

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

      1. associate-/l* 92.7%

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

   3. Simplified 92.7%

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

   4. Taylor expanded in a around inf 45.9%

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

   if -9.4999999999999996e73 < a < 1.2199999999999999e28

   1. Initial program 66.7%

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

      1. associate-/l* 77.5%

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

   3. Simplified 77.5%

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

   4. Taylor expanded in t around inf 35.7%

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

4. Final simplification 40.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -9.5 \cdot 10^{+73}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.22 \cdot 10^{+28}:\\ \;\;\;\;y\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 20: 25.9% accurate, 13.0× speedup

Math

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

FPCore

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

C

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

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
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 70.1%

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

   1. associate-/l* 84.0%

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

3. Simplified 84.0%

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

4. Taylor expanded in a around inf 23.4%

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

5. Final simplification 23.4%

   \[\leadsto x \]

Developer target: 86.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{y - x}{1} \cdot \frac{z - t}{a - t}\\ \mathbf{if}\;a < -1.6153062845442575 \cdot 10^{-142}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a < 3.774403170083174 \cdot 10^{-182}:\\ \;\;\;\;y - \frac{z}{t} \cdot \left(y - x\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))
   (if (< a -1.6153062845442575e-142)
     t_1
     (if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
	double tmp;
	if (a < -1.6153062845442575e-142) {
		tmp = t_1;
	} else if (a < 3.774403170083174e-182) {
		tmp = y - ((z / t) * (y - 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 = x + (((y - x) / 1.0d0) * ((z - t) / (a - t)))
    if (a < (-1.6153062845442575d-142)) then
        tmp = t_1
    else if (a < 3.774403170083174d-182) then
        tmp = y - ((z / t) * (y - x))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
	double tmp;
	if (a < -1.6153062845442575e-142) {
		tmp = t_1;
	} else if (a < 3.774403170083174e-182) {
		tmp = y - ((z / t) * (y - x));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)))
	tmp = 0
	if a < -1.6153062845442575e-142:
		tmp = t_1
	elif a < 3.774403170083174e-182:
		tmp = y - ((z / t) * (y - x))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(Float64(y - x) / 1.0) * Float64(Float64(z - t) / Float64(a - t))))
	tmp = 0.0
	if (a < -1.6153062845442575e-142)
		tmp = t_1;
	elseif (a < 3.774403170083174e-182)
		tmp = Float64(y - Float64(Float64(z / t) * Float64(y - x)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + (((y - x) / 1.0) * ((z - t) / (a - t)));
	tmp = 0.0;
	if (a < -1.6153062845442575e-142)
		tmp = t_1;
	elseif (a < 3.774403170083174e-182)
		tmp = y - ((z / t) * (y - x));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - x), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[a, -1.6153062845442575e-142], t$95$1, If[Less[a, 3.774403170083174e-182], N[(y - N[(N[(z / t), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Reproduce

herbie shell --seed 2023336 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
  :precision binary64

  :herbie-target
  (if (< a -1.6153062845442575e-142) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t)))) (if (< a 3.774403170083174e-182) (- y (* (/ z t) (- y x))) (+ x (* (/ (- y x) 1.0) (/ (- z t) (- a t))))))

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