Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2

Percentage Accurate: 95.1% → 97.9%

Time: 19.2s

Alternatives: 26

Speedup: 0.5×

• 35.7% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 95.1% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 97.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\\ \mathbf{if}\;t\_1 + \left(\left(y + t\right) - 2\right) \cdot b \leq \infty:\\ \;\;\;\;t\_1 + \left(\left(y + t\right) \cdot b + -2 \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- (- x (* (- y 1.0) z)) (* (- t 1.0) a))))
   (if (<= (+ t_1 (* (- (+ y t) 2.0) b)) INFINITY)
     (+ t_1 (+ (* (+ y t) b) (* -2.0 b)))
     (* t (- b a)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x - ((y - 1.0) * z)) - ((t - 1.0) * a);
	double tmp;
	if ((t_1 + (((y + t) - 2.0) * b)) <= ((double) INFINITY)) {
		tmp = t_1 + (((y + t) * b) + (-2.0 * b));
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x - ((y - 1.0) * z)) - ((t - 1.0) * a);
	double tmp;
	if ((t_1 + (((y + t) - 2.0) * b)) <= Double.POSITIVE_INFINITY) {
		tmp = t_1 + (((y + t) * b) + (-2.0 * b));
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x - ((y - 1.0) * z)) - ((t - 1.0) * a)
	tmp = 0
	if (t_1 + (((y + t) - 2.0) * b)) <= math.inf:
		tmp = t_1 + (((y + t) * b) + (-2.0 * b))
	else:
		tmp = t * (b - a)
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a))
	tmp = 0.0
	if (Float64(t_1 + Float64(Float64(Float64(y + t) - 2.0) * b)) <= Inf)
		tmp = Float64(t_1 + Float64(Float64(Float64(y + t) * b) + Float64(-2.0 * b)));
	else
		tmp = Float64(t * Float64(b - a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x - ((y - 1.0) * z)) - ((t - 1.0) * a);
	tmp = 0.0;
	if ((t_1 + (((y + t) - 2.0) * b)) <= Inf)
		tmp = t_1 + (((y + t) * b) + (-2.0 * b));
	else
		tmp = t * (b - a);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y #s(literal 1 binary64)) z)) (*.f64 (-.f64 t #s(literal 1 binary64)) a)) (*.f64 (-.f64 (+.f64 y t) #s(literal 2 binary64)) b)) < +inf.0

   1. Initial program 100.0%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y #s(literal 1 binary64)) z)) (*.f64 (-.f64 t #s(literal 1 binary64)) a)) (*.f64 (-.f64 (+.f64 y t) #s(literal 2 binary64)) b))

   1. Initial program 0.0%

      \[\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b \]
   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 2: 51.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -1 \cdot 10^{+40}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -4.4 \cdot 10^{-101}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -2.4 \cdot 10^{-131}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq -5.4 \cdot 10^{-157}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;t \leq -2.6 \cdot 10^{-168}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq -6 \cdot 10^{-219}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 5.8 \cdot 10^{-227}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq 2 \cdot 10^{-37}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 49000:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
   (if (<= t -1e+40)
     t_2
     (if (<= t -4.4e-101)
       t_1
       (if (<= t -2.4e-131)
         (+ a x)
         (if (<= t -5.4e-157)
           (* z (- 1.0 y))
           (if (<= t -2.6e-168)
             (+ a x)
             (if (<= t -6e-219)
               t_1
               (if (<= t 5.8e-227)
                 (+ a x)
                 (if (<= t 2e-37) t_1 (if (<= t 49000.0) (+ x z) t_2)))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -1e+40) {
		tmp = t_2;
	} else if (t <= -4.4e-101) {
		tmp = t_1;
	} else if (t <= -2.4e-131) {
		tmp = a + x;
	} else if (t <= -5.4e-157) {
		tmp = z * (1.0 - y);
	} else if (t <= -2.6e-168) {
		tmp = a + x;
	} else if (t <= -6e-219) {
		tmp = t_1;
	} else if (t <= 5.8e-227) {
		tmp = a + x;
	} else if (t <= 2e-37) {
		tmp = t_1;
	} else if (t <= 49000.0) {
		tmp = x + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = y * (b - z)
    t_2 = t * (b - a)
    if (t <= (-1d+40)) then
        tmp = t_2
    else if (t <= (-4.4d-101)) then
        tmp = t_1
    else if (t <= (-2.4d-131)) then
        tmp = a + x
    else if (t <= (-5.4d-157)) then
        tmp = z * (1.0d0 - y)
    else if (t <= (-2.6d-168)) then
        tmp = a + x
    else if (t <= (-6d-219)) then
        tmp = t_1
    else if (t <= 5.8d-227) then
        tmp = a + x
    else if (t <= 2d-37) then
        tmp = t_1
    else if (t <= 49000.0d0) then
        tmp = x + z
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -1e+40) {
		tmp = t_2;
	} else if (t <= -4.4e-101) {
		tmp = t_1;
	} else if (t <= -2.4e-131) {
		tmp = a + x;
	} else if (t <= -5.4e-157) {
		tmp = z * (1.0 - y);
	} else if (t <= -2.6e-168) {
		tmp = a + x;
	} else if (t <= -6e-219) {
		tmp = t_1;
	} else if (t <= 5.8e-227) {
		tmp = a + x;
	} else if (t <= 2e-37) {
		tmp = t_1;
	} else if (t <= 49000.0) {
		tmp = x + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -1e+40:
		tmp = t_2
	elif t <= -4.4e-101:
		tmp = t_1
	elif t <= -2.4e-131:
		tmp = a + x
	elif t <= -5.4e-157:
		tmp = z * (1.0 - y)
	elif t <= -2.6e-168:
		tmp = a + x
	elif t <= -6e-219:
		tmp = t_1
	elif t <= 5.8e-227:
		tmp = a + x
	elif t <= 2e-37:
		tmp = t_1
	elif t <= 49000.0:
		tmp = x + z
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -1e+40)
		tmp = t_2;
	elseif (t <= -4.4e-101)
		tmp = t_1;
	elseif (t <= -2.4e-131)
		tmp = Float64(a + x);
	elseif (t <= -5.4e-157)
		tmp = Float64(z * Float64(1.0 - y));
	elseif (t <= -2.6e-168)
		tmp = Float64(a + x);
	elseif (t <= -6e-219)
		tmp = t_1;
	elseif (t <= 5.8e-227)
		tmp = Float64(a + x);
	elseif (t <= 2e-37)
		tmp = t_1;
	elseif (t <= 49000.0)
		tmp = Float64(x + z);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -1e+40)
		tmp = t_2;
	elseif (t <= -4.4e-101)
		tmp = t_1;
	elseif (t <= -2.4e-131)
		tmp = a + x;
	elseif (t <= -5.4e-157)
		tmp = z * (1.0 - y);
	elseif (t <= -2.6e-168)
		tmp = a + x;
	elseif (t <= -6e-219)
		tmp = t_1;
	elseif (t <= 5.8e-227)
		tmp = a + x;
	elseif (t <= 2e-37)
		tmp = t_1;
	elseif (t <= 49000.0)
		tmp = x + z;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1e+40], t$95$2, If[LessEqual[t, -4.4e-101], t$95$1, If[LessEqual[t, -2.4e-131], N[(a + x), $MachinePrecision], If[LessEqual[t, -5.4e-157], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.6e-168], N[(a + x), $MachinePrecision], If[LessEqual[t, -6e-219], t$95$1, If[LessEqual[t, 5.8e-227], N[(a + x), $MachinePrecision], If[LessEqual[t, 2e-37], t$95$1, If[LessEqual[t, 49000.0], N[(x + z), $MachinePrecision], t$95$2]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -1.00000000000000003e40 or 49000 < t

   1. Initial program 94.6%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.00000000000000003e40 < t < -4.3999999999999998e-101 or -2.6000000000000001e-168 < t < -6.0000000000000002e-219 or 5.80000000000000022e-227 < t < 2.00000000000000013e-37

   1. Initial program 95.9%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.3999999999999998e-101 < t < -2.4e-131 or -5.4e-157 < t < -2.6000000000000001e-168 or -6.0000000000000002e-219 < t < 5.80000000000000022e-227

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -2.4e-131 < t < -5.4e-157

   1. Initial program 100.0%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.00000000000000013e-37 < t < 49000

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   14. Simplified 0

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

Alternative 3: 51.1% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -6.2 \cdot 10^{+41}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -7.5 \cdot 10^{-102}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -9.5 \cdot 10^{-133}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq -4.5 \cdot 10^{-152}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -1.25 \cdot 10^{-168}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq -4.4 \cdot 10^{-219}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 6.8 \cdot 10^{-228}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq 7.8 \cdot 10^{-41}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 48000:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
   (if (<= t -6.2e+41)
     t_2
     (if (<= t -7.5e-102)
       t_1
       (if (<= t -9.5e-133)
         (+ a x)
         (if (<= t -4.5e-152)
           t_1
           (if (<= t -1.25e-168)
             (+ a x)
             (if (<= t -4.4e-219)
               t_1
               (if (<= t 6.8e-228)
                 (+ a x)
                 (if (<= t 7.8e-41)
                   t_1
                   (if (<= t 48000.0) (+ x z) t_2)))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -6.2e+41) {
		tmp = t_2;
	} else if (t <= -7.5e-102) {
		tmp = t_1;
	} else if (t <= -9.5e-133) {
		tmp = a + x;
	} else if (t <= -4.5e-152) {
		tmp = t_1;
	} else if (t <= -1.25e-168) {
		tmp = a + x;
	} else if (t <= -4.4e-219) {
		tmp = t_1;
	} else if (t <= 6.8e-228) {
		tmp = a + x;
	} else if (t <= 7.8e-41) {
		tmp = t_1;
	} else if (t <= 48000.0) {
		tmp = x + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = y * (b - z)
    t_2 = t * (b - a)
    if (t <= (-6.2d+41)) then
        tmp = t_2
    else if (t <= (-7.5d-102)) then
        tmp = t_1
    else if (t <= (-9.5d-133)) then
        tmp = a + x
    else if (t <= (-4.5d-152)) then
        tmp = t_1
    else if (t <= (-1.25d-168)) then
        tmp = a + x
    else if (t <= (-4.4d-219)) then
        tmp = t_1
    else if (t <= 6.8d-228) then
        tmp = a + x
    else if (t <= 7.8d-41) then
        tmp = t_1
    else if (t <= 48000.0d0) then
        tmp = x + z
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -6.2e+41) {
		tmp = t_2;
	} else if (t <= -7.5e-102) {
		tmp = t_1;
	} else if (t <= -9.5e-133) {
		tmp = a + x;
	} else if (t <= -4.5e-152) {
		tmp = t_1;
	} else if (t <= -1.25e-168) {
		tmp = a + x;
	} else if (t <= -4.4e-219) {
		tmp = t_1;
	} else if (t <= 6.8e-228) {
		tmp = a + x;
	} else if (t <= 7.8e-41) {
		tmp = t_1;
	} else if (t <= 48000.0) {
		tmp = x + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -6.2e+41:
		tmp = t_2
	elif t <= -7.5e-102:
		tmp = t_1
	elif t <= -9.5e-133:
		tmp = a + x
	elif t <= -4.5e-152:
		tmp = t_1
	elif t <= -1.25e-168:
		tmp = a + x
	elif t <= -4.4e-219:
		tmp = t_1
	elif t <= 6.8e-228:
		tmp = a + x
	elif t <= 7.8e-41:
		tmp = t_1
	elif t <= 48000.0:
		tmp = x + z
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -6.2e+41)
		tmp = t_2;
	elseif (t <= -7.5e-102)
		tmp = t_1;
	elseif (t <= -9.5e-133)
		tmp = Float64(a + x);
	elseif (t <= -4.5e-152)
		tmp = t_1;
	elseif (t <= -1.25e-168)
		tmp = Float64(a + x);
	elseif (t <= -4.4e-219)
		tmp = t_1;
	elseif (t <= 6.8e-228)
		tmp = Float64(a + x);
	elseif (t <= 7.8e-41)
		tmp = t_1;
	elseif (t <= 48000.0)
		tmp = Float64(x + z);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -6.2e+41)
		tmp = t_2;
	elseif (t <= -7.5e-102)
		tmp = t_1;
	elseif (t <= -9.5e-133)
		tmp = a + x;
	elseif (t <= -4.5e-152)
		tmp = t_1;
	elseif (t <= -1.25e-168)
		tmp = a + x;
	elseif (t <= -4.4e-219)
		tmp = t_1;
	elseif (t <= 6.8e-228)
		tmp = a + x;
	elseif (t <= 7.8e-41)
		tmp = t_1;
	elseif (t <= 48000.0)
		tmp = x + z;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.2e+41], t$95$2, If[LessEqual[t, -7.5e-102], t$95$1, If[LessEqual[t, -9.5e-133], N[(a + x), $MachinePrecision], If[LessEqual[t, -4.5e-152], t$95$1, If[LessEqual[t, -1.25e-168], N[(a + x), $MachinePrecision], If[LessEqual[t, -4.4e-219], t$95$1, If[LessEqual[t, 6.8e-228], N[(a + x), $MachinePrecision], If[LessEqual[t, 7.8e-41], t$95$1, If[LessEqual[t, 48000.0], N[(x + z), $MachinePrecision], t$95$2]]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -6.2e41 or 48000 < t

   1. Initial program 94.6%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.2e41 < t < -7.5000000000000008e-102 or -9.4999999999999992e-133 < t < -4.5000000000000004e-152 or -1.25e-168 < t < -4.3999999999999999e-219 or 6.79999999999999981e-228 < t < 7.79999999999999982e-41

   1. Initial program 96.2%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.5000000000000008e-102 < t < -9.4999999999999992e-133 or -4.5000000000000004e-152 < t < -1.25e-168 or -4.3999999999999999e-219 < t < 6.79999999999999981e-228

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 7.79999999999999982e-41 < t < 48000

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   14. Simplified 0

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

Alternative 4: 97.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{if}\;t\_1 \leq \infty:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1
         (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b))))
   (if (<= t_1 INFINITY) t_1 (* t (- b a)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = t_1;
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
	double tmp;
	if (t_1 <= Double.POSITIVE_INFINITY) {
		tmp = t_1;
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b)
	tmp = 0
	if t_1 <= math.inf:
		tmp = t_1
	else:
		tmp = t * (b - a)
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(Float64(x - Float64(Float64(y - 1.0) * z)) - Float64(Float64(t - 1.0) * a)) + Float64(Float64(Float64(y + t) - 2.0) * b))
	tmp = 0.0
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = Float64(t * Float64(b - a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = ((x - ((y - 1.0) * z)) - ((t - 1.0) * a)) + (((y + t) - 2.0) * b);
	tmp = 0.0;
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = t * (b - a);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y #s(literal 1 binary64)) z)) (*.f64 (-.f64 t #s(literal 1 binary64)) a)) (*.f64 (-.f64 (+.f64 y t) #s(literal 2 binary64)) b)) < +inf.0

   1. Initial program 100.0%

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

   if +inf.0 < (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y #s(literal 1 binary64)) z)) (*.f64 (-.f64 t #s(literal 1 binary64)) a)) (*.f64 (-.f64 (+.f64 y t) #s(literal 2 binary64)) b))

   1. Initial program 0.0%

      \[\left(\left(x - \left(y - 1\right) \cdot z\right) - \left(t - 1\right) \cdot a\right) + \left(\left(y + t\right) - 2\right) \cdot b \]
   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 5: 50.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -2.6 \cdot 10^{+39}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -4.3 \cdot 10^{-103}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -1.3 \cdot 10^{-168}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq -3.7 \cdot 10^{-217}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -9.5 \cdot 10^{-225}:\\ \;\;\;\;a + z\\ \mathbf{elif}\;t \leq 1.1 \cdot 10^{-161}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;t \leq 7.5 \cdot 10^{+30}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
   (if (<= t -2.6e+39)
     t_2
     (if (<= t -4.3e-103)
       t_1
       (if (<= t -1.3e-168)
         (+ a x)
         (if (<= t -3.7e-217)
           t_1
           (if (<= t -9.5e-225)
             (+ a z)
             (if (<= t 1.1e-161)
               (+ x (* y b))
               (if (<= t 7.5e+30) (* z (- 1.0 y)) t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -2.6e+39) {
		tmp = t_2;
	} else if (t <= -4.3e-103) {
		tmp = t_1;
	} else if (t <= -1.3e-168) {
		tmp = a + x;
	} else if (t <= -3.7e-217) {
		tmp = t_1;
	} else if (t <= -9.5e-225) {
		tmp = a + z;
	} else if (t <= 1.1e-161) {
		tmp = x + (y * b);
	} else if (t <= 7.5e+30) {
		tmp = z * (1.0 - y);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = y * (b - z)
    t_2 = t * (b - a)
    if (t <= (-2.6d+39)) then
        tmp = t_2
    else if (t <= (-4.3d-103)) then
        tmp = t_1
    else if (t <= (-1.3d-168)) then
        tmp = a + x
    else if (t <= (-3.7d-217)) then
        tmp = t_1
    else if (t <= (-9.5d-225)) then
        tmp = a + z
    else if (t <= 1.1d-161) then
        tmp = x + (y * b)
    else if (t <= 7.5d+30) then
        tmp = z * (1.0d0 - y)
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -2.6e+39) {
		tmp = t_2;
	} else if (t <= -4.3e-103) {
		tmp = t_1;
	} else if (t <= -1.3e-168) {
		tmp = a + x;
	} else if (t <= -3.7e-217) {
		tmp = t_1;
	} else if (t <= -9.5e-225) {
		tmp = a + z;
	} else if (t <= 1.1e-161) {
		tmp = x + (y * b);
	} else if (t <= 7.5e+30) {
		tmp = z * (1.0 - y);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -2.6e+39:
		tmp = t_2
	elif t <= -4.3e-103:
		tmp = t_1
	elif t <= -1.3e-168:
		tmp = a + x
	elif t <= -3.7e-217:
		tmp = t_1
	elif t <= -9.5e-225:
		tmp = a + z
	elif t <= 1.1e-161:
		tmp = x + (y * b)
	elif t <= 7.5e+30:
		tmp = z * (1.0 - y)
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -2.6e+39)
		tmp = t_2;
	elseif (t <= -4.3e-103)
		tmp = t_1;
	elseif (t <= -1.3e-168)
		tmp = Float64(a + x);
	elseif (t <= -3.7e-217)
		tmp = t_1;
	elseif (t <= -9.5e-225)
		tmp = Float64(a + z);
	elseif (t <= 1.1e-161)
		tmp = Float64(x + Float64(y * b));
	elseif (t <= 7.5e+30)
		tmp = Float64(z * Float64(1.0 - y));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -2.6e+39)
		tmp = t_2;
	elseif (t <= -4.3e-103)
		tmp = t_1;
	elseif (t <= -1.3e-168)
		tmp = a + x;
	elseif (t <= -3.7e-217)
		tmp = t_1;
	elseif (t <= -9.5e-225)
		tmp = a + z;
	elseif (t <= 1.1e-161)
		tmp = x + (y * b);
	elseif (t <= 7.5e+30)
		tmp = z * (1.0 - y);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.6e+39], t$95$2, If[LessEqual[t, -4.3e-103], t$95$1, If[LessEqual[t, -1.3e-168], N[(a + x), $MachinePrecision], If[LessEqual[t, -3.7e-217], t$95$1, If[LessEqual[t, -9.5e-225], N[(a + z), $MachinePrecision], If[LessEqual[t, 1.1e-161], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.5e+30], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if t < -2.6e39 or 7.49999999999999973e30 < t

   1. Initial program 94.4%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.6e39 < t < -4.30000000000000023e-103 or -1.3e-168 < t < -3.6999999999999996e-217

   1. Initial program 94.2%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.30000000000000023e-103 < t < -1.3e-168

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -3.6999999999999996e-217 < t < -9.50000000000000006e-225

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in x around 0 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]

   if -9.50000000000000006e-225 < t < 1.10000000000000001e-161

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 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.10000000000000001e-161 < t < 7.49999999999999973e30

   1. Initial program 97.3%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 6: 70.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := \left(\left(y + t\right) - 2\right) \cdot b\\ t_3 := t\_1 + t\_2\\ t_4 := z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -7 \cdot 10^{+20}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq 2.2 \cdot 10^{+71}:\\ \;\;\;\;\left(x + t\_1\right) + z\\ \mathbf{elif}\;b \leq 1.75 \cdot 10^{+120}:\\ \;\;\;\;t\_4 - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{+124}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;b \leq 9 \cdot 10^{+253}:\\ \;\;\;\;t\_4 + t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t)))
        (t_2 (* (- (+ y t) 2.0) b))
        (t_3 (+ t_1 t_2))
        (t_4 (* z (- 1.0 y))))
   (if (<= b -7e+20)
     t_3
     (if (<= b 2.2e+71)
       (+ (+ x t_1) z)
       (if (<= b 1.75e+120)
         (- t_4 (* a (+ t -1.0)))
         (if (<= b 1.1e+124)
           (+ x (* y b))
           (if (<= b 9e+253) (+ t_4 t_2) t_3)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = ((y + t) - 2.0) * b;
	double t_3 = t_1 + t_2;
	double t_4 = z * (1.0 - y);
	double tmp;
	if (b <= -7e+20) {
		tmp = t_3;
	} else if (b <= 2.2e+71) {
		tmp = (x + t_1) + z;
	} else if (b <= 1.75e+120) {
		tmp = t_4 - (a * (t + -1.0));
	} else if (b <= 1.1e+124) {
		tmp = x + (y * b);
	} else if (b <= 9e+253) {
		tmp = t_4 + t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = ((y + t) - 2.0d0) * b
    t_3 = t_1 + t_2
    t_4 = z * (1.0d0 - y)
    if (b <= (-7d+20)) then
        tmp = t_3
    else if (b <= 2.2d+71) then
        tmp = (x + t_1) + z
    else if (b <= 1.75d+120) then
        tmp = t_4 - (a * (t + (-1.0d0)))
    else if (b <= 1.1d+124) then
        tmp = x + (y * b)
    else if (b <= 9d+253) then
        tmp = t_4 + t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = ((y + t) - 2.0) * b;
	double t_3 = t_1 + t_2;
	double t_4 = z * (1.0 - y);
	double tmp;
	if (b <= -7e+20) {
		tmp = t_3;
	} else if (b <= 2.2e+71) {
		tmp = (x + t_1) + z;
	} else if (b <= 1.75e+120) {
		tmp = t_4 - (a * (t + -1.0));
	} else if (b <= 1.1e+124) {
		tmp = x + (y * b);
	} else if (b <= 9e+253) {
		tmp = t_4 + t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = ((y + t) - 2.0) * b
	t_3 = t_1 + t_2
	t_4 = z * (1.0 - y)
	tmp = 0
	if b <= -7e+20:
		tmp = t_3
	elif b <= 2.2e+71:
		tmp = (x + t_1) + z
	elif b <= 1.75e+120:
		tmp = t_4 - (a * (t + -1.0))
	elif b <= 1.1e+124:
		tmp = x + (y * b)
	elif b <= 9e+253:
		tmp = t_4 + t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(Float64(Float64(y + t) - 2.0) * b)
	t_3 = Float64(t_1 + t_2)
	t_4 = Float64(z * Float64(1.0 - y))
	tmp = 0.0
	if (b <= -7e+20)
		tmp = t_3;
	elseif (b <= 2.2e+71)
		tmp = Float64(Float64(x + t_1) + z);
	elseif (b <= 1.75e+120)
		tmp = Float64(t_4 - Float64(a * Float64(t + -1.0)));
	elseif (b <= 1.1e+124)
		tmp = Float64(x + Float64(y * b));
	elseif (b <= 9e+253)
		tmp = Float64(t_4 + t_2);
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	t_2 = ((y + t) - 2.0) * b;
	t_3 = t_1 + t_2;
	t_4 = z * (1.0 - y);
	tmp = 0.0;
	if (b <= -7e+20)
		tmp = t_3;
	elseif (b <= 2.2e+71)
		tmp = (x + t_1) + z;
	elseif (b <= 1.75e+120)
		tmp = t_4 - (a * (t + -1.0));
	elseif (b <= 1.1e+124)
		tmp = x + (y * b);
	elseif (b <= 9e+253)
		tmp = t_4 + t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 + t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7e+20], t$95$3, If[LessEqual[b, 2.2e+71], N[(N[(x + t$95$1), $MachinePrecision] + z), $MachinePrecision], If[LessEqual[b, 1.75e+120], N[(t$95$4 - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.1e+124], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9e+253], N[(t$95$4 + t$95$2), $MachinePrecision], t$95$3]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -7e20 or 8.99999999999999943e253 < b

   1. Initial program 91.4%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7e20 < b < 2.19999999999999995e71

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.19999999999999995e71 < b < 1.75000000000000004e120

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.75000000000000004e120 < b < 1.1e124

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 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.1e124 < b < 8.99999999999999943e253

   1. Initial program 99.8%

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

   3. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 7: 54.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x + a\right) + z\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -4.5 \cdot 10^{+73}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -1.55 \cdot 10^{-226}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 1.55 \cdot 10^{-288}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;t \leq 2.1 \cdot 10^{-181}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.7 \cdot 10^{-64}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq 48000:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ (+ x a) z)) (t_2 (* t (- b a))))
   (if (<= t -4.5e+73)
     t_2
     (if (<= t -1.55e-226)
       t_1
       (if (<= t 1.55e-288)
         (+ x (* y b))
         (if (<= t 2.1e-181)
           t_1
           (if (<= t 2.7e-64) (* y (- b z)) (if (<= t 48000.0) t_1 t_2))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x + a) + z;
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -4.5e+73) {
		tmp = t_2;
	} else if (t <= -1.55e-226) {
		tmp = t_1;
	} else if (t <= 1.55e-288) {
		tmp = x + (y * b);
	} else if (t <= 2.1e-181) {
		tmp = t_1;
	} else if (t <= 2.7e-64) {
		tmp = y * (b - z);
	} else if (t <= 48000.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (x + a) + z
    t_2 = t * (b - a)
    if (t <= (-4.5d+73)) then
        tmp = t_2
    else if (t <= (-1.55d-226)) then
        tmp = t_1
    else if (t <= 1.55d-288) then
        tmp = x + (y * b)
    else if (t <= 2.1d-181) then
        tmp = t_1
    else if (t <= 2.7d-64) then
        tmp = y * (b - z)
    else if (t <= 48000.0d0) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x + a) + z;
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -4.5e+73) {
		tmp = t_2;
	} else if (t <= -1.55e-226) {
		tmp = t_1;
	} else if (t <= 1.55e-288) {
		tmp = x + (y * b);
	} else if (t <= 2.1e-181) {
		tmp = t_1;
	} else if (t <= 2.7e-64) {
		tmp = y * (b - z);
	} else if (t <= 48000.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x + a) + z
	t_2 = t * (b - a)
	tmp = 0
	if t <= -4.5e+73:
		tmp = t_2
	elif t <= -1.55e-226:
		tmp = t_1
	elif t <= 1.55e-288:
		tmp = x + (y * b)
	elif t <= 2.1e-181:
		tmp = t_1
	elif t <= 2.7e-64:
		tmp = y * (b - z)
	elif t <= 48000.0:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x + a) + z)
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -4.5e+73)
		tmp = t_2;
	elseif (t <= -1.55e-226)
		tmp = t_1;
	elseif (t <= 1.55e-288)
		tmp = Float64(x + Float64(y * b));
	elseif (t <= 2.1e-181)
		tmp = t_1;
	elseif (t <= 2.7e-64)
		tmp = Float64(y * Float64(b - z));
	elseif (t <= 48000.0)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x + a) + z;
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -4.5e+73)
		tmp = t_2;
	elseif (t <= -1.55e-226)
		tmp = t_1;
	elseif (t <= 1.55e-288)
		tmp = x + (y * b);
	elseif (t <= 2.1e-181)
		tmp = t_1;
	elseif (t <= 2.7e-64)
		tmp = y * (b - z);
	elseif (t <= 48000.0)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + a), $MachinePrecision] + z), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.5e+73], t$95$2, If[LessEqual[t, -1.55e-226], t$95$1, If[LessEqual[t, 1.55e-288], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.1e-181], t$95$1, If[LessEqual[t, 2.7e-64], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 48000.0], t$95$1, t$95$2]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -4.49999999999999985e73 or 48000 < t

   1. Initial program 94.4%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.49999999999999985e73 < t < -1.54999999999999994e-226 or 1.54999999999999992e-288 < t < 2.10000000000000003e-181 or 2.69999999999999986e-64 < t < 48000

   1. Initial program 98.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.54999999999999994e-226 < t < 1.54999999999999992e-288

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 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.10000000000000003e-181 < t < 2.69999999999999986e-64

   1. Initial program 95.6%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 8: 56.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a + b \cdot \left(y + -2\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -7 \cdot 10^{+27}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -2.5 \cdot 10^{-225}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -1.9 \cdot 10^{-256}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;t \leq 1.32 \cdot 10^{-164}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 8 \cdot 10^{+30}:\\ \;\;\;\;a + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ a (* b (+ y -2.0)))) (t_2 (* t (- b a))))
   (if (<= t -7e+27)
     t_2
     (if (<= t -2.5e-225)
       t_1
       (if (<= t -1.9e-256)
         (+ x (* y b))
         (if (<= t 1.32e-164)
           t_1
           (if (<= t 8e+30) (+ a (* z (- 1.0 y))) t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a + (b * (y + -2.0));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -7e+27) {
		tmp = t_2;
	} else if (t <= -2.5e-225) {
		tmp = t_1;
	} else if (t <= -1.9e-256) {
		tmp = x + (y * b);
	} else if (t <= 1.32e-164) {
		tmp = t_1;
	} else if (t <= 8e+30) {
		tmp = a + (z * (1.0 - y));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a + (b * (y + (-2.0d0)))
    t_2 = t * (b - a)
    if (t <= (-7d+27)) then
        tmp = t_2
    else if (t <= (-2.5d-225)) then
        tmp = t_1
    else if (t <= (-1.9d-256)) then
        tmp = x + (y * b)
    else if (t <= 1.32d-164) then
        tmp = t_1
    else if (t <= 8d+30) then
        tmp = a + (z * (1.0d0 - y))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a + (b * (y + -2.0));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -7e+27) {
		tmp = t_2;
	} else if (t <= -2.5e-225) {
		tmp = t_1;
	} else if (t <= -1.9e-256) {
		tmp = x + (y * b);
	} else if (t <= 1.32e-164) {
		tmp = t_1;
	} else if (t <= 8e+30) {
		tmp = a + (z * (1.0 - y));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a + (b * (y + -2.0))
	t_2 = t * (b - a)
	tmp = 0
	if t <= -7e+27:
		tmp = t_2
	elif t <= -2.5e-225:
		tmp = t_1
	elif t <= -1.9e-256:
		tmp = x + (y * b)
	elif t <= 1.32e-164:
		tmp = t_1
	elif t <= 8e+30:
		tmp = a + (z * (1.0 - y))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a + Float64(b * Float64(y + -2.0)))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -7e+27)
		tmp = t_2;
	elseif (t <= -2.5e-225)
		tmp = t_1;
	elseif (t <= -1.9e-256)
		tmp = Float64(x + Float64(y * b));
	elseif (t <= 1.32e-164)
		tmp = t_1;
	elseif (t <= 8e+30)
		tmp = Float64(a + Float64(z * Float64(1.0 - y)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a + (b * (y + -2.0));
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -7e+27)
		tmp = t_2;
	elseif (t <= -2.5e-225)
		tmp = t_1;
	elseif (t <= -1.9e-256)
		tmp = x + (y * b);
	elseif (t <= 1.32e-164)
		tmp = t_1;
	elseif (t <= 8e+30)
		tmp = a + (z * (1.0 - y));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7e+27], t$95$2, If[LessEqual[t, -2.5e-225], t$95$1, If[LessEqual[t, -1.9e-256], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.32e-164], t$95$1, If[LessEqual[t, 8e+30], N[(a + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -7.0000000000000004e27 or 8.0000000000000002e30 < t

   1. Initial program 94.5%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.0000000000000004e27 < t < -2.5e-225 or -1.89999999999999988e-256 < t < 1.3199999999999999e-164

   1. Initial program 98.0%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.5e-225 < t < -1.89999999999999988e-256

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 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.3199999999999999e-164 < t < 8.0000000000000002e30

   1. Initial program 97.3%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 9: 56.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a + b \cdot \left(y + -2\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -9 \cdot 10^{+27}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -2.4 \cdot 10^{-226}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -2 \cdot 10^{-256}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;t \leq 7.2 \cdot 10^{-64}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 46:\\ \;\;\;\;\left(x + a\right) + z\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ a (* b (+ y -2.0)))) (t_2 (* t (- b a))))
   (if (<= t -9e+27)
     t_2
     (if (<= t -2.4e-226)
       t_1
       (if (<= t -2e-256)
         (+ x (* y b))
         (if (<= t 7.2e-64) t_1 (if (<= t 46.0) (+ (+ x a) z) t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a + (b * (y + -2.0));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -9e+27) {
		tmp = t_2;
	} else if (t <= -2.4e-226) {
		tmp = t_1;
	} else if (t <= -2e-256) {
		tmp = x + (y * b);
	} else if (t <= 7.2e-64) {
		tmp = t_1;
	} else if (t <= 46.0) {
		tmp = (x + a) + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a + (b * (y + (-2.0d0)))
    t_2 = t * (b - a)
    if (t <= (-9d+27)) then
        tmp = t_2
    else if (t <= (-2.4d-226)) then
        tmp = t_1
    else if (t <= (-2d-256)) then
        tmp = x + (y * b)
    else if (t <= 7.2d-64) then
        tmp = t_1
    else if (t <= 46.0d0) then
        tmp = (x + a) + z
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a + (b * (y + -2.0));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -9e+27) {
		tmp = t_2;
	} else if (t <= -2.4e-226) {
		tmp = t_1;
	} else if (t <= -2e-256) {
		tmp = x + (y * b);
	} else if (t <= 7.2e-64) {
		tmp = t_1;
	} else if (t <= 46.0) {
		tmp = (x + a) + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a + (b * (y + -2.0))
	t_2 = t * (b - a)
	tmp = 0
	if t <= -9e+27:
		tmp = t_2
	elif t <= -2.4e-226:
		tmp = t_1
	elif t <= -2e-256:
		tmp = x + (y * b)
	elif t <= 7.2e-64:
		tmp = t_1
	elif t <= 46.0:
		tmp = (x + a) + z
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a + Float64(b * Float64(y + -2.0)))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -9e+27)
		tmp = t_2;
	elseif (t <= -2.4e-226)
		tmp = t_1;
	elseif (t <= -2e-256)
		tmp = Float64(x + Float64(y * b));
	elseif (t <= 7.2e-64)
		tmp = t_1;
	elseif (t <= 46.0)
		tmp = Float64(Float64(x + a) + z);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a + (b * (y + -2.0));
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -9e+27)
		tmp = t_2;
	elseif (t <= -2.4e-226)
		tmp = t_1;
	elseif (t <= -2e-256)
		tmp = x + (y * b);
	elseif (t <= 7.2e-64)
		tmp = t_1;
	elseif (t <= 46.0)
		tmp = (x + a) + z;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a + N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9e+27], t$95$2, If[LessEqual[t, -2.4e-226], t$95$1, If[LessEqual[t, -2e-256], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.2e-64], t$95$1, If[LessEqual[t, 46.0], N[(N[(x + a), $MachinePrecision] + z), $MachinePrecision], t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -8.9999999999999998e27 or 46 < t

   1. Initial program 94.6%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.9999999999999998e27 < t < -2.4e-226 or -1.99999999999999995e-256 < t < 7.1999999999999996e-64

   1. Initial program 97.5%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.4e-226 < t < -1.99999999999999995e-256

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 7.1999999999999996e-64 < t < 46

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 10: 64.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot \left(1 - t\right)\\ t_2 := x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{if}\;b \leq -2.75 \cdot 10^{+42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 5.8 \cdot 10^{-292}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 1.45 \cdot 10^{-176}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+92}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a (- 1.0 t)))) (t_2 (+ x (* (- (+ y t) 2.0) b))))
   (if (<= b -2.75e+42)
     t_2
     (if (<= b 5.8e-292)
       t_1
       (if (<= b 1.45e-176)
         (+ x (* z (- 1.0 y)))
         (if (<= b 3.8e+92) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -2.75e+42) {
		tmp = t_2;
	} else if (b <= 5.8e-292) {
		tmp = t_1;
	} else if (b <= 1.45e-176) {
		tmp = x + (z * (1.0 - y));
	} else if (b <= 3.8e+92) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + (a * (1.0d0 - t))
    t_2 = x + (((y + t) - 2.0d0) * b)
    if (b <= (-2.75d+42)) then
        tmp = t_2
    else if (b <= 5.8d-292) then
        tmp = t_1
    else if (b <= 1.45d-176) then
        tmp = x + (z * (1.0d0 - y))
    else if (b <= 3.8d+92) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -2.75e+42) {
		tmp = t_2;
	} else if (b <= 5.8e-292) {
		tmp = t_1;
	} else if (b <= 1.45e-176) {
		tmp = x + (z * (1.0 - y));
	} else if (b <= 3.8e+92) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * (1.0 - t))
	t_2 = x + (((y + t) - 2.0) * b)
	tmp = 0
	if b <= -2.75e+42:
		tmp = t_2
	elif b <= 5.8e-292:
		tmp = t_1
	elif b <= 1.45e-176:
		tmp = x + (z * (1.0 - y))
	elif b <= 3.8e+92:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * Float64(1.0 - t)))
	t_2 = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b))
	tmp = 0.0
	if (b <= -2.75e+42)
		tmp = t_2;
	elseif (b <= 5.8e-292)
		tmp = t_1;
	elseif (b <= 1.45e-176)
		tmp = Float64(x + Float64(z * Float64(1.0 - y)));
	elseif (b <= 3.8e+92)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * (1.0 - t));
	t_2 = x + (((y + t) - 2.0) * b);
	tmp = 0.0;
	if (b <= -2.75e+42)
		tmp = t_2;
	elseif (b <= 5.8e-292)
		tmp = t_1;
	elseif (b <= 1.45e-176)
		tmp = x + (z * (1.0 - y));
	elseif (b <= 3.8e+92)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.75e+42], t$95$2, If[LessEqual[b, 5.8e-292], t$95$1, If[LessEqual[b, 1.45e-176], N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.8e+92], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -2.75000000000000001e42 or 3.8e92 < b

   1. Initial program 93.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.75000000000000001e42 < b < 5.79999999999999985e-292 or 1.45000000000000003e-176 < b < 3.8e92

   1. Initial program 98.4%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.79999999999999985e-292 < b < 1.45000000000000003e-176

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 11: 27.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.75 \cdot 10^{+35}:\\ \;\;\;\;b \cdot t\\ \mathbf{elif}\;t \leq -8.5 \cdot 10^{-97}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 3.9 \cdot 10^{-296}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 2.5 \cdot 10^{-66}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 55000:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;b \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -1.75e+35)
   (* b t)
   (if (<= t -8.5e-97)
     (* y b)
     (if (<= t 3.9e-296)
       x
       (if (<= t 2.5e-66) (* y b) (if (<= t 55000.0) x (* b t)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1.75e+35) {
		tmp = b * t;
	} else if (t <= -8.5e-97) {
		tmp = y * b;
	} else if (t <= 3.9e-296) {
		tmp = x;
	} else if (t <= 2.5e-66) {
		tmp = y * b;
	} else if (t <= 55000.0) {
		tmp = x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-1.75d+35)) then
        tmp = b * t
    else if (t <= (-8.5d-97)) then
        tmp = y * b
    else if (t <= 3.9d-296) then
        tmp = x
    else if (t <= 2.5d-66) then
        tmp = y * b
    else if (t <= 55000.0d0) then
        tmp = x
    else
        tmp = b * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1.75e+35) {
		tmp = b * t;
	} else if (t <= -8.5e-97) {
		tmp = y * b;
	} else if (t <= 3.9e-296) {
		tmp = x;
	} else if (t <= 2.5e-66) {
		tmp = y * b;
	} else if (t <= 55000.0) {
		tmp = x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -1.75e+35:
		tmp = b * t
	elif t <= -8.5e-97:
		tmp = y * b
	elif t <= 3.9e-296:
		tmp = x
	elif t <= 2.5e-66:
		tmp = y * b
	elif t <= 55000.0:
		tmp = x
	else:
		tmp = b * t
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -1.75e+35)
		tmp = Float64(b * t);
	elseif (t <= -8.5e-97)
		tmp = Float64(y * b);
	elseif (t <= 3.9e-296)
		tmp = x;
	elseif (t <= 2.5e-66)
		tmp = Float64(y * b);
	elseif (t <= 55000.0)
		tmp = x;
	else
		tmp = Float64(b * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -1.75e+35)
		tmp = b * t;
	elseif (t <= -8.5e-97)
		tmp = y * b;
	elseif (t <= 3.9e-296)
		tmp = x;
	elseif (t <= 2.5e-66)
		tmp = y * b;
	elseif (t <= 55000.0)
		tmp = x;
	else
		tmp = b * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.75e+35], N[(b * t), $MachinePrecision], If[LessEqual[t, -8.5e-97], N[(y * b), $MachinePrecision], If[LessEqual[t, 3.9e-296], x, If[LessEqual[t, 2.5e-66], N[(y * b), $MachinePrecision], If[LessEqual[t, 55000.0], x, N[(b * t), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.75e35 or 55000 < t

   1. Initial program 94.6%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.75e35 < t < -8.5000000000000002e-97 or 3.9000000000000001e-296 < t < 2.49999999999999981e-66

   1. Initial program 98.6%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -8.5000000000000002e-97 < t < 3.9000000000000001e-296 or 2.49999999999999981e-66 < t < 55000

   1. Initial program 97.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 12: 61.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot \left(1 - t\right)\\ t_2 := b \cdot \left(t + \left(y + -2\right)\right)\\ \mathbf{if}\;b \leq -4.8 \cdot 10^{+42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 3.25 \cdot 10^{-292}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{-175}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{+127}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a (- 1.0 t)))) (t_2 (* b (+ t (+ y -2.0)))))
   (if (<= b -4.8e+42)
     t_2
     (if (<= b 3.25e-292)
       t_1
       (if (<= b 9.5e-175)
         (+ x (* z (- 1.0 y)))
         (if (<= b 9.5e+127) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -4.8e+42) {
		tmp = t_2;
	} else if (b <= 3.25e-292) {
		tmp = t_1;
	} else if (b <= 9.5e-175) {
		tmp = x + (z * (1.0 - y));
	} else if (b <= 9.5e+127) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + (a * (1.0d0 - t))
    t_2 = b * (t + (y + (-2.0d0)))
    if (b <= (-4.8d+42)) then
        tmp = t_2
    else if (b <= 3.25d-292) then
        tmp = t_1
    else if (b <= 9.5d-175) then
        tmp = x + (z * (1.0d0 - y))
    else if (b <= 9.5d+127) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -4.8e+42) {
		tmp = t_2;
	} else if (b <= 3.25e-292) {
		tmp = t_1;
	} else if (b <= 9.5e-175) {
		tmp = x + (z * (1.0 - y));
	} else if (b <= 9.5e+127) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * (1.0 - t))
	t_2 = b * (t + (y + -2.0))
	tmp = 0
	if b <= -4.8e+42:
		tmp = t_2
	elif b <= 3.25e-292:
		tmp = t_1
	elif b <= 9.5e-175:
		tmp = x + (z * (1.0 - y))
	elif b <= 9.5e+127:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * Float64(1.0 - t)))
	t_2 = Float64(b * Float64(t + Float64(y + -2.0)))
	tmp = 0.0
	if (b <= -4.8e+42)
		tmp = t_2;
	elseif (b <= 3.25e-292)
		tmp = t_1;
	elseif (b <= 9.5e-175)
		tmp = Float64(x + Float64(z * Float64(1.0 - y)));
	elseif (b <= 9.5e+127)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * (1.0 - t));
	t_2 = b * (t + (y + -2.0));
	tmp = 0.0;
	if (b <= -4.8e+42)
		tmp = t_2;
	elseif (b <= 3.25e-292)
		tmp = t_1;
	elseif (b <= 9.5e-175)
		tmp = x + (z * (1.0 - y));
	elseif (b <= 9.5e+127)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(t + N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.8e+42], t$95$2, If[LessEqual[b, 3.25e-292], t$95$1, If[LessEqual[b, 9.5e-175], N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.5e+127], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -4.7999999999999997e42 or 9.49999999999999975e127 < b

   1. Initial program 93.0%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.7999999999999997e42 < b < 3.2499999999999998e-292 or 9.50000000000000052e-175 < b < 9.49999999999999975e127

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.2499999999999998e-292 < b < 9.50000000000000052e-175

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 13: 60.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot \left(1 - t\right)\\ t_2 := b \cdot \left(t + \left(y + -2\right)\right)\\ \mathbf{if}\;b \leq -1.4 \cdot 10^{+42}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 7.9 \cdot 10^{-293}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{-209}:\\ \;\;\;\;\left(x + a\right) + z\\ \mathbf{elif}\;b \leq 9 \cdot 10^{+127}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a (- 1.0 t)))) (t_2 (* b (+ t (+ y -2.0)))))
   (if (<= b -1.4e+42)
     t_2
     (if (<= b 7.9e-293)
       t_1
       (if (<= b 3.4e-209) (+ (+ x a) z) (if (<= b 9e+127) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -1.4e+42) {
		tmp = t_2;
	} else if (b <= 7.9e-293) {
		tmp = t_1;
	} else if (b <= 3.4e-209) {
		tmp = (x + a) + z;
	} else if (b <= 9e+127) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + (a * (1.0d0 - t))
    t_2 = b * (t + (y + (-2.0d0)))
    if (b <= (-1.4d+42)) then
        tmp = t_2
    else if (b <= 7.9d-293) then
        tmp = t_1
    else if (b <= 3.4d-209) then
        tmp = (x + a) + z
    else if (b <= 9d+127) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -1.4e+42) {
		tmp = t_2;
	} else if (b <= 7.9e-293) {
		tmp = t_1;
	} else if (b <= 3.4e-209) {
		tmp = (x + a) + z;
	} else if (b <= 9e+127) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * (1.0 - t))
	t_2 = b * (t + (y + -2.0))
	tmp = 0
	if b <= -1.4e+42:
		tmp = t_2
	elif b <= 7.9e-293:
		tmp = t_1
	elif b <= 3.4e-209:
		tmp = (x + a) + z
	elif b <= 9e+127:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * Float64(1.0 - t)))
	t_2 = Float64(b * Float64(t + Float64(y + -2.0)))
	tmp = 0.0
	if (b <= -1.4e+42)
		tmp = t_2;
	elseif (b <= 7.9e-293)
		tmp = t_1;
	elseif (b <= 3.4e-209)
		tmp = Float64(Float64(x + a) + z);
	elseif (b <= 9e+127)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * (1.0 - t));
	t_2 = b * (t + (y + -2.0));
	tmp = 0.0;
	if (b <= -1.4e+42)
		tmp = t_2;
	elseif (b <= 7.9e-293)
		tmp = t_1;
	elseif (b <= 3.4e-209)
		tmp = (x + a) + z;
	elseif (b <= 9e+127)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(t + N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.4e+42], t$95$2, If[LessEqual[b, 7.9e-293], t$95$1, If[LessEqual[b, 3.4e-209], N[(N[(x + a), $MachinePrecision] + z), $MachinePrecision], If[LessEqual[b, 9e+127], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.4e42 or 9.00000000000000068e127 < b

   1. Initial program 93.0%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.4e42 < b < 7.9000000000000002e-293 or 3.39999999999999988e-209 < b < 9.00000000000000068e127

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 7.9000000000000002e-293 < b < 3.39999999999999988e-209

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 14: 55.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(t + \left(y + -2\right)\right)\\ \mathbf{if}\;b \leq -2.75 \cdot 10^{+42}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{+35}:\\ \;\;\;\;\left(x + a\right) + z\\ \mathbf{elif}\;b \leq 4.7 \cdot 10^{+92}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 2.1 \cdot 10^{+124}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (+ t (+ y -2.0)))))
   (if (<= b -2.75e+42)
     t_1
     (if (<= b 9.5e+35)
       (+ (+ x a) z)
       (if (<= b 4.7e+92)
         (* a (- 1.0 t))
         (if (<= b 2.1e+124) (+ x (* y b)) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -2.75e+42) {
		tmp = t_1;
	} else if (b <= 9.5e+35) {
		tmp = (x + a) + z;
	} else if (b <= 4.7e+92) {
		tmp = a * (1.0 - t);
	} else if (b <= 2.1e+124) {
		tmp = x + (y * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = b * (t + (y + (-2.0d0)))
    if (b <= (-2.75d+42)) then
        tmp = t_1
    else if (b <= 9.5d+35) then
        tmp = (x + a) + z
    else if (b <= 4.7d+92) then
        tmp = a * (1.0d0 - t)
    else if (b <= 2.1d+124) then
        tmp = x + (y * b)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (t + (y + -2.0));
	double tmp;
	if (b <= -2.75e+42) {
		tmp = t_1;
	} else if (b <= 9.5e+35) {
		tmp = (x + a) + z;
	} else if (b <= 4.7e+92) {
		tmp = a * (1.0 - t);
	} else if (b <= 2.1e+124) {
		tmp = x + (y * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * (t + (y + -2.0))
	tmp = 0
	if b <= -2.75e+42:
		tmp = t_1
	elif b <= 9.5e+35:
		tmp = (x + a) + z
	elif b <= 4.7e+92:
		tmp = a * (1.0 - t)
	elif b <= 2.1e+124:
		tmp = x + (y * b)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(t + Float64(y + -2.0)))
	tmp = 0.0
	if (b <= -2.75e+42)
		tmp = t_1;
	elseif (b <= 9.5e+35)
		tmp = Float64(Float64(x + a) + z);
	elseif (b <= 4.7e+92)
		tmp = Float64(a * Float64(1.0 - t));
	elseif (b <= 2.1e+124)
		tmp = Float64(x + Float64(y * b));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = b * (t + (y + -2.0));
	tmp = 0.0;
	if (b <= -2.75e+42)
		tmp = t_1;
	elseif (b <= 9.5e+35)
		tmp = (x + a) + z;
	elseif (b <= 4.7e+92)
		tmp = a * (1.0 - t);
	elseif (b <= 2.1e+124)
		tmp = x + (y * b);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(t + N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.75e+42], t$95$1, If[LessEqual[b, 9.5e+35], N[(N[(x + a), $MachinePrecision] + z), $MachinePrecision], If[LessEqual[b, 4.7e+92], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.1e+124], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -2.75000000000000001e42 or 2.10000000000000011e124 < b

   1. Initial program 93.1%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.75000000000000001e42 < b < 9.50000000000000062e35

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 9.50000000000000062e35 < b < 4.7e92

   1. Initial program 100.0%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 4.7e92 < b < 2.10000000000000011e124

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 15: 49.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -3.1 \cdot 10^{+66}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 3.5 \cdot 10^{-206}:\\ \;\;\;\;a + x\\ \mathbf{elif}\;t \leq 2.8 \cdot 10^{-65}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 3800:\\ \;\;\;\;a + x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))))
   (if (<= t -3.1e+66)
     t_1
     (if (<= t 3.5e-206)
       (+ a x)
       (if (<= t 2.8e-65) (* b (- y 2.0)) (if (<= t 3800.0) (+ a x) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -3.1e+66) {
		tmp = t_1;
	} else if (t <= 3.5e-206) {
		tmp = a + x;
	} else if (t <= 2.8e-65) {
		tmp = b * (y - 2.0);
	} else if (t <= 3800.0) {
		tmp = a + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * (b - a)
    if (t <= (-3.1d+66)) then
        tmp = t_1
    else if (t <= 3.5d-206) then
        tmp = a + x
    else if (t <= 2.8d-65) then
        tmp = b * (y - 2.0d0)
    else if (t <= 3800.0d0) then
        tmp = a + x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -3.1e+66) {
		tmp = t_1;
	} else if (t <= 3.5e-206) {
		tmp = a + x;
	} else if (t <= 2.8e-65) {
		tmp = b * (y - 2.0);
	} else if (t <= 3800.0) {
		tmp = a + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -3.1e+66:
		tmp = t_1
	elif t <= 3.5e-206:
		tmp = a + x
	elif t <= 2.8e-65:
		tmp = b * (y - 2.0)
	elif t <= 3800.0:
		tmp = a + x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -3.1e+66)
		tmp = t_1;
	elseif (t <= 3.5e-206)
		tmp = Float64(a + x);
	elseif (t <= 2.8e-65)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 3800.0)
		tmp = Float64(a + x);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	tmp = 0.0;
	if (t <= -3.1e+66)
		tmp = t_1;
	elseif (t <= 3.5e-206)
		tmp = a + x;
	elseif (t <= 2.8e-65)
		tmp = b * (y - 2.0);
	elseif (t <= 3800.0)
		tmp = a + x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.1e+66], t$95$1, If[LessEqual[t, 3.5e-206], N[(a + x), $MachinePrecision], If[LessEqual[t, 2.8e-65], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3800.0], N[(a + x), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.10000000000000019e66 or 3800 < t

   1. Initial program 94.4%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.10000000000000019e66 < t < 3.49999999999999989e-206 or 2.8e-65 < t < 3800

   1. Initial program 98.3%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 3.49999999999999989e-206 < t < 2.8e-65

   1. Initial program 96.1%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 16: 39.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := b \cdot \left(t + -2\right)\\ \mathbf{if}\;b \leq -3.6 \cdot 10^{+47}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 5.5 \cdot 10^{-292}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 7.5 \cdot 10^{-117}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;b \leq 1.6 \cdot 10^{+128}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))) (t_2 (* b (+ t -2.0))))
   (if (<= b -3.6e+47)
     t_2
     (if (<= b 5.5e-292)
       t_1
       (if (<= b 7.5e-117) (+ x z) (if (<= b 1.6e+128) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = b * (t + -2.0);
	double tmp;
	if (b <= -3.6e+47) {
		tmp = t_2;
	} else if (b <= 5.5e-292) {
		tmp = t_1;
	} else if (b <= 7.5e-117) {
		tmp = x + z;
	} else if (b <= 1.6e+128) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = b * (t + (-2.0d0))
    if (b <= (-3.6d+47)) then
        tmp = t_2
    else if (b <= 5.5d-292) then
        tmp = t_1
    else if (b <= 7.5d-117) then
        tmp = x + z
    else if (b <= 1.6d+128) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = b * (t + -2.0);
	double tmp;
	if (b <= -3.6e+47) {
		tmp = t_2;
	} else if (b <= 5.5e-292) {
		tmp = t_1;
	} else if (b <= 7.5e-117) {
		tmp = x + z;
	} else if (b <= 1.6e+128) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = b * (t + -2.0)
	tmp = 0
	if b <= -3.6e+47:
		tmp = t_2
	elif b <= 5.5e-292:
		tmp = t_1
	elif b <= 7.5e-117:
		tmp = x + z
	elif b <= 1.6e+128:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(b * Float64(t + -2.0))
	tmp = 0.0
	if (b <= -3.6e+47)
		tmp = t_2;
	elseif (b <= 5.5e-292)
		tmp = t_1;
	elseif (b <= 7.5e-117)
		tmp = Float64(x + z);
	elseif (b <= 1.6e+128)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	t_2 = b * (t + -2.0);
	tmp = 0.0;
	if (b <= -3.6e+47)
		tmp = t_2;
	elseif (b <= 5.5e-292)
		tmp = t_1;
	elseif (b <= 7.5e-117)
		tmp = x + z;
	elseif (b <= 1.6e+128)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(t + -2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.6e+47], t$95$2, If[LessEqual[b, 5.5e-292], t$95$1, If[LessEqual[b, 7.5e-117], N[(x + z), $MachinePrecision], If[LessEqual[b, 1.6e+128], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -3.60000000000000008e47 or 1.59999999999999993e128 < b

   1. Initial program 93.0%

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

   3. Taylor expanded in b 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.60000000000000008e47 < b < 5.50000000000000006e-292 or 7.50000000000000066e-117 < b < 1.59999999999999993e128

   1. Initial program 98.3%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 5.50000000000000006e-292 < b < 7.50000000000000066e-117

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   14. Simplified 0

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

Alternative 17: 40.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;a \leq -2.3 \cdot 10^{-67}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -3.75 \cdot 10^{-174}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;a \leq -2.5 \cdot 10^{-285}:\\ \;\;\;\;b \cdot t\\ \mathbf{elif}\;a \leq 1.8 \cdot 10^{+56}:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (<= a -2.3e-67)
     t_1
     (if (<= a -3.75e-174)
       (+ x z)
       (if (<= a -2.5e-285) (* b t) (if (<= a 1.8e+56) (+ x z) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (a <= -2.3e-67) {
		tmp = t_1;
	} else if (a <= -3.75e-174) {
		tmp = x + z;
	} else if (a <= -2.5e-285) {
		tmp = b * t;
	} else if (a <= 1.8e+56) {
		tmp = x + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    if (a <= (-2.3d-67)) then
        tmp = t_1
    else if (a <= (-3.75d-174)) then
        tmp = x + z
    else if (a <= (-2.5d-285)) then
        tmp = b * t
    else if (a <= 1.8d+56) then
        tmp = x + z
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (a <= -2.3e-67) {
		tmp = t_1;
	} else if (a <= -3.75e-174) {
		tmp = x + z;
	} else if (a <= -2.5e-285) {
		tmp = b * t;
	} else if (a <= 1.8e+56) {
		tmp = x + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	tmp = 0
	if a <= -2.3e-67:
		tmp = t_1
	elif a <= -3.75e-174:
		tmp = x + z
	elif a <= -2.5e-285:
		tmp = b * t
	elif a <= 1.8e+56:
		tmp = x + z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	tmp = 0.0
	if (a <= -2.3e-67)
		tmp = t_1;
	elseif (a <= -3.75e-174)
		tmp = Float64(x + z);
	elseif (a <= -2.5e-285)
		tmp = Float64(b * t);
	elseif (a <= 1.8e+56)
		tmp = Float64(x + z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	tmp = 0.0;
	if (a <= -2.3e-67)
		tmp = t_1;
	elseif (a <= -3.75e-174)
		tmp = x + z;
	elseif (a <= -2.5e-285)
		tmp = b * t;
	elseif (a <= 1.8e+56)
		tmp = x + z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.3e-67], t$95$1, If[LessEqual[a, -3.75e-174], N[(x + z), $MachinePrecision], If[LessEqual[a, -2.5e-285], N[(b * t), $MachinePrecision], If[LessEqual[a, 1.8e+56], N[(x + z), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if a < -2.3e-67 or 1.79999999999999999e56 < a

   1. Initial program 93.3%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.3e-67 < a < -3.7500000000000002e-174 or -2.50000000000000009e-285 < a < 1.79999999999999999e56

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]

   if -3.7500000000000002e-174 < a < -2.50000000000000009e-285

   1. Initial program 100.0%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 18: 69.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{if}\;b \leq -1.95 \cdot 10^{-51}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 4 \cdot 10^{-86}:\\ \;\;\;\;\left(x + a\right) + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+92}:\\ \;\;\;\;x + a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* (- (+ y t) 2.0) b))))
   (if (<= b -1.95e-51)
     t_1
     (if (<= b 4e-86)
       (+ (+ x a) (* z (- 1.0 y)))
       (if (<= b 3.8e+92) (+ x (* a (- 1.0 t))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -1.95e-51) {
		tmp = t_1;
	} else if (b <= 4e-86) {
		tmp = (x + a) + (z * (1.0 - y));
	} else if (b <= 3.8e+92) {
		tmp = x + (a * (1.0 - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x + (((y + t) - 2.0d0) * b)
    if (b <= (-1.95d-51)) then
        tmp = t_1
    else if (b <= 4d-86) then
        tmp = (x + a) + (z * (1.0d0 - y))
    else if (b <= 3.8d+92) then
        tmp = x + (a * (1.0d0 - 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 b) {
	double t_1 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -1.95e-51) {
		tmp = t_1;
	} else if (b <= 4e-86) {
		tmp = (x + a) + (z * (1.0 - y));
	} else if (b <= 3.8e+92) {
		tmp = x + (a * (1.0 - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (((y + t) - 2.0) * b)
	tmp = 0
	if b <= -1.95e-51:
		tmp = t_1
	elif b <= 4e-86:
		tmp = (x + a) + (z * (1.0 - y))
	elif b <= 3.8e+92:
		tmp = x + (a * (1.0 - t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b))
	tmp = 0.0
	if (b <= -1.95e-51)
		tmp = t_1;
	elseif (b <= 4e-86)
		tmp = Float64(Float64(x + a) + Float64(z * Float64(1.0 - y)));
	elseif (b <= 3.8e+92)
		tmp = Float64(x + Float64(a * Float64(1.0 - t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (((y + t) - 2.0) * b);
	tmp = 0.0;
	if (b <= -1.95e-51)
		tmp = t_1;
	elseif (b <= 4e-86)
		tmp = (x + a) + (z * (1.0 - y));
	elseif (b <= 3.8e+92)
		tmp = x + (a * (1.0 - t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.95e-51], t$95$1, If[LessEqual[b, 4e-86], N[(N[(x + a), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.8e+92], N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.9499999999999999e-51 or 3.8e92 < b

   1. Initial program 93.9%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.9499999999999999e-51 < b < 4.00000000000000034e-86

   1. Initial program 98.9%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 4.00000000000000034e-86 < b < 3.8e92

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 19: 83.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;b \leq -6.8 \cdot 10^{+18}:\\ \;\;\;\;t\_1 + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{elif}\;b \leq 10^{+128}:\\ \;\;\;\;\left(x + t\_1\right) + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x + \left(y + t\right) \cdot b\right) + b \cdot -2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (<= b -6.8e+18)
     (+ t_1 (* (- (+ y t) 2.0) b))
     (if (<= b 1e+128)
       (+ (+ x t_1) (* z (- 1.0 y)))
       (+ (+ x (* (+ y t) b)) (* b -2.0))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (b <= -6.8e+18) {
		tmp = t_1 + (((y + t) - 2.0) * b);
	} else if (b <= 1e+128) {
		tmp = (x + t_1) + (z * (1.0 - y));
	} else {
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    if (b <= (-6.8d+18)) then
        tmp = t_1 + (((y + t) - 2.0d0) * b)
    else if (b <= 1d+128) then
        tmp = (x + t_1) + (z * (1.0d0 - y))
    else
        tmp = (x + ((y + t) * b)) + (b * (-2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (b <= -6.8e+18) {
		tmp = t_1 + (((y + t) - 2.0) * b);
	} else if (b <= 1e+128) {
		tmp = (x + t_1) + (z * (1.0 - y));
	} else {
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	tmp = 0
	if b <= -6.8e+18:
		tmp = t_1 + (((y + t) - 2.0) * b)
	elif b <= 1e+128:
		tmp = (x + t_1) + (z * (1.0 - y))
	else:
		tmp = (x + ((y + t) * b)) + (b * -2.0)
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	tmp = 0.0
	if (b <= -6.8e+18)
		tmp = Float64(t_1 + Float64(Float64(Float64(y + t) - 2.0) * b));
	elseif (b <= 1e+128)
		tmp = Float64(Float64(x + t_1) + Float64(z * Float64(1.0 - y)));
	else
		tmp = Float64(Float64(x + Float64(Float64(y + t) * b)) + Float64(b * -2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	tmp = 0.0;
	if (b <= -6.8e+18)
		tmp = t_1 + (((y + t) - 2.0) * b);
	elseif (b <= 1e+128)
		tmp = (x + t_1) + (z * (1.0 - y));
	else
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.8e+18], N[(t$95$1 + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+128], N[(N[(x + t$95$1), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(N[(y + t), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if b < -6.8e18

   1. Initial program 89.4%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.8e18 < b < 1.0000000000000001e128

   1. Initial program 99.3%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.0000000000000001e128 < b

   1. Initial program 97.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 20: 71.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := t\_1 + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{if}\;b \leq -7.6 \cdot 10^{+20}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 2.2 \cdot 10^{+73}:\\ \;\;\;\;\left(x + t\_1\right) + z\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))) (t_2 (+ t_1 (* (- (+ y t) 2.0) b))))
   (if (<= b -7.6e+20) t_2 (if (<= b 2.2e+73) (+ (+ x t_1) z) t_2))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = t_1 + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -7.6e+20) {
		tmp = t_2;
	} else if (b <= 2.2e+73) {
		tmp = (x + t_1) + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = t_1 + (((y + t) - 2.0d0) * b)
    if (b <= (-7.6d+20)) then
        tmp = t_2
    else if (b <= 2.2d+73) then
        tmp = (x + t_1) + z
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = t_1 + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -7.6e+20) {
		tmp = t_2;
	} else if (b <= 2.2e+73) {
		tmp = (x + t_1) + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = t_1 + (((y + t) - 2.0) * b)
	tmp = 0
	if b <= -7.6e+20:
		tmp = t_2
	elif b <= 2.2e+73:
		tmp = (x + t_1) + z
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(t_1 + Float64(Float64(Float64(y + t) - 2.0) * b))
	tmp = 0.0
	if (b <= -7.6e+20)
		tmp = t_2;
	elseif (b <= 2.2e+73)
		tmp = Float64(Float64(x + t_1) + z);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	t_2 = t_1 + (((y + t) - 2.0) * b);
	tmp = 0.0;
	if (b <= -7.6e+20)
		tmp = t_2;
	elseif (b <= 2.2e+73)
		tmp = (x + t_1) + z;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.6e+20], t$95$2, If[LessEqual[b, 2.2e+73], N[(N[(x + t$95$1), $MachinePrecision] + z), $MachinePrecision], t$95$2]]]]

Derivation

1. Split input into 2 regimes

2. if b < -7.6e20 or 2.2e73 < b

   1. Initial program 94.3%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.6e20 < b < 2.2e73

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 21: 72.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -3.15 \cdot 10^{+42}:\\ \;\;\;\;x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+92}:\\ \;\;\;\;\left(x + a \cdot \left(1 - t\right)\right) + z\\ \mathbf{else}:\\ \;\;\;\;\left(x + \left(y + t\right) \cdot b\right) + b \cdot -2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= b -3.15e+42)
   (+ x (* (- (+ y t) 2.0) b))
   (if (<= b 3.8e+92)
     (+ (+ x (* a (- 1.0 t))) z)
     (+ (+ x (* (+ y t) b)) (* b -2.0)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -3.15e+42) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (b <= 3.8e+92) {
		tmp = (x + (a * (1.0 - t))) + z;
	} else {
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (b <= (-3.15d+42)) then
        tmp = x + (((y + t) - 2.0d0) * b)
    else if (b <= 3.8d+92) then
        tmp = (x + (a * (1.0d0 - t))) + z
    else
        tmp = (x + ((y + t) * b)) + (b * (-2.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -3.15e+42) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (b <= 3.8e+92) {
		tmp = (x + (a * (1.0 - t))) + z;
	} else {
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= -3.15e+42:
		tmp = x + (((y + t) - 2.0) * b)
	elif b <= 3.8e+92:
		tmp = (x + (a * (1.0 - t))) + z
	else:
		tmp = (x + ((y + t) * b)) + (b * -2.0)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= -3.15e+42)
		tmp = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b));
	elseif (b <= 3.8e+92)
		tmp = Float64(Float64(x + Float64(a * Float64(1.0 - t))) + z);
	else
		tmp = Float64(Float64(x + Float64(Float64(y + t) * b)) + Float64(b * -2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= -3.15e+42)
		tmp = x + (((y + t) - 2.0) * b);
	elseif (b <= 3.8e+92)
		tmp = (x + (a * (1.0 - t))) + z;
	else
		tmp = (x + ((y + t) * b)) + (b * -2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -3.15e+42], N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.8e+92], N[(N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision], N[(N[(x + N[(N[(y + t), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] + N[(b * -2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -3.14999999999999978e42

   1. Initial program 89.4%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.14999999999999978e42 < b < 3.8e92

   1. Initial program 98.6%

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

   3. Taylor expanded in b around 0 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.8e92 < b

   1. Initial program 98.1%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 22: 72.3% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{if}\;b \leq -4.9 \cdot 10^{+42}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 3.9 \cdot 10^{+92}:\\ \;\;\;\;\left(x + a \cdot \left(1 - t\right)\right) + z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* (- (+ y t) 2.0) b))))
   (if (<= b -4.9e+42)
     t_1
     (if (<= b 3.9e+92) (+ (+ x (* a (- 1.0 t))) z) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -4.9e+42) {
		tmp = t_1;
	} else if (b <= 3.9e+92) {
		tmp = (x + (a * (1.0 - t))) + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x + (((y + t) - 2.0d0) * b)
    if (b <= (-4.9d+42)) then
        tmp = t_1
    else if (b <= 3.9d+92) then
        tmp = (x + (a * (1.0d0 - t))) + z
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (((y + t) - 2.0) * b);
	double tmp;
	if (b <= -4.9e+42) {
		tmp = t_1;
	} else if (b <= 3.9e+92) {
		tmp = (x + (a * (1.0 - t))) + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (((y + t) - 2.0) * b)
	tmp = 0
	if b <= -4.9e+42:
		tmp = t_1
	elif b <= 3.9e+92:
		tmp = (x + (a * (1.0 - t))) + z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b))
	tmp = 0.0
	if (b <= -4.9e+42)
		tmp = t_1;
	elseif (b <= 3.9e+92)
		tmp = Float64(Float64(x + Float64(a * Float64(1.0 - t))) + z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (((y + t) - 2.0) * b);
	tmp = 0.0;
	if (b <= -4.9e+42)
		tmp = t_1;
	elseif (b <= 3.9e+92)
		tmp = (x + (a * (1.0 - t))) + z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.9e+42], t$95$1, If[LessEqual[b, 3.9e+92], N[(N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if b < -4.9000000000000002e42 or 3.90000000000000011e92 < b

   1. Initial program 93.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.9000000000000002e42 < b < 3.90000000000000011e92

   1. Initial program 98.6%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 23: 36.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -5.8 \cdot 10^{+85}:\\ \;\;\;\;b \cdot t\\ \mathbf{elif}\;t \leq 52000:\\ \;\;\;\;a + x\\ \mathbf{else}:\\ \;\;\;\;b \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -5.8e+85) (* b t) (if (<= t 52000.0) (+ a x) (* b t))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -5.8e+85) {
		tmp = b * t;
	} else if (t <= 52000.0) {
		tmp = a + x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-5.8d+85)) then
        tmp = b * t
    else if (t <= 52000.0d0) then
        tmp = a + x
    else
        tmp = b * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -5.8e+85) {
		tmp = b * t;
	} else if (t <= 52000.0) {
		tmp = a + x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -5.8e+85:
		tmp = b * t
	elif t <= 52000.0:
		tmp = a + x
	else:
		tmp = b * t
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -5.8e+85)
		tmp = Float64(b * t);
	elseif (t <= 52000.0)
		tmp = Float64(a + x);
	else
		tmp = Float64(b * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -5.8e+85)
		tmp = b * t;
	elseif (t <= 52000.0)
		tmp = a + x;
	else
		tmp = b * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -5.8e+85], N[(b * t), $MachinePrecision], If[LessEqual[t, 52000.0], N[(a + x), $MachinePrecision], N[(b * t), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if t < -5.79999999999999995e85 or 52000 < t

   1. Initial program 94.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -5.79999999999999995e85 < t < 52000

   1. Initial program 98.0%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 24: 27.7% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -9 \cdot 10^{+85}:\\ \;\;\;\;b \cdot t\\ \mathbf{elif}\;t \leq 62000:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;b \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -9e+85) (* b t) (if (<= t 62000.0) x (* b t))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -9e+85) {
		tmp = b * t;
	} else if (t <= 62000.0) {
		tmp = x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-9d+85)) then
        tmp = b * t
    else if (t <= 62000.0d0) then
        tmp = x
    else
        tmp = b * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -9e+85) {
		tmp = b * t;
	} else if (t <= 62000.0) {
		tmp = x;
	} else {
		tmp = b * t;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -9e+85:
		tmp = b * t
	elif t <= 62000.0:
		tmp = x
	else:
		tmp = b * t
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -9e+85)
		tmp = Float64(b * t);
	elseif (t <= 62000.0)
		tmp = x;
	else
		tmp = Float64(b * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -9e+85)
		tmp = b * t;
	elseif (t <= 62000.0)
		tmp = x;
	else
		tmp = b * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -9e+85], N[(b * t), $MachinePrecision], If[LessEqual[t, 62000.0], x, N[(b * t), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if t < -9.00000000000000013e85 or 62000 < t

   1. Initial program 94.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -9.00000000000000013e85 < t < 62000

   1. Initial program 98.0%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 25: 21.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -7.8 \cdot 10^{+35}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 8.8 \cdot 10^{+74}:\\ \;\;\;\;a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -7.8e+35) x (if (<= x 8.8e+74) a x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -7.8e+35) {
		tmp = x;
	} else if (x <= 8.8e+74) {
		tmp = a;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (x <= (-7.8d+35)) then
        tmp = x
    else if (x <= 8.8d+74) then
        tmp = a
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -7.8e+35) {
		tmp = x;
	} else if (x <= 8.8e+74) {
		tmp = a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -7.8e+35:
		tmp = x
	elif x <= 8.8e+74:
		tmp = a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -7.8e+35)
		tmp = x;
	elseif (x <= 8.8e+74)
		tmp = a;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -7.8e+35)
		tmp = x;
	elseif (x <= 8.8e+74)
		tmp = a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -7.8e+35], x, If[LessEqual[x, 8.8e+74], a, x]]

Derivation

1. Split input into 2 regimes

2. if x < -7.7999999999999998e35 or 8.8000000000000005e74 < x

   1. Initial program 96.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.7999999999999998e35 < x < 8.8000000000000005e74

   1. Initial program 96.5%

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

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   11. Simplified 0

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

Alternative 26: 10.9% accurate, 21.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_] := a

Derivation

1. Initial program 96.5%

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

3. Taylor expanded in b around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in t around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]

9. Taylor expanded in a around inf 0

   \[\leadsto expr\]

11. Simplified 0

    \[\leadsto expr\]
12. Add Preprocessing

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z t a b)
  :name "Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2"
  :precision binary64
  (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))