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

Percentage Accurate: 68.5% → 87.2%

Time: 18.2s

Alternatives: 24

Speedup: 0.6×

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: 68.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: 87.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y - \frac{z - a}{\frac{t}{y - x}}\\ \mathbf{if}\;t \leq -6 \cdot 10^{+235}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.7 \cdot 10^{+54}:\\ \;\;\;\;x + \frac{y - x}{\frac{a - t}{z - t}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- y (/ (- z a) (/ t (- y x))))))
   (if (<= t -6e+235)
     t_1
     (if (<= t 2.7e+54) (+ x (/ (- y x) (/ (- a t) (- z t)))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y - ((z - a) / (t / (y - x)));
	double tmp;
	if (t <= -6e+235) {
		tmp = t_1;
	} else if (t <= 2.7e+54) {
		tmp = x + ((y - x) / ((a - t) / (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 = y - ((z - a) / (t / (y - x)))
    if (t <= (-6d+235)) then
        tmp = t_1
    else if (t <= 2.7d+54) then
        tmp = x + ((y - x) / ((a - t) / (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 = y - ((z - a) / (t / (y - x)));
	double tmp;
	if (t <= -6e+235) {
		tmp = t_1;
	} else if (t <= 2.7e+54) {
		tmp = x + ((y - x) / ((a - t) / (z - t)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y - ((z - a) / (t / (y - x)))
	tmp = 0
	if t <= -6e+235:
		tmp = t_1
	elif t <= 2.7e+54:
		tmp = x + ((y - x) / ((a - t) / (z - t)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y - Float64(Float64(z - a) / Float64(t / Float64(y - x))))
	tmp = 0.0
	if (t <= -6e+235)
		tmp = t_1;
	elseif (t <= 2.7e+54)
		tmp = Float64(x + Float64(Float64(y - x) / Float64(Float64(a - t) / Float64(z - t))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y - ((z - a) / (t / (y - x)));
	tmp = 0.0;
	if (t <= -6e+235)
		tmp = t_1;
	elseif (t <= 2.7e+54)
		tmp = x + ((y - x) / ((a - t) / (z - t)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if t < -6.00000000000000032e235 or 2.70000000000000011e54 < t

   1. Initial program 38.9%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -6.00000000000000032e235 < t < 2.70000000000000011e54

   1. Initial program 84.8%

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

   4. Applied egg-rr 0

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

Alternative 2: 55.0% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(z - t\right) \cdot \frac{y}{a - t}\\ t_2 := x + \frac{z \cdot y}{a}\\ t_3 := \left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{if}\;a \leq -3.6 \cdot 10^{+114}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;a \leq -1.05 \cdot 10^{-162}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -5 \cdot 10^{-226}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;a \leq 4.2 \cdot 10^{-234}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 4.2 \cdot 10^{-176}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;a \leq 6.2 \cdot 10^{+155}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq 10^{+219}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* (- z t) (/ y (- a t))))
        (t_2 (+ x (/ (* z y) a)))
        (t_3 (* (- y x) (/ z (- a t)))))
   (if (<= a -3.6e+114)
     t_2
     (if (<= a -1.05e-162)
       t_1
       (if (<= a -5e-226)
         t_3
         (if (<= a 4.2e-234)
           (* (- (/ (- z t) t)) y)
           (if (<= a 4.2e-176)
             t_3
             (if (<= a 6.2e+155)
               t_1
               (if (<= a 1e+219) (* x (- 1.0 (/ z a))) t_2)))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = (z - t) * (y / (a - t));
	double t_2 = x + ((z * y) / a);
	double t_3 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -3.6e+114) {
		tmp = t_2;
	} else if (a <= -1.05e-162) {
		tmp = t_1;
	} else if (a <= -5e-226) {
		tmp = t_3;
	} else if (a <= 4.2e-234) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 4.2e-176) {
		tmp = t_3;
	} else if (a <= 6.2e+155) {
		tmp = t_1;
	} else if (a <= 1e+219) {
		tmp = x * (1.0 - (z / a));
	} 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) :: t_3
    real(8) :: tmp
    t_1 = (z - t) * (y / (a - t))
    t_2 = x + ((z * y) / a)
    t_3 = (y - x) * (z / (a - t))
    if (a <= (-3.6d+114)) then
        tmp = t_2
    else if (a <= (-1.05d-162)) then
        tmp = t_1
    else if (a <= (-5d-226)) then
        tmp = t_3
    else if (a <= 4.2d-234) then
        tmp = -((z - t) / t) * y
    else if (a <= 4.2d-176) then
        tmp = t_3
    else if (a <= 6.2d+155) then
        tmp = t_1
    else if (a <= 1d+219) then
        tmp = x * (1.0d0 - (z / a))
    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 = (z - t) * (y / (a - t));
	double t_2 = x + ((z * y) / a);
	double t_3 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -3.6e+114) {
		tmp = t_2;
	} else if (a <= -1.05e-162) {
		tmp = t_1;
	} else if (a <= -5e-226) {
		tmp = t_3;
	} else if (a <= 4.2e-234) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 4.2e-176) {
		tmp = t_3;
	} else if (a <= 6.2e+155) {
		tmp = t_1;
	} else if (a <= 1e+219) {
		tmp = x * (1.0 - (z / a));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = (z - t) * (y / (a - t))
	t_2 = x + ((z * y) / a)
	t_3 = (y - x) * (z / (a - t))
	tmp = 0
	if a <= -3.6e+114:
		tmp = t_2
	elif a <= -1.05e-162:
		tmp = t_1
	elif a <= -5e-226:
		tmp = t_3
	elif a <= 4.2e-234:
		tmp = -((z - t) / t) * y
	elif a <= 4.2e-176:
		tmp = t_3
	elif a <= 6.2e+155:
		tmp = t_1
	elif a <= 1e+219:
		tmp = x * (1.0 - (z / a))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(z - t) * Float64(y / Float64(a - t)))
	t_2 = Float64(x + Float64(Float64(z * y) / a))
	t_3 = Float64(Float64(y - x) * Float64(z / Float64(a - t)))
	tmp = 0.0
	if (a <= -3.6e+114)
		tmp = t_2;
	elseif (a <= -1.05e-162)
		tmp = t_1;
	elseif (a <= -5e-226)
		tmp = t_3;
	elseif (a <= 4.2e-234)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 4.2e-176)
		tmp = t_3;
	elseif (a <= 6.2e+155)
		tmp = t_1;
	elseif (a <= 1e+219)
		tmp = Float64(x * Float64(1.0 - Float64(z / a)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = (z - t) * (y / (a - t));
	t_2 = x + ((z * y) / a);
	t_3 = (y - x) * (z / (a - t));
	tmp = 0.0;
	if (a <= -3.6e+114)
		tmp = t_2;
	elseif (a <= -1.05e-162)
		tmp = t_1;
	elseif (a <= -5e-226)
		tmp = t_3;
	elseif (a <= 4.2e-234)
		tmp = -((z - t) / t) * y;
	elseif (a <= 4.2e-176)
		tmp = t_3;
	elseif (a <= 6.2e+155)
		tmp = t_1;
	elseif (a <= 1e+219)
		tmp = x * (1.0 - (z / a));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.6e+114], t$95$2, If[LessEqual[a, -1.05e-162], t$95$1, If[LessEqual[a, -5e-226], t$95$3, If[LessEqual[a, 4.2e-234], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 4.2e-176], t$95$3, If[LessEqual[a, 6.2e+155], t$95$1, If[LessEqual[a, 1e+219], N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if a < -3.6000000000000001e114 or 9.99999999999999965e218 < a

   1. Initial program 79.3%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -3.6000000000000001e114 < a < -1.05e-162 or 4.19999999999999984e-176 < a < 6.19999999999999978e155

   1. Initial program 71.4%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.05e-162 < a < -4.9999999999999998e-226 or 4.19999999999999982e-234 < a < 4.19999999999999984e-176

   1. Initial program 86.2%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.9999999999999998e-226 < a < 4.19999999999999982e-234

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 6.19999999999999978e155 < a < 9.99999999999999965e218

   1. Initial program 71.6%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 3: 60.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(x - y\right) \cdot \left(\frac{z}{t} + -1\right)\\ t_2 := x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{if}\;a \leq -350:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;a \leq -1.4 \cdot 10^{-162}:\\ \;\;\;\;\frac{y \cdot \left(z - t\right)}{a - t}\\ \mathbf{elif}\;a \leq -3 \cdot 10^{-225}:\\ \;\;\;\;\frac{z \cdot \left(y - x\right)}{a - t}\\ \mathbf{elif}\;a \leq 1.45 \cdot 10^{-86}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq 4000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;a \leq 9 \cdot 10^{+56}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \left(x - y\right) \cdot \frac{t}{a - t}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (- x y) (+ (/ z t) -1.0))))
        (t_2 (+ x (/ (- y x) (/ a z)))))
   (if (<= a -350.0)
     t_2
     (if (<= a -1.4e-162)
       (/ (* y (- z t)) (- a t))
       (if (<= a -3e-225)
         (/ (* z (- y x)) (- a t))
         (if (<= a 1.45e-86)
           t_1
           (if (<= a 4000000000000.0)
             t_2
             (if (<= a 9e+56) t_1 (+ x (* (- x y) (/ t (- a t))))))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((x - y) * ((z / t) + -1.0));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -350.0) {
		tmp = t_2;
	} else if (a <= -1.4e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -3e-225) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 1.45e-86) {
		tmp = t_1;
	} else if (a <= 4000000000000.0) {
		tmp = t_2;
	} else if (a <= 9e+56) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + ((x - y) * ((z / t) + (-1.0d0)))
    t_2 = x + ((y - x) / (a / z))
    if (a <= (-350.0d0)) then
        tmp = t_2
    else if (a <= (-1.4d-162)) then
        tmp = (y * (z - t)) / (a - t)
    else if (a <= (-3d-225)) then
        tmp = (z * (y - x)) / (a - t)
    else if (a <= 1.45d-86) then
        tmp = t_1
    else if (a <= 4000000000000.0d0) then
        tmp = t_2
    else if (a <= 9d+56) then
        tmp = t_1
    else
        tmp = x + ((x - y) * (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 t_1 = x + ((x - y) * ((z / t) + -1.0));
	double t_2 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -350.0) {
		tmp = t_2;
	} else if (a <= -1.4e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -3e-225) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 1.45e-86) {
		tmp = t_1;
	} else if (a <= 4000000000000.0) {
		tmp = t_2;
	} else if (a <= 9e+56) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (t / (a - t)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + ((x - y) * ((z / t) + -1.0))
	t_2 = x + ((y - x) / (a / z))
	tmp = 0
	if a <= -350.0:
		tmp = t_2
	elif a <= -1.4e-162:
		tmp = (y * (z - t)) / (a - t)
	elif a <= -3e-225:
		tmp = (z * (y - x)) / (a - t)
	elif a <= 1.45e-86:
		tmp = t_1
	elif a <= 4000000000000.0:
		tmp = t_2
	elif a <= 9e+56:
		tmp = t_1
	else:
		tmp = x + ((x - y) * (t / (a - t)))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(x - y) * Float64(Float64(z / t) + -1.0)))
	t_2 = Float64(x + Float64(Float64(y - x) / Float64(a / z)))
	tmp = 0.0
	if (a <= -350.0)
		tmp = t_2;
	elseif (a <= -1.4e-162)
		tmp = Float64(Float64(y * Float64(z - t)) / Float64(a - t));
	elseif (a <= -3e-225)
		tmp = Float64(Float64(z * Float64(y - x)) / Float64(a - t));
	elseif (a <= 1.45e-86)
		tmp = t_1;
	elseif (a <= 4000000000000.0)
		tmp = t_2;
	elseif (a <= 9e+56)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(Float64(x - y) * Float64(t / Float64(a - t))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + ((x - y) * ((z / t) + -1.0));
	t_2 = x + ((y - x) / (a / z));
	tmp = 0.0;
	if (a <= -350.0)
		tmp = t_2;
	elseif (a <= -1.4e-162)
		tmp = (y * (z - t)) / (a - t);
	elseif (a <= -3e-225)
		tmp = (z * (y - x)) / (a - t);
	elseif (a <= 1.45e-86)
		tmp = t_1;
	elseif (a <= 4000000000000.0)
		tmp = t_2;
	elseif (a <= 9e+56)
		tmp = t_1;
	else
		tmp = x + ((x - y) * (t / (a - t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(x - y), $MachinePrecision] * N[(N[(z / t), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -350.0], t$95$2, If[LessEqual[a, -1.4e-162], N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -3e-225], N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.45e-86], t$95$1, If[LessEqual[a, 4000000000000.0], t$95$2, If[LessEqual[a, 9e+56], t$95$1, N[(x + N[(N[(x - y), $MachinePrecision] * N[(t / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if a < -350 or 1.45e-86 < a < 4e12

   1. Initial program 76.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -350 < a < -1.40000000000000011e-162

   1. Initial program 71.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.40000000000000011e-162 < a < -3.00000000000000018e-225

   1. Initial program 88.1%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.00000000000000018e-225 < a < 1.45e-86 or 4e12 < a < 9.0000000000000006e56

   1. Initial program 69.5%

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

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 9.0000000000000006e56 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 4: 60.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{if}\;a \leq -1650:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -1.1 \cdot 10^{-162}:\\ \;\;\;\;\frac{y \cdot \left(z - t\right)}{a - t}\\ \mathbf{elif}\;a \leq -3 \cdot 10^{-225}:\\ \;\;\;\;\frac{z \cdot \left(y - x\right)}{a - t}\\ \mathbf{elif}\;a \leq 6 \cdot 10^{-108}:\\ \;\;\;\;x + \left(x - y\right) \cdot \left(\frac{z}{t} + -1\right)\\ \mathbf{elif}\;a \leq 6.5 \cdot 10^{+158}:\\ \;\;\;\;\left(z - t\right) \cdot \frac{y}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (/ (- y x) (/ a z)))))
   (if (<= a -1650.0)
     t_1
     (if (<= a -1.1e-162)
       (/ (* y (- z t)) (- a t))
       (if (<= a -3e-225)
         (/ (* z (- y x)) (- a t))
         (if (<= a 6e-108)
           (+ x (* (- x y) (+ (/ z t) -1.0)))
           (if (<= a 6.5e+158) (* (- z t) (/ y (- a t))) t_1)))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((y - x) / (a / z));
	double tmp;
	if (a <= -1650.0) {
		tmp = t_1;
	} else if (a <= -1.1e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -3e-225) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 6e-108) {
		tmp = x + ((x - y) * ((z / t) + -1.0));
	} else if (a <= 6.5e+158) {
		tmp = (z - t) * (y / (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 + ((y - x) / (a / z))
    if (a <= (-1650.0d0)) then
        tmp = t_1
    else if (a <= (-1.1d-162)) then
        tmp = (y * (z - t)) / (a - t)
    else if (a <= (-3d-225)) then
        tmp = (z * (y - x)) / (a - t)
    else if (a <= 6d-108) then
        tmp = x + ((x - y) * ((z / t) + (-1.0d0)))
    else if (a <= 6.5d+158) then
        tmp = (z - t) * (y / (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 + ((y - x) / (a / z));
	double tmp;
	if (a <= -1650.0) {
		tmp = t_1;
	} else if (a <= -1.1e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -3e-225) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 6e-108) {
		tmp = x + ((x - y) * ((z / t) + -1.0));
	} else if (a <= 6.5e+158) {
		tmp = (z - t) * (y / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + ((y - x) / (a / z))
	tmp = 0
	if a <= -1650.0:
		tmp = t_1
	elif a <= -1.1e-162:
		tmp = (y * (z - t)) / (a - t)
	elif a <= -3e-225:
		tmp = (z * (y - x)) / (a - t)
	elif a <= 6e-108:
		tmp = x + ((x - y) * ((z / t) + -1.0))
	elif a <= 6.5e+158:
		tmp = (z - t) * (y / (a - t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(y - x) / Float64(a / z)))
	tmp = 0.0
	if (a <= -1650.0)
		tmp = t_1;
	elseif (a <= -1.1e-162)
		tmp = Float64(Float64(y * Float64(z - t)) / Float64(a - t));
	elseif (a <= -3e-225)
		tmp = Float64(Float64(z * Float64(y - x)) / Float64(a - t));
	elseif (a <= 6e-108)
		tmp = Float64(x + Float64(Float64(x - y) * Float64(Float64(z / t) + -1.0)));
	elseif (a <= 6.5e+158)
		tmp = Float64(Float64(z - t) * Float64(y / Float64(a - t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + ((y - x) / (a / z));
	tmp = 0.0;
	if (a <= -1650.0)
		tmp = t_1;
	elseif (a <= -1.1e-162)
		tmp = (y * (z - t)) / (a - t);
	elseif (a <= -3e-225)
		tmp = (z * (y - x)) / (a - t);
	elseif (a <= 6e-108)
		tmp = x + ((x - y) * ((z / t) + -1.0));
	elseif (a <= 6.5e+158)
		tmp = (z - t) * (y / (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[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1650.0], t$95$1, If[LessEqual[a, -1.1e-162], N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -3e-225], N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6e-108], N[(x + N[(N[(x - y), $MachinePrecision] * N[(N[(z / t), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 6.5e+158], N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if a < -1650 or 6.5000000000000001e158 < a

   1. Initial program 79.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1650 < a < -1.1e-162

   1. Initial program 71.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.1e-162 < a < -3.00000000000000018e-225

   1. Initial program 88.1%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.00000000000000018e-225 < a < 5.99999999999999986e-108

   1. Initial program 71.3%

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

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 5.99999999999999986e-108 < a < 6.5000000000000001e158

   1. Initial program 65.0%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 5: 58.1% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -350:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{elif}\;a \leq -1.08 \cdot 10^{-162}:\\ \;\;\;\;\frac{y \cdot \left(z - t\right)}{a - t}\\ \mathbf{elif}\;a \leq -7.5 \cdot 10^{-226}:\\ \;\;\;\;\frac{z \cdot \left(y - x\right)}{a - t}\\ \mathbf{elif}\;a \leq 8.2 \cdot 10^{-231}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 3.7 \cdot 10^{+61}:\\ \;\;\;\;\left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{else}:\\ \;\;\;\;x + \left(x - y\right) \cdot \frac{t}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -350.0)
   (+ x (/ (- y x) (/ a z)))
   (if (<= a -1.08e-162)
     (/ (* y (- z t)) (- a t))
     (if (<= a -7.5e-226)
       (/ (* z (- y x)) (- a t))
       (if (<= a 8.2e-231)
         (* (- (/ (- z t) t)) y)
         (if (<= a 3.7e+61)
           (* (- y x) (/ z (- a t)))
           (+ x (* (- x y) (/ t a)))))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -350.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.08e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -7.5e-226) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 8.2e-231) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 3.7e+61) {
		tmp = (y - x) * (z / (a - t));
	} else {
		tmp = x + ((x - y) * (t / 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 (a <= (-350.0d0)) then
        tmp = x + ((y - x) / (a / z))
    else if (a <= (-1.08d-162)) then
        tmp = (y * (z - t)) / (a - t)
    else if (a <= (-7.5d-226)) then
        tmp = (z * (y - x)) / (a - t)
    else if (a <= 8.2d-231) then
        tmp = -((z - t) / t) * y
    else if (a <= 3.7d+61) then
        tmp = (y - x) * (z / (a - t))
    else
        tmp = x + ((x - y) * (t / 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 (a <= -350.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.08e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -7.5e-226) {
		tmp = (z * (y - x)) / (a - t);
	} else if (a <= 8.2e-231) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 3.7e+61) {
		tmp = (y - x) * (z / (a - t));
	} else {
		tmp = x + ((x - y) * (t / a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -350.0:
		tmp = x + ((y - x) / (a / z))
	elif a <= -1.08e-162:
		tmp = (y * (z - t)) / (a - t)
	elif a <= -7.5e-226:
		tmp = (z * (y - x)) / (a - t)
	elif a <= 8.2e-231:
		tmp = -((z - t) / t) * y
	elif a <= 3.7e+61:
		tmp = (y - x) * (z / (a - t))
	else:
		tmp = x + ((x - y) * (t / a))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -350.0)
		tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z)));
	elseif (a <= -1.08e-162)
		tmp = Float64(Float64(y * Float64(z - t)) / Float64(a - t));
	elseif (a <= -7.5e-226)
		tmp = Float64(Float64(z * Float64(y - x)) / Float64(a - t));
	elseif (a <= 8.2e-231)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 3.7e+61)
		tmp = Float64(Float64(y - x) * Float64(z / Float64(a - t)));
	else
		tmp = Float64(x + Float64(Float64(x - y) * Float64(t / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -350.0)
		tmp = x + ((y - x) / (a / z));
	elseif (a <= -1.08e-162)
		tmp = (y * (z - t)) / (a - t);
	elseif (a <= -7.5e-226)
		tmp = (z * (y - x)) / (a - t);
	elseif (a <= 8.2e-231)
		tmp = -((z - t) / t) * y;
	elseif (a <= 3.7e+61)
		tmp = (y - x) * (z / (a - t));
	else
		tmp = x + ((x - y) * (t / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -350.0], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.08e-162], N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7.5e-226], N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 8.2e-231], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 3.7e+61], N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(x - y), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 6 regimes

2. if a < -350

   1. Initial program 77.9%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -350 < a < -1.08000000000000006e-162

   1. Initial program 71.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.08000000000000006e-162 < a < -7.50000000000000044e-226

   1. Initial program 88.1%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.50000000000000044e-226 < a < 8.2000000000000003e-231

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 8.2000000000000003e-231 < a < 3.70000000000000003e61

   1. Initial program 72.4%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 3.70000000000000003e61 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 6: 58.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{if}\;a \leq -940:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{elif}\;a \leq -1.7 \cdot 10^{-162}:\\ \;\;\;\;\frac{y \cdot \left(z - t\right)}{a - t}\\ \mathbf{elif}\;a \leq -7.8 \cdot 10^{-226}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq 8.5 \cdot 10^{-235}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 7.5 \cdot 10^{+62}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \left(x - y\right) \cdot \frac{t}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* (- y x) (/ z (- a t)))))
   (if (<= a -940.0)
     (+ x (/ (- y x) (/ a z)))
     (if (<= a -1.7e-162)
       (/ (* y (- z t)) (- a t))
       (if (<= a -7.8e-226)
         t_1
         (if (<= a 8.5e-235)
           (* (- (/ (- z t) t)) y)
           (if (<= a 7.5e+62) t_1 (+ x (* (- x y) (/ t a))))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -940.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.7e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -7.8e-226) {
		tmp = t_1;
	} else if (a <= 8.5e-235) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 7.5e+62) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (t / 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) :: t_1
    real(8) :: tmp
    t_1 = (y - x) * (z / (a - t))
    if (a <= (-940.0d0)) then
        tmp = x + ((y - x) / (a / z))
    else if (a <= (-1.7d-162)) then
        tmp = (y * (z - t)) / (a - t)
    else if (a <= (-7.8d-226)) then
        tmp = t_1
    else if (a <= 8.5d-235) then
        tmp = -((z - t) / t) * y
    else if (a <= 7.5d+62) then
        tmp = t_1
    else
        tmp = x + ((x - y) * (t / a))
    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 - x) * (z / (a - t));
	double tmp;
	if (a <= -940.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.7e-162) {
		tmp = (y * (z - t)) / (a - t);
	} else if (a <= -7.8e-226) {
		tmp = t_1;
	} else if (a <= 8.5e-235) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 7.5e+62) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (t / a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = (y - x) * (z / (a - t))
	tmp = 0
	if a <= -940.0:
		tmp = x + ((y - x) / (a / z))
	elif a <= -1.7e-162:
		tmp = (y * (z - t)) / (a - t)
	elif a <= -7.8e-226:
		tmp = t_1
	elif a <= 8.5e-235:
		tmp = -((z - t) / t) * y
	elif a <= 7.5e+62:
		tmp = t_1
	else:
		tmp = x + ((x - y) * (t / a))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(y - x) * Float64(z / Float64(a - t)))
	tmp = 0.0
	if (a <= -940.0)
		tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z)));
	elseif (a <= -1.7e-162)
		tmp = Float64(Float64(y * Float64(z - t)) / Float64(a - t));
	elseif (a <= -7.8e-226)
		tmp = t_1;
	elseif (a <= 8.5e-235)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 7.5e+62)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(Float64(x - y) * Float64(t / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = (y - x) * (z / (a - t));
	tmp = 0.0;
	if (a <= -940.0)
		tmp = x + ((y - x) / (a / z));
	elseif (a <= -1.7e-162)
		tmp = (y * (z - t)) / (a - t);
	elseif (a <= -7.8e-226)
		tmp = t_1;
	elseif (a <= 8.5e-235)
		tmp = -((z - t) / t) * y;
	elseif (a <= 7.5e+62)
		tmp = t_1;
	else
		tmp = x + ((x - y) * (t / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -940.0], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.7e-162], N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7.8e-226], t$95$1, If[LessEqual[a, 8.5e-235], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 7.5e+62], t$95$1, N[(x + N[(N[(x - y), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if a < -940

   1. Initial program 77.9%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -940 < a < -1.7e-162

   1. Initial program 71.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.7e-162 < a < -7.7999999999999995e-226 or 8.49999999999999964e-235 < a < 7.49999999999999998e62

   1. Initial program 75.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -7.7999999999999995e-226 < a < 8.49999999999999964e-235

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 7.49999999999999998e62 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 7: 58.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{if}\;a \leq -68:\\ \;\;\;\;x + \frac{y - x}{\frac{a}{z}}\\ \mathbf{elif}\;a \leq -1.55 \cdot 10^{-162}:\\ \;\;\;\;\left(z - t\right) \cdot \frac{y}{a - t}\\ \mathbf{elif}\;a \leq -2.5 \cdot 10^{-225}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq 5.8 \cdot 10^{-230}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 7.2 \cdot 10^{+63}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \left(x - y\right) \cdot \frac{t}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* (- y x) (/ z (- a t)))))
   (if (<= a -68.0)
     (+ x (/ (- y x) (/ a z)))
     (if (<= a -1.55e-162)
       (* (- z t) (/ y (- a t)))
       (if (<= a -2.5e-225)
         t_1
         (if (<= a 5.8e-230)
           (* (- (/ (- z t) t)) y)
           (if (<= a 7.2e+63) t_1 (+ x (* (- x y) (/ t a))))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -68.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.55e-162) {
		tmp = (z - t) * (y / (a - t));
	} else if (a <= -2.5e-225) {
		tmp = t_1;
	} else if (a <= 5.8e-230) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 7.2e+63) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (t / 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) :: t_1
    real(8) :: tmp
    t_1 = (y - x) * (z / (a - t))
    if (a <= (-68.0d0)) then
        tmp = x + ((y - x) / (a / z))
    else if (a <= (-1.55d-162)) then
        tmp = (z - t) * (y / (a - t))
    else if (a <= (-2.5d-225)) then
        tmp = t_1
    else if (a <= 5.8d-230) then
        tmp = -((z - t) / t) * y
    else if (a <= 7.2d+63) then
        tmp = t_1
    else
        tmp = x + ((x - y) * (t / a))
    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 - x) * (z / (a - t));
	double tmp;
	if (a <= -68.0) {
		tmp = x + ((y - x) / (a / z));
	} else if (a <= -1.55e-162) {
		tmp = (z - t) * (y / (a - t));
	} else if (a <= -2.5e-225) {
		tmp = t_1;
	} else if (a <= 5.8e-230) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 7.2e+63) {
		tmp = t_1;
	} else {
		tmp = x + ((x - y) * (t / a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = (y - x) * (z / (a - t))
	tmp = 0
	if a <= -68.0:
		tmp = x + ((y - x) / (a / z))
	elif a <= -1.55e-162:
		tmp = (z - t) * (y / (a - t))
	elif a <= -2.5e-225:
		tmp = t_1
	elif a <= 5.8e-230:
		tmp = -((z - t) / t) * y
	elif a <= 7.2e+63:
		tmp = t_1
	else:
		tmp = x + ((x - y) * (t / a))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(y - x) * Float64(z / Float64(a - t)))
	tmp = 0.0
	if (a <= -68.0)
		tmp = Float64(x + Float64(Float64(y - x) / Float64(a / z)));
	elseif (a <= -1.55e-162)
		tmp = Float64(Float64(z - t) * Float64(y / Float64(a - t)));
	elseif (a <= -2.5e-225)
		tmp = t_1;
	elseif (a <= 5.8e-230)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 7.2e+63)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(Float64(x - y) * Float64(t / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = (y - x) * (z / (a - t));
	tmp = 0.0;
	if (a <= -68.0)
		tmp = x + ((y - x) / (a / z));
	elseif (a <= -1.55e-162)
		tmp = (z - t) * (y / (a - t));
	elseif (a <= -2.5e-225)
		tmp = t_1;
	elseif (a <= 5.8e-230)
		tmp = -((z - t) / t) * y;
	elseif (a <= 7.2e+63)
		tmp = t_1;
	else
		tmp = x + ((x - y) * (t / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -68.0], N[(x + N[(N[(y - x), $MachinePrecision] / N[(a / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.55e-162], N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.5e-225], t$95$1, If[LessEqual[a, 5.8e-230], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 7.2e+63], t$95$1, N[(x + N[(N[(x - y), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if a < -68

   1. Initial program 77.9%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -68 < a < -1.5499999999999999e-162

   1. Initial program 71.6%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.5499999999999999e-162 < a < -2.5e-225 or 5.80000000000000011e-230 < a < 7.19999999999999998e63

   1. Initial program 75.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -2.5e-225 < a < 5.80000000000000011e-230

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 7.19999999999999998e63 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 8: 55.3% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(x - y\right) \cdot \frac{t}{a}\\ t_2 := \left(y - x\right) \cdot \frac{z}{a - t}\\ \mathbf{if}\;a \leq -4.6 \cdot 10^{+187}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -1.76 \cdot 10^{-162}:\\ \;\;\;\;\left(z - t\right) \cdot \frac{y}{a - t}\\ \mathbf{elif}\;a \leq -2.6 \cdot 10^{-225}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;a \leq 1.65 \cdot 10^{-233}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 1.1 \cdot 10^{+64}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (- x y) (/ t a)))) (t_2 (* (- y x) (/ z (- a t)))))
   (if (<= a -4.6e+187)
     t_1
     (if (<= a -1.76e-162)
       (* (- z t) (/ y (- a t)))
       (if (<= a -2.6e-225)
         t_2
         (if (<= a 1.65e-233)
           (* (- (/ (- z t) t)) y)
           (if (<= a 1.1e+64) t_2 t_1)))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((x - y) * (t / a));
	double t_2 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -4.6e+187) {
		tmp = t_1;
	} else if (a <= -1.76e-162) {
		tmp = (z - t) * (y / (a - t));
	} else if (a <= -2.6e-225) {
		tmp = t_2;
	} else if (a <= 1.65e-233) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 1.1e+64) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: tmp
    t_1 = x + ((x - y) * (t / a))
    t_2 = (y - x) * (z / (a - t))
    if (a <= (-4.6d+187)) then
        tmp = t_1
    else if (a <= (-1.76d-162)) then
        tmp = (z - t) * (y / (a - t))
    else if (a <= (-2.6d-225)) then
        tmp = t_2
    else if (a <= 1.65d-233) then
        tmp = -((z - t) / t) * y
    else if (a <= 1.1d+64) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((x - y) * (t / a));
	double t_2 = (y - x) * (z / (a - t));
	double tmp;
	if (a <= -4.6e+187) {
		tmp = t_1;
	} else if (a <= -1.76e-162) {
		tmp = (z - t) * (y / (a - t));
	} else if (a <= -2.6e-225) {
		tmp = t_2;
	} else if (a <= 1.65e-233) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 1.1e+64) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + ((x - y) * (t / a))
	t_2 = (y - x) * (z / (a - t))
	tmp = 0
	if a <= -4.6e+187:
		tmp = t_1
	elif a <= -1.76e-162:
		tmp = (z - t) * (y / (a - t))
	elif a <= -2.6e-225:
		tmp = t_2
	elif a <= 1.65e-233:
		tmp = -((z - t) / t) * y
	elif a <= 1.1e+64:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(x - y) * Float64(t / a)))
	t_2 = Float64(Float64(y - x) * Float64(z / Float64(a - t)))
	tmp = 0.0
	if (a <= -4.6e+187)
		tmp = t_1;
	elseif (a <= -1.76e-162)
		tmp = Float64(Float64(z - t) * Float64(y / Float64(a - t)));
	elseif (a <= -2.6e-225)
		tmp = t_2;
	elseif (a <= 1.65e-233)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 1.1e+64)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + ((x - y) * (t / a));
	t_2 = (y - x) * (z / (a - t));
	tmp = 0.0;
	if (a <= -4.6e+187)
		tmp = t_1;
	elseif (a <= -1.76e-162)
		tmp = (z - t) * (y / (a - t));
	elseif (a <= -2.6e-225)
		tmp = t_2;
	elseif (a <= 1.65e-233)
		tmp = -((z - t) / t) * y;
	elseif (a <= 1.1e+64)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(x - y), $MachinePrecision] * N[(t / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.6e+187], t$95$1, If[LessEqual[a, -1.76e-162], N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.6e-225], t$95$2, If[LessEqual[a, 1.65e-233], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 1.1e+64], t$95$2, t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -4.60000000000000008e187 or 1.10000000000000001e64 < a

   1. Initial program 76.1%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -4.60000000000000008e187 < a < -1.76000000000000009e-162

   1. Initial program 75.0%

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

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.76000000000000009e-162 < a < -2.60000000000000013e-225 or 1.65e-233 < a < 1.10000000000000001e64

   1. Initial program 75.9%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -2.60000000000000013e-225 < a < 1.65e-233

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

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

Alternative 9: 55.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(y - x\right) \cdot \frac{z}{a - t}\\ t_2 := x + \frac{z \cdot y}{a}\\ \mathbf{if}\;a \leq -2.6 \cdot 10^{-5}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;a \leq -5.5 \cdot 10^{-226}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq 5 \cdot 10^{-231}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{elif}\;a \leq 9.8 \cdot 10^{+104}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* (- y x) (/ z (- a t)))) (t_2 (+ x (/ (* z y) a))))
   (if (<= a -2.6e-5)
     t_2
     (if (<= a -5.5e-226)
       t_1
       (if (<= a 5e-231)
         (* (- (/ (- z t) t)) y)
         (if (<= a 9.8e+104) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = (y - x) * (z / (a - t));
	double t_2 = x + ((z * y) / a);
	double tmp;
	if (a <= -2.6e-5) {
		tmp = t_2;
	} else if (a <= -5.5e-226) {
		tmp = t_1;
	} else if (a <= 5e-231) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 9.8e+104) {
		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 - x) * (z / (a - t))
    t_2 = x + ((z * y) / a)
    if (a <= (-2.6d-5)) then
        tmp = t_2
    else if (a <= (-5.5d-226)) then
        tmp = t_1
    else if (a <= 5d-231) then
        tmp = -((z - t) / t) * y
    else if (a <= 9.8d+104) 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 - x) * (z / (a - t));
	double t_2 = x + ((z * y) / a);
	double tmp;
	if (a <= -2.6e-5) {
		tmp = t_2;
	} else if (a <= -5.5e-226) {
		tmp = t_1;
	} else if (a <= 5e-231) {
		tmp = -((z - t) / t) * y;
	} else if (a <= 9.8e+104) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = (y - x) * (z / (a - t))
	t_2 = x + ((z * y) / a)
	tmp = 0
	if a <= -2.6e-5:
		tmp = t_2
	elif a <= -5.5e-226:
		tmp = t_1
	elif a <= 5e-231:
		tmp = -((z - t) / t) * y
	elif a <= 9.8e+104:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(y - x) * Float64(z / Float64(a - t)))
	t_2 = Float64(x + Float64(Float64(z * y) / a))
	tmp = 0.0
	if (a <= -2.6e-5)
		tmp = t_2;
	elseif (a <= -5.5e-226)
		tmp = t_1;
	elseif (a <= 5e-231)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	elseif (a <= 9.8e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = (y - x) * (z / (a - t));
	t_2 = x + ((z * y) / a);
	tmp = 0.0;
	if (a <= -2.6e-5)
		tmp = t_2;
	elseif (a <= -5.5e-226)
		tmp = t_1;
	elseif (a <= 5e-231)
		tmp = -((z - t) / t) * y;
	elseif (a <= 9.8e+104)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - x), $MachinePrecision] * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.6e-5], t$95$2, If[LessEqual[a, -5.5e-226], t$95$1, If[LessEqual[a, 5e-231], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], If[LessEqual[a, 9.8e+104], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -2.59999999999999984e-5 or 9.7999999999999997e104 < a

   1. Initial program 78.4%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.59999999999999984e-5 < a < -5.5e-226 or 5.00000000000000023e-231 < a < 9.7999999999999997e104

   1. Initial program 73.2%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -5.5e-226 < a < 5.00000000000000023e-231

   1. Initial program 66.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

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

Alternative 10: 49.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{if}\;a \leq -0.000125:\\ \;\;\;\;x + \frac{z \cdot y}{a}\\ \mathbf{elif}\;a \leq -3.6 \cdot 10^{-166}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -2.8 \cdot 10^{-225}:\\ \;\;\;\;\frac{z \cdot \left(y - x\right)}{-t}\\ \mathbf{elif}\;a \leq 4.1 \cdot 10^{+155}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* (- (/ (- z t) t)) y)))
   (if (<= a -0.000125)
     (+ x (/ (* z y) a))
     (if (<= a -3.6e-166)
       t_1
       (if (<= a -2.8e-225)
         (/ (* z (- y x)) (- t))
         (if (<= a 4.1e+155) t_1 (* x (- 1.0 (/ z a)))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = -((z - t) / t) * y;
	double tmp;
	if (a <= -0.000125) {
		tmp = x + ((z * y) / a);
	} else if (a <= -3.6e-166) {
		tmp = t_1;
	} else if (a <= -2.8e-225) {
		tmp = (z * (y - x)) / -t;
	} else if (a <= 4.1e+155) {
		tmp = t_1;
	} else {
		tmp = x * (1.0 - (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) :: t_1
    real(8) :: tmp
    t_1 = -((z - t) / t) * y
    if (a <= (-0.000125d0)) then
        tmp = x + ((z * y) / a)
    else if (a <= (-3.6d-166)) then
        tmp = t_1
    else if (a <= (-2.8d-225)) then
        tmp = (z * (y - x)) / -t
    else if (a <= 4.1d+155) then
        tmp = t_1
    else
        tmp = x * (1.0d0 - (z / a))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = -((z - t) / t) * y;
	double tmp;
	if (a <= -0.000125) {
		tmp = x + ((z * y) / a);
	} else if (a <= -3.6e-166) {
		tmp = t_1;
	} else if (a <= -2.8e-225) {
		tmp = (z * (y - x)) / -t;
	} else if (a <= 4.1e+155) {
		tmp = t_1;
	} else {
		tmp = x * (1.0 - (z / a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = -((z - t) / t) * y
	tmp = 0
	if a <= -0.000125:
		tmp = x + ((z * y) / a)
	elif a <= -3.6e-166:
		tmp = t_1
	elif a <= -2.8e-225:
		tmp = (z * (y - x)) / -t
	elif a <= 4.1e+155:
		tmp = t_1
	else:
		tmp = x * (1.0 - (z / a))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(-Float64(Float64(z - t) / t)) * y)
	tmp = 0.0
	if (a <= -0.000125)
		tmp = Float64(x + Float64(Float64(z * y) / a));
	elseif (a <= -3.6e-166)
		tmp = t_1;
	elseif (a <= -2.8e-225)
		tmp = Float64(Float64(z * Float64(y - x)) / Float64(-t));
	elseif (a <= 4.1e+155)
		tmp = t_1;
	else
		tmp = Float64(x * Float64(1.0 - Float64(z / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = -((z - t) / t) * y;
	tmp = 0.0;
	if (a <= -0.000125)
		tmp = x + ((z * y) / a);
	elseif (a <= -3.6e-166)
		tmp = t_1;
	elseif (a <= -2.8e-225)
		tmp = (z * (y - x)) / -t;
	elseif (a <= 4.1e+155)
		tmp = t_1;
	else
		tmp = x * (1.0 - (z / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision]}, If[LessEqual[a, -0.000125], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -3.6e-166], t$95$1, If[LessEqual[a, -2.8e-225], N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / (-t)), $MachinePrecision], If[LessEqual[a, 4.1e+155], t$95$1, N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -1.25e-4

   1. Initial program 78.2%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.25e-4 < a < -3.6000000000000001e-166 or -2.8e-225 < a < 4.0999999999999998e155

   1. Initial program 69.2%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -3.6000000000000001e-166 < a < -2.8e-225

   1. Initial program 87.4%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around -inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 4.0999999999999998e155 < a

   1. Initial program 82.1%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 11: 47.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y - \frac{y \cdot z}{t}\\ \mathbf{if}\;a \leq -3.5:\\ \;\;\;\;x + \frac{z \cdot y}{a}\\ \mathbf{elif}\;a \leq -2.35 \cdot 10^{-169}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -2 \cdot 10^{-208}:\\ \;\;\;\;\frac{x \cdot \left(z - a\right)}{t}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- y (/ (* y z) t))))
   (if (<= a -3.5)
     (+ x (/ (* z y) a))
     (if (<= a -2.35e-169)
       t_1
       (if (<= a -2e-208)
         (/ (* x (- z a)) t)
         (if (<= a 3.6e+155) t_1 (* x (- 1.0 (/ z a)))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y - ((y * z) / t);
	double tmp;
	if (a <= -3.5) {
		tmp = x + ((z * y) / a);
	} else if (a <= -2.35e-169) {
		tmp = t_1;
	} else if (a <= -2e-208) {
		tmp = (x * (z - a)) / t;
	} else if (a <= 3.6e+155) {
		tmp = t_1;
	} else {
		tmp = x * (1.0 - (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) :: t_1
    real(8) :: tmp
    t_1 = y - ((y * z) / t)
    if (a <= (-3.5d0)) then
        tmp = x + ((z * y) / a)
    else if (a <= (-2.35d-169)) then
        tmp = t_1
    else if (a <= (-2d-208)) then
        tmp = (x * (z - a)) / t
    else if (a <= 3.6d+155) then
        tmp = t_1
    else
        tmp = x * (1.0d0 - (z / a))
    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 * z) / t);
	double tmp;
	if (a <= -3.5) {
		tmp = x + ((z * y) / a);
	} else if (a <= -2.35e-169) {
		tmp = t_1;
	} else if (a <= -2e-208) {
		tmp = (x * (z - a)) / t;
	} else if (a <= 3.6e+155) {
		tmp = t_1;
	} else {
		tmp = x * (1.0 - (z / a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y - ((y * z) / t)
	tmp = 0
	if a <= -3.5:
		tmp = x + ((z * y) / a)
	elif a <= -2.35e-169:
		tmp = t_1
	elif a <= -2e-208:
		tmp = (x * (z - a)) / t
	elif a <= 3.6e+155:
		tmp = t_1
	else:
		tmp = x * (1.0 - (z / a))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y - Float64(Float64(y * z) / t))
	tmp = 0.0
	if (a <= -3.5)
		tmp = Float64(x + Float64(Float64(z * y) / a));
	elseif (a <= -2.35e-169)
		tmp = t_1;
	elseif (a <= -2e-208)
		tmp = Float64(Float64(x * Float64(z - a)) / t);
	elseif (a <= 3.6e+155)
		tmp = t_1;
	else
		tmp = Float64(x * Float64(1.0 - Float64(z / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y - ((y * z) / t);
	tmp = 0.0;
	if (a <= -3.5)
		tmp = x + ((z * y) / a);
	elseif (a <= -2.35e-169)
		tmp = t_1;
	elseif (a <= -2e-208)
		tmp = (x * (z - a)) / t;
	elseif (a <= 3.6e+155)
		tmp = t_1;
	else
		tmp = x * (1.0 - (z / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.5], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.35e-169], t$95$1, If[LessEqual[a, -2e-208], N[(N[(x * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[a, 3.6e+155], t$95$1, N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -3.5

   1. Initial program 78.2%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -3.5 < a < -2.34999999999999995e-169 or -2.0000000000000002e-208 < a < 3.60000000000000007e155

   1. Initial program 69.6%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.34999999999999995e-169 < a < -2.0000000000000002e-208

   1. Initial program 90.9%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.60000000000000007e155 < a

   1. Initial program 82.1%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 12: 48.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{z \cdot y}{a}\\ \mathbf{if}\;t \leq -3.75 \cdot 10^{+53}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -1.25 \cdot 10^{-156}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -1.12 \cdot 10^{-219}:\\ \;\;\;\;y \cdot \frac{z}{a - t}\\ \mathbf{elif}\;t \leq 4.8 \cdot 10^{+71}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (/ (* z y) a))))
   (if (<= t -3.75e+53)
     y
     (if (<= t -1.25e-156)
       t_1
       (if (<= t -1.12e-219) (* y (/ z (- a t))) (if (<= t 4.8e+71) t_1 y))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x + ((z * y) / a);
	double tmp;
	if (t <= -3.75e+53) {
		tmp = y;
	} else if (t <= -1.25e-156) {
		tmp = t_1;
	} else if (t <= -1.12e-219) {
		tmp = y * (z / (a - t));
	} else if (t <= 4.8e+71) {
		tmp = t_1;
	} 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) :: t_1
    real(8) :: tmp
    t_1 = x + ((z * y) / a)
    if (t <= (-3.75d+53)) then
        tmp = y
    else if (t <= (-1.25d-156)) then
        tmp = t_1
    else if (t <= (-1.12d-219)) then
        tmp = y * (z / (a - t))
    else if (t <= 4.8d+71) then
        tmp = t_1
    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 t_1 = x + ((z * y) / a);
	double tmp;
	if (t <= -3.75e+53) {
		tmp = y;
	} else if (t <= -1.25e-156) {
		tmp = t_1;
	} else if (t <= -1.12e-219) {
		tmp = y * (z / (a - t));
	} else if (t <= 4.8e+71) {
		tmp = t_1;
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x + ((z * y) / a)
	tmp = 0
	if t <= -3.75e+53:
		tmp = y
	elif t <= -1.25e-156:
		tmp = t_1
	elif t <= -1.12e-219:
		tmp = y * (z / (a - t))
	elif t <= 4.8e+71:
		tmp = t_1
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x + Float64(Float64(z * y) / a))
	tmp = 0.0
	if (t <= -3.75e+53)
		tmp = y;
	elseif (t <= -1.25e-156)
		tmp = t_1;
	elseif (t <= -1.12e-219)
		tmp = Float64(y * Float64(z / Float64(a - t)));
	elseif (t <= 4.8e+71)
		tmp = t_1;
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x + ((z * y) / a);
	tmp = 0.0;
	if (t <= -3.75e+53)
		tmp = y;
	elseif (t <= -1.25e-156)
		tmp = t_1;
	elseif (t <= -1.12e-219)
		tmp = y * (z / (a - t));
	elseif (t <= 4.8e+71)
		tmp = t_1;
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.75e+53], y, If[LessEqual[t, -1.25e-156], t$95$1, If[LessEqual[t, -1.12e-219], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.8e+71], t$95$1, y]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.7499999999999999e53 or 4.79999999999999961e71 < t

   1. Initial program 50.6%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.7499999999999999e53 < t < -1.25000000000000002e-156 or -1.12e-219 < t < 4.79999999999999961e71

   1. Initial program 87.8%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.25000000000000002e-156 < t < -1.12e-219

   1. Initial program 94.1%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 13: 45.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(1 - \frac{z}{a}\right)\\ \mathbf{if}\;t \leq -1.65 \cdot 10^{+56}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq -7.8 \cdot 10^{-133}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -4.4 \cdot 10^{-277}:\\ \;\;\;\;y \cdot \frac{z}{a - t}\\ \mathbf{elif}\;t \leq 5.8 \cdot 10^{+20}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (* x (- 1.0 (/ z a)))))
   (if (<= t -1.65e+56)
     y
     (if (<= t -7.8e-133)
       t_1
       (if (<= t -4.4e-277) (* y (/ z (- a t))) (if (<= t 5.8e+20) t_1 y))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x * (1.0 - (z / a));
	double tmp;
	if (t <= -1.65e+56) {
		tmp = y;
	} else if (t <= -7.8e-133) {
		tmp = t_1;
	} else if (t <= -4.4e-277) {
		tmp = y * (z / (a - t));
	} else if (t <= 5.8e+20) {
		tmp = t_1;
	} 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) :: t_1
    real(8) :: tmp
    t_1 = x * (1.0d0 - (z / a))
    if (t <= (-1.65d+56)) then
        tmp = y
    else if (t <= (-7.8d-133)) then
        tmp = t_1
    else if (t <= (-4.4d-277)) then
        tmp = y * (z / (a - t))
    else if (t <= 5.8d+20) then
        tmp = t_1
    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 t_1 = x * (1.0 - (z / a));
	double tmp;
	if (t <= -1.65e+56) {
		tmp = y;
	} else if (t <= -7.8e-133) {
		tmp = t_1;
	} else if (t <= -4.4e-277) {
		tmp = y * (z / (a - t));
	} else if (t <= 5.8e+20) {
		tmp = t_1;
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x * (1.0 - (z / a))
	tmp = 0
	if t <= -1.65e+56:
		tmp = y
	elif t <= -7.8e-133:
		tmp = t_1
	elif t <= -4.4e-277:
		tmp = y * (z / (a - t))
	elif t <= 5.8e+20:
		tmp = t_1
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x * Float64(1.0 - Float64(z / a)))
	tmp = 0.0
	if (t <= -1.65e+56)
		tmp = y;
	elseif (t <= -7.8e-133)
		tmp = t_1;
	elseif (t <= -4.4e-277)
		tmp = Float64(y * Float64(z / Float64(a - t)));
	elseif (t <= 5.8e+20)
		tmp = t_1;
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x * (1.0 - (z / a));
	tmp = 0.0;
	if (t <= -1.65e+56)
		tmp = y;
	elseif (t <= -7.8e-133)
		tmp = t_1;
	elseif (t <= -4.4e-277)
		tmp = y * (z / (a - t));
	elseif (t <= 5.8e+20)
		tmp = t_1;
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.65e+56], y, If[LessEqual[t, -7.8e-133], t$95$1, If[LessEqual[t, -4.4e-277], N[(y * N[(z / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e+20], t$95$1, y]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.65000000000000001e56 or 5.8e20 < t

   1. Initial program 49.9%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.65000000000000001e56 < t < -7.80000000000000058e-133 or -4.39999999999999991e-277 < t < 5.8e20

   1. Initial program 90.7%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -7.80000000000000058e-133 < t < -4.39999999999999991e-277

   1. Initial program 94.2%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 14: 82.4% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- y (/ (- z a) (/ t (- y x))))))
   (if (<= t -2.9e+154)
     t_1
     (if (<= t 3.7e+47) (+ x (/ (* (- y x) (- z t)) (- a t))) t_1))))

C

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

Python

def code(x, y, z, t, a):
	t_1 = y - ((z - a) / (t / (y - x)))
	tmp = 0
	if t <= -2.9e+154:
		tmp = t_1
	elif t <= 3.7e+47:
		tmp = x + (((y - x) * (z - t)) / (a - t))
	else:
		tmp = t_1
	return tmp

Julia

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

Derivation

1. Split input into 2 regimes

2. if t < -2.89999999999999979e154 or 3.70000000000000041e47 < t

   1. Initial program 39.2%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if -2.89999999999999979e154 < t < 3.70000000000000041e47

   1. Initial program 89.6%

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

Alternative 15: 69.5% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ x (* (/ 1.0 (- a t)) (* y (- z t))))))
   (if (<= a -0.25)
     t_1
     (if (<= a 3.4e+50) (- y (/ (- z a) (/ t (- y x)))) t_1))))

C

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

Python

def code(x, y, z, t, a):
	t_1 = x + ((1.0 / (a - t)) * (y * (z - t)))
	tmp = 0
	if a <= -0.25:
		tmp = t_1
	elif a <= 3.4e+50:
		tmp = y - ((z - a) / (t / (y - x)))
	else:
		tmp = t_1
	return tmp

Julia

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

Derivation

1. Split input into 2 regimes

2. if a < -0.25 or 3.3999999999999998e50 < a

   1. Initial program 77.3%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.25 < a < 3.3999999999999998e50

   1. Initial program 71.8%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 16: 34.5% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -6.1 \cdot 10^{+21}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq -7.2 \cdot 10^{-149}:\\ \;\;\;\;y \cdot \frac{z}{a}\\ \mathbf{elif}\;a \leq -2.85 \cdot 10^{-227}:\\ \;\;\;\;\frac{y \cdot z}{-t}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;y\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -6.1e+21)
   x
   (if (<= a -7.2e-149)
     (* y (/ z a))
     (if (<= a -2.85e-227) (/ (* y z) (- t)) (if (<= a 3.6e+155) y x)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -6.1e+21) {
		tmp = x;
	} else if (a <= -7.2e-149) {
		tmp = y * (z / a);
	} else if (a <= -2.85e-227) {
		tmp = (y * z) / -t;
	} else if (a <= 3.6e+155) {
		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 <= (-6.1d+21)) then
        tmp = x
    else if (a <= (-7.2d-149)) then
        tmp = y * (z / a)
    else if (a <= (-2.85d-227)) then
        tmp = (y * z) / -t
    else if (a <= 3.6d+155) 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 <= -6.1e+21) {
		tmp = x;
	} else if (a <= -7.2e-149) {
		tmp = y * (z / a);
	} else if (a <= -2.85e-227) {
		tmp = (y * z) / -t;
	} else if (a <= 3.6e+155) {
		tmp = y;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -6.1e+21:
		tmp = x
	elif a <= -7.2e-149:
		tmp = y * (z / a)
	elif a <= -2.85e-227:
		tmp = (y * z) / -t
	elif a <= 3.6e+155:
		tmp = y
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -6.1e+21)
		tmp = x;
	elseif (a <= -7.2e-149)
		tmp = Float64(y * Float64(z / a));
	elseif (a <= -2.85e-227)
		tmp = Float64(Float64(y * z) / Float64(-t));
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -6.1e+21)
		tmp = x;
	elseif (a <= -7.2e-149)
		tmp = y * (z / a);
	elseif (a <= -2.85e-227)
		tmp = (y * z) / -t;
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -6.1e+21], x, If[LessEqual[a, -7.2e-149], N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.85e-227], N[(N[(y * z), $MachinePrecision] / (-t)), $MachinePrecision], If[LessEqual[a, 3.6e+155], y, x]]]]

Derivation

1. Split input into 4 regimes

2. if a < -6.1e21 or 3.60000000000000007e155 < a

   1. Initial program 77.9%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.1e21 < a < -7.2000000000000004e-149

   1. Initial program 78.1%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -7.2000000000000004e-149 < a < -2.84999999999999995e-227

   1. Initial program 83.5%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.84999999999999995e-227 < a < 3.60000000000000007e155

   1. Initial program 68.3%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 17: 70.3% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -0.165)
   (+ x (/ (- y x) (/ a z)))
   (if (<= a 2.35e+58)
     (- y (/ (- z a) (/ t (- y x))))
     (+ x (* (- x y) (/ t (- a t)))))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -0.165:
		tmp = x + ((y - x) / (a / z))
	elif a <= 2.35e+58:
		tmp = y - ((z - a) / (t / (y - x)))
	else:
		tmp = x + ((x - y) * (t / (a - t)))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if a < -0.165000000000000008

   1. Initial program 78.2%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.165000000000000008 < a < 2.34999999999999986e58

   1. Initial program 72.2%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 2.34999999999999986e58 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 18: 70.2% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -0.00076)
   (+ x (/ (- y x) (/ a z)))
   (if (<= a 9.2e+55)
     (- y (* (/ (- y x) t) (- z a)))
     (+ x (* (- x y) (/ t (- a t)))))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -0.00076:
		tmp = x + ((y - x) / (a / z))
	elif a <= 9.2e+55:
		tmp = y - (((y - x) / t) * (z - a))
	else:
		tmp = x + ((x - y) * (t / (a - t)))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if a < -7.6000000000000004e-4

   1. Initial program 78.2%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -7.6000000000000004e-4 < a < 9.1999999999999995e55

   1. Initial program 72.2%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 9.1999999999999995e55 < a

   1. Initial program 75.0%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 19: 50.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -0.0024:\\ \;\;\;\;x + \frac{z \cdot y}{a}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;\left(-\frac{z - t}{t}\right) \cdot y\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -0.0024)
   (+ x (/ (* z y) a))
   (if (<= a 3.6e+155) (* (- (/ (- z t) t)) y) (* x (- 1.0 (/ z a))))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -0.0024:
		tmp = x + ((z * y) / a)
	elif a <= 3.6e+155:
		tmp = -((z - t) / t) * y
	else:
		tmp = x * (1.0 - (z / a))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -0.0024)
		tmp = Float64(x + Float64(Float64(z * y) / a));
	elseif (a <= 3.6e+155)
		tmp = Float64(Float64(-Float64(Float64(z - t) / t)) * y);
	else
		tmp = Float64(x * Float64(1.0 - Float64(z / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -0.0024)
		tmp = x + ((z * y) / a);
	elseif (a <= 3.6e+155)
		tmp = -((z - t) / t) * y;
	else
		tmp = x * (1.0 - (z / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -0.0024], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e+155], N[((-N[(N[(z - t), $MachinePrecision] / t), $MachinePrecision]) * y), $MachinePrecision], N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if a < -0.00239999999999999979

   1. Initial program 78.2%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -0.00239999999999999979 < a < 3.60000000000000007e155

   1. Initial program 71.0%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 3.60000000000000007e155 < a

   1. Initial program 82.1%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 20: 48.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -0.00135:\\ \;\;\;\;x + \frac{z \cdot y}{a}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;y - \frac{y \cdot z}{t}\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -0.00135)
   (+ x (/ (* z y) a))
   (if (<= a 3.6e+155) (- y (/ (* y z) t)) (* x (- 1.0 (/ z a))))))

C

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

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -0.00135:
		tmp = x + ((z * y) / a)
	elif a <= 3.6e+155:
		tmp = y - ((y * z) / t)
	else:
		tmp = x * (1.0 - (z / a))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -0.00135)
		tmp = Float64(x + Float64(Float64(z * y) / a));
	elseif (a <= 3.6e+155)
		tmp = Float64(y - Float64(Float64(y * z) / t));
	else
		tmp = Float64(x * Float64(1.0 - Float64(z / a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -0.00135)
		tmp = x + ((z * y) / a);
	elseif (a <= 3.6e+155)
		tmp = y - ((y * z) / t);
	else
		tmp = x * (1.0 - (z / a));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -0.00135], N[(x + N[(N[(z * y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e+155], N[(y - N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if a < -0.0013500000000000001

   1. Initial program 78.2%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -0.0013500000000000001 < a < 3.60000000000000007e155

   1. Initial program 71.0%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if 3.60000000000000007e155 < a

   1. Initial program 82.1%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 21: 48.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.55 \cdot 10^{+56}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq 1.75 \cdot 10^{+30}:\\ \;\;\;\;x \cdot \left(1 - \frac{z}{a}\right)\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= t -1.55e+56) y (if (<= t 1.75e+30) (* x (- 1.0 (/ z a))) y)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -1.55e+56) {
		tmp = y;
	} else if (t <= 1.75e+30) {
		tmp = x * (1.0 - (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.55d+56)) then
        tmp = y
    else if (t <= 1.75d+30) then
        tmp = x * (1.0d0 - (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.55e+56) {
		tmp = y;
	} else if (t <= 1.75e+30) {
		tmp = x * (1.0 - (z / a));
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -1.55e+56:
		tmp = y
	elif t <= 1.75e+30:
		tmp = x * (1.0 - (z / a))
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -1.55e+56)
		tmp = y;
	elseif (t <= 1.75e+30)
		tmp = Float64(x * Float64(1.0 - 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.55e+56)
		tmp = y;
	elseif (t <= 1.75e+30)
		tmp = x * (1.0 - (z / a));
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.55e+56], y, If[LessEqual[t, 1.75e+30], N[(x * N[(1.0 - N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], y]]

Derivation

1. Split input into 2 regimes

2. if t < -1.55000000000000002e56 or 1.75000000000000011e30 < t

   1. Initial program 49.9%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.55000000000000002e56 < t < 1.75000000000000011e30

   1. Initial program 91.4%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 22: 34.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -1.1 \cdot 10^{+27}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq -3.15 \cdot 10^{-226}:\\ \;\;\;\;y \cdot \frac{z}{a}\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;y\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -1.1e+27)
   x
   (if (<= a -3.15e-226) (* y (/ z a)) (if (<= a 3.6e+155) y x))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -1.1e+27) {
		tmp = x;
	} else if (a <= -3.15e-226) {
		tmp = y * (z / a);
	} else if (a <= 3.6e+155) {
		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 <= (-1.1d+27)) then
        tmp = x
    else if (a <= (-3.15d-226)) then
        tmp = y * (z / a)
    else if (a <= 3.6d+155) 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 <= -1.1e+27) {
		tmp = x;
	} else if (a <= -3.15e-226) {
		tmp = y * (z / a);
	} else if (a <= 3.6e+155) {
		tmp = y;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -1.1e+27:
		tmp = x
	elif a <= -3.15e-226:
		tmp = y * (z / a)
	elif a <= 3.6e+155:
		tmp = y
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -1.1e+27)
		tmp = x;
	elseif (a <= -3.15e-226)
		tmp = Float64(y * Float64(z / a));
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -1.1e+27)
		tmp = x;
	elseif (a <= -3.15e-226)
		tmp = y * (z / a);
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.1e+27], x, If[LessEqual[a, -3.15e-226], N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e+155], y, x]]]

Derivation

1. Split input into 3 regimes

2. if a < -1.0999999999999999e27 or 3.60000000000000007e155 < a

   1. Initial program 77.9%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.0999999999999999e27 < a < -3.1499999999999999e-226

   1. Initial program 80.5%

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

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -3.1499999999999999e-226 < a < 3.60000000000000007e155

   1. Initial program 68.3%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 23: 37.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -10200:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 3.6 \cdot 10^{+155}:\\ \;\;\;\;y\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= a -10200.0) x (if (<= a 3.6e+155) y x)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -10200.0) {
		tmp = x;
	} else if (a <= 3.6e+155) {
		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 <= (-10200.0d0)) then
        tmp = x
    else if (a <= 3.6d+155) 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 <= -10200.0) {
		tmp = x;
	} else if (a <= 3.6e+155) {
		tmp = y;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if a <= -10200.0:
		tmp = x
	elif a <= 3.6e+155:
		tmp = y
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -10200.0)
		tmp = x;
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (a <= -10200.0)
		tmp = x;
	elseif (a <= 3.6e+155)
		tmp = y;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -10200.0], x, If[LessEqual[a, 3.6e+155], y, x]]

Derivation

1. Split input into 2 regimes

2. if a < -10200 or 3.60000000000000007e155 < a

   1. Initial program 79.3%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -10200 < a < 3.60000000000000007e155

   1. Initial program 71.2%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 24: 24.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 74.2%

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

3. Taylor expanded in a around inf 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Developer target: 87.0% accurate, 0.5× 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 2024110 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
  :precision binary64

  :alt
  (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))))