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

Percentage Accurate: 95.2% → 98.0%

Time: 19.3s

Alternatives: 24

Speedup: 0.5×

• 37.0% 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.2% 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: 98.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 (-.f64 (-.f64 x (*.f64 (-.f64 y 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) 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 1) z)) (*.f64 (-.f64 t 1) a)) (*.f64 (-.f64 (+.f64 y t) 2) 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 y around inf 66.7%

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

4. Final simplification 98.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\left(\left(x + z \cdot \left(1 - y\right)\right) + a \cdot \left(1 - t\right)\right) + b \cdot \left(\left(y + t\right) - 2\right) \leq \infty:\\ \;\;\;\;\left(\left(x + z \cdot \left(1 - y\right)\right) + a \cdot \left(1 - t\right)\right) + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 97.3% accurate, 0.1× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

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

   1. +-commutative 96.5%

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

   2. fma-define 97.6%

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

   3. associate--l+ 97.6%

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

   4. sub-neg 97.6%

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

   5. metadata-eval 97.6%

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

   6. sub-neg 97.6%

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

   7. associate-+l- 97.6%

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

   8. fma-neg 98.0%

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

   9. sub-neg 98.0%

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

   10. metadata-eval 98.0%

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

   11. remove-double-neg 98.0%

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

   12. sub-neg 98.0%

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

   13. metadata-eval 98.0%

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

3. Simplified 98.0%

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

5. Final simplification 98.0%

   \[\leadsto \mathsf{fma}\left(y + \left(t + -2\right), b, x - \mathsf{fma}\left(y + -1, z, a \cdot \left(t + -1\right)\right)\right) \]
6. Add Preprocessing

Alternative 3: 59.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := x + z \cdot \left(1 - y\right)\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+77}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -1.16 \cdot 10^{+51}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq -9.5 \cdot 10^{-56}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-72}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 1.22 \cdot 10^{-147}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 10^{-82}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+54}:\\ \;\;\;\;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 (+ x (* z (- 1.0 y))))
        (t_3 (* b (- (+ y t) 2.0))))
   (if (<= b -1e+107)
     t_3
     (if (<= b -6.5e+77)
       t_1
       (if (<= b -1.16e+51)
         t_3
         (if (<= b -9.5e-56)
           (* y (- b z))
           (if (<= b -6.8e-72)
             (* t (- b a))
             (if (<= b 1.22e-147)
               t_2
               (if (<= b 1e-82) t_1 (if (<= b 4.8e+54) 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 = x + (z * (1.0 - y));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_3;
	} else if (b <= -6.5e+77) {
		tmp = t_1;
	} else if (b <= -1.16e+51) {
		tmp = t_3;
	} else if (b <= -9.5e-56) {
		tmp = y * (b - z);
	} else if (b <= -6.8e-72) {
		tmp = t * (b - a);
	} else if (b <= 1.22e-147) {
		tmp = t_2;
	} else if (b <= 1e-82) {
		tmp = t_1;
	} else if (b <= 4.8e+54) {
		tmp = 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) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = x + (z * (1.0d0 - y))
    t_3 = b * ((y + t) - 2.0d0)
    if (b <= (-1d+107)) then
        tmp = t_3
    else if (b <= (-6.5d+77)) then
        tmp = t_1
    else if (b <= (-1.16d+51)) then
        tmp = t_3
    else if (b <= (-9.5d-56)) then
        tmp = y * (b - z)
    else if (b <= (-6.8d-72)) then
        tmp = t * (b - a)
    else if (b <= 1.22d-147) then
        tmp = t_2
    else if (b <= 1d-82) then
        tmp = t_1
    else if (b <= 4.8d+54) then
        tmp = 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 = x + (z * (1.0 - y));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_3;
	} else if (b <= -6.5e+77) {
		tmp = t_1;
	} else if (b <= -1.16e+51) {
		tmp = t_3;
	} else if (b <= -9.5e-56) {
		tmp = y * (b - z);
	} else if (b <= -6.8e-72) {
		tmp = t * (b - a);
	} else if (b <= 1.22e-147) {
		tmp = t_2;
	} else if (b <= 1e-82) {
		tmp = t_1;
	} else if (b <= 4.8e+54) {
		tmp = 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 = x + (z * (1.0 - y))
	t_3 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -1e+107:
		tmp = t_3
	elif b <= -6.5e+77:
		tmp = t_1
	elif b <= -1.16e+51:
		tmp = t_3
	elif b <= -9.5e-56:
		tmp = y * (b - z)
	elif b <= -6.8e-72:
		tmp = t * (b - a)
	elif b <= 1.22e-147:
		tmp = t_2
	elif b <= 1e-82:
		tmp = t_1
	elif b <= 4.8e+54:
		tmp = 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(x + Float64(z * Float64(1.0 - y)))
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -1e+107)
		tmp = t_3;
	elseif (b <= -6.5e+77)
		tmp = t_1;
	elseif (b <= -1.16e+51)
		tmp = t_3;
	elseif (b <= -9.5e-56)
		tmp = Float64(y * Float64(b - z));
	elseif (b <= -6.8e-72)
		tmp = Float64(t * Float64(b - a));
	elseif (b <= 1.22e-147)
		tmp = t_2;
	elseif (b <= 1e-82)
		tmp = t_1;
	elseif (b <= 4.8e+54)
		tmp = 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 = x + (z * (1.0 - y));
	t_3 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -1e+107)
		tmp = t_3;
	elseif (b <= -6.5e+77)
		tmp = t_1;
	elseif (b <= -1.16e+51)
		tmp = t_3;
	elseif (b <= -9.5e-56)
		tmp = y * (b - z);
	elseif (b <= -6.8e-72)
		tmp = t * (b - a);
	elseif (b <= 1.22e-147)
		tmp = t_2;
	elseif (b <= 1e-82)
		tmp = t_1;
	elseif (b <= 4.8e+54)
		tmp = 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[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+107], t$95$3, If[LessEqual[b, -6.5e+77], t$95$1, If[LessEqual[b, -1.16e+51], t$95$3, If[LessEqual[b, -9.5e-56], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -6.8e-72], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.22e-147], t$95$2, If[LessEqual[b, 1e-82], t$95$1, If[LessEqual[b, 4.8e+54], t$95$2, t$95$3]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -9.9999999999999997e106 or -6.5e77 < b < -1.16e51 or 4.79999999999999997e54 < b

   1. Initial program 93.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 inf 81.2%

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

   if -9.9999999999999997e106 < b < -6.5e77 or 1.21999999999999995e-147 < b < 1e-82

   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 76.1%

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

   if -1.16e51 < b < -9.4999999999999991e-56

   1. Initial program 94.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 y around inf 64.0%

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

   if -9.4999999999999991e-56 < b < -6.7999999999999997e-72

   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 t around inf 55.1%

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

   if -6.7999999999999997e-72 < b < 1.21999999999999995e-147 or 1e-82 < b < 4.79999999999999997e54

   1. Initial program 99.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 0 73.5%

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

   4. Taylor expanded in b around 0 62.8%

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

4. Final simplification 71.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+77}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -1.16 \cdot 10^{+51}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -9.5 \cdot 10^{-56}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-72}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 1.22 \cdot 10^{-147}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 10^{-82}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+54}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 59.3% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := x + z \cdot \left(1 - y\right)\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+77}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -4.6 \cdot 10^{+50}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq -7.5 \cdot 10^{-51}:\\ \;\;\;\;y \cdot b - y \cdot z\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-72}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 4.2 \cdot 10^{-146}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 8 \cdot 10^{-85}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 6.4 \cdot 10^{+59}:\\ \;\;\;\;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 (+ x (* z (- 1.0 y))))
        (t_3 (* b (- (+ y t) 2.0))))
   (if (<= b -1e+107)
     t_3
     (if (<= b -6.5e+77)
       t_1
       (if (<= b -4.6e+50)
         t_3
         (if (<= b -7.5e-51)
           (- (* y b) (* y z))
           (if (<= b -6.8e-72)
             (* t (- b a))
             (if (<= b 4.2e-146)
               t_2
               (if (<= b 8e-85) t_1 (if (<= b 6.4e+59) 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 = x + (z * (1.0 - y));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_3;
	} else if (b <= -6.5e+77) {
		tmp = t_1;
	} else if (b <= -4.6e+50) {
		tmp = t_3;
	} else if (b <= -7.5e-51) {
		tmp = (y * b) - (y * z);
	} else if (b <= -6.8e-72) {
		tmp = t * (b - a);
	} else if (b <= 4.2e-146) {
		tmp = t_2;
	} else if (b <= 8e-85) {
		tmp = t_1;
	} else if (b <= 6.4e+59) {
		tmp = 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) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = x + (z * (1.0d0 - y))
    t_3 = b * ((y + t) - 2.0d0)
    if (b <= (-1d+107)) then
        tmp = t_3
    else if (b <= (-6.5d+77)) then
        tmp = t_1
    else if (b <= (-4.6d+50)) then
        tmp = t_3
    else if (b <= (-7.5d-51)) then
        tmp = (y * b) - (y * z)
    else if (b <= (-6.8d-72)) then
        tmp = t * (b - a)
    else if (b <= 4.2d-146) then
        tmp = t_2
    else if (b <= 8d-85) then
        tmp = t_1
    else if (b <= 6.4d+59) then
        tmp = 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 = x + (z * (1.0 - y));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_3;
	} else if (b <= -6.5e+77) {
		tmp = t_1;
	} else if (b <= -4.6e+50) {
		tmp = t_3;
	} else if (b <= -7.5e-51) {
		tmp = (y * b) - (y * z);
	} else if (b <= -6.8e-72) {
		tmp = t * (b - a);
	} else if (b <= 4.2e-146) {
		tmp = t_2;
	} else if (b <= 8e-85) {
		tmp = t_1;
	} else if (b <= 6.4e+59) {
		tmp = 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 = x + (z * (1.0 - y))
	t_3 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -1e+107:
		tmp = t_3
	elif b <= -6.5e+77:
		tmp = t_1
	elif b <= -4.6e+50:
		tmp = t_3
	elif b <= -7.5e-51:
		tmp = (y * b) - (y * z)
	elif b <= -6.8e-72:
		tmp = t * (b - a)
	elif b <= 4.2e-146:
		tmp = t_2
	elif b <= 8e-85:
		tmp = t_1
	elif b <= 6.4e+59:
		tmp = 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(x + Float64(z * Float64(1.0 - y)))
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -1e+107)
		tmp = t_3;
	elseif (b <= -6.5e+77)
		tmp = t_1;
	elseif (b <= -4.6e+50)
		tmp = t_3;
	elseif (b <= -7.5e-51)
		tmp = Float64(Float64(y * b) - Float64(y * z));
	elseif (b <= -6.8e-72)
		tmp = Float64(t * Float64(b - a));
	elseif (b <= 4.2e-146)
		tmp = t_2;
	elseif (b <= 8e-85)
		tmp = t_1;
	elseif (b <= 6.4e+59)
		tmp = 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 = x + (z * (1.0 - y));
	t_3 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -1e+107)
		tmp = t_3;
	elseif (b <= -6.5e+77)
		tmp = t_1;
	elseif (b <= -4.6e+50)
		tmp = t_3;
	elseif (b <= -7.5e-51)
		tmp = (y * b) - (y * z);
	elseif (b <= -6.8e-72)
		tmp = t * (b - a);
	elseif (b <= 4.2e-146)
		tmp = t_2;
	elseif (b <= 8e-85)
		tmp = t_1;
	elseif (b <= 6.4e+59)
		tmp = 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[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+107], t$95$3, If[LessEqual[b, -6.5e+77], t$95$1, If[LessEqual[b, -4.6e+50], t$95$3, If[LessEqual[b, -7.5e-51], N[(N[(y * b), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -6.8e-72], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.2e-146], t$95$2, If[LessEqual[b, 8e-85], t$95$1, If[LessEqual[b, 6.4e+59], t$95$2, t$95$3]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -9.9999999999999997e106 or -6.5e77 < b < -4.59999999999999994e50 or 6.39999999999999964e59 < b

   1. Initial program 93.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 inf 81.2%

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

   if -9.9999999999999997e106 < b < -6.5e77 or 4.1999999999999998e-146 < b < 7.9999999999999998e-85

   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 76.1%

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

   if -4.59999999999999994e50 < b < -7.49999999999999976e-51

   1. Initial program 94.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 y around inf 66.7%

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

      1. mul-1-neg 66.7%

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

      2. distribute-rgt-neg-in 66.7%

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

   5. Simplified 66.7%

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

   6. Taylor expanded in y around inf 64.1%

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

      1. +-commutative 64.1%

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

      2. distribute-rgt-neg-out 64.1%

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

      3. unsub-neg 64.1%

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

      4. *-commutative 64.1%

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

   8. Applied egg-rr 64.1%

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

   if -7.49999999999999976e-51 < b < -6.7999999999999997e-72

   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 t around inf 55.1%

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

   if -6.7999999999999997e-72 < b < 4.1999999999999998e-146 or 7.9999999999999998e-85 < b < 6.39999999999999964e59

   1. Initial program 99.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 0 73.5%

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

   4. Taylor expanded in b around 0 62.8%

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

4. Final simplification 71.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+77}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -4.6 \cdot 10^{+50}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -7.5 \cdot 10^{-51}:\\ \;\;\;\;y \cdot b - y \cdot z\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-72}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 4.2 \cdot 10^{-146}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 8 \cdot 10^{-85}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 6.4 \cdot 10^{+59}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 26.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.6 \cdot 10^{+108}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -1.1 \cdot 10^{-227}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 2.3 \cdot 10^{-280}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;t \leq 1.1 \cdot 10^{-200}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 2 \cdot 10^{-176}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq 2.25 \cdot 10^{-135}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-68}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{+22}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -1.6e+108)
   (* t b)
   (if (<= t -1.1e-227)
     (* y b)
     (if (<= t 2.3e-280)
       (* -2.0 b)
       (if (<= t 1.1e-200)
         x
         (if (<= t 2e-176)
           z
           (if (<= t 2.25e-135)
             (* y b)
             (if (<= t 8.5e-68) z (if (<= t 1.4e+22) x (* t b))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1.6e+108) {
		tmp = t * b;
	} else if (t <= -1.1e-227) {
		tmp = y * b;
	} else if (t <= 2.3e-280) {
		tmp = -2.0 * b;
	} else if (t <= 1.1e-200) {
		tmp = x;
	} else if (t <= 2e-176) {
		tmp = z;
	} else if (t <= 2.25e-135) {
		tmp = y * b;
	} else if (t <= 8.5e-68) {
		tmp = z;
	} else if (t <= 1.4e+22) {
		tmp = x;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-1.6d+108)) then
        tmp = t * b
    else if (t <= (-1.1d-227)) then
        tmp = y * b
    else if (t <= 2.3d-280) then
        tmp = (-2.0d0) * b
    else if (t <= 1.1d-200) then
        tmp = x
    else if (t <= 2d-176) then
        tmp = z
    else if (t <= 2.25d-135) then
        tmp = y * b
    else if (t <= 8.5d-68) then
        tmp = z
    else if (t <= 1.4d+22) then
        tmp = x
    else
        tmp = t * b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1.6e+108) {
		tmp = t * b;
	} else if (t <= -1.1e-227) {
		tmp = y * b;
	} else if (t <= 2.3e-280) {
		tmp = -2.0 * b;
	} else if (t <= 1.1e-200) {
		tmp = x;
	} else if (t <= 2e-176) {
		tmp = z;
	} else if (t <= 2.25e-135) {
		tmp = y * b;
	} else if (t <= 8.5e-68) {
		tmp = z;
	} else if (t <= 1.4e+22) {
		tmp = x;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -1.6e+108:
		tmp = t * b
	elif t <= -1.1e-227:
		tmp = y * b
	elif t <= 2.3e-280:
		tmp = -2.0 * b
	elif t <= 1.1e-200:
		tmp = x
	elif t <= 2e-176:
		tmp = z
	elif t <= 2.25e-135:
		tmp = y * b
	elif t <= 8.5e-68:
		tmp = z
	elif t <= 1.4e+22:
		tmp = x
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -1.6e+108)
		tmp = Float64(t * b);
	elseif (t <= -1.1e-227)
		tmp = Float64(y * b);
	elseif (t <= 2.3e-280)
		tmp = Float64(-2.0 * b);
	elseif (t <= 1.1e-200)
		tmp = x;
	elseif (t <= 2e-176)
		tmp = z;
	elseif (t <= 2.25e-135)
		tmp = Float64(y * b);
	elseif (t <= 8.5e-68)
		tmp = z;
	elseif (t <= 1.4e+22)
		tmp = x;
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -1.6e+108)
		tmp = t * b;
	elseif (t <= -1.1e-227)
		tmp = y * b;
	elseif (t <= 2.3e-280)
		tmp = -2.0 * b;
	elseif (t <= 1.1e-200)
		tmp = x;
	elseif (t <= 2e-176)
		tmp = z;
	elseif (t <= 2.25e-135)
		tmp = y * b;
	elseif (t <= 8.5e-68)
		tmp = z;
	elseif (t <= 1.4e+22)
		tmp = x;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.6e+108], N[(t * b), $MachinePrecision], If[LessEqual[t, -1.1e-227], N[(y * b), $MachinePrecision], If[LessEqual[t, 2.3e-280], N[(-2.0 * b), $MachinePrecision], If[LessEqual[t, 1.1e-200], x, If[LessEqual[t, 2e-176], z, If[LessEqual[t, 2.25e-135], N[(y * b), $MachinePrecision], If[LessEqual[t, 8.5e-68], z, If[LessEqual[t, 1.4e+22], x, N[(t * b), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -1.6e108 or 1.4e22 < t

   1. Initial program 95.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 78.3%

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

   4. Taylor expanded in b around inf 47.4%

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

   if -1.6e108 < t < -1.0999999999999999e-227 or 2e-176 < t < 2.24999999999999994e-135

   1. Initial program 96.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 inf 45.1%

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

   4. Taylor expanded in y around inf 34.4%

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

   if -1.0999999999999999e-227 < t < 2.3e-280

   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 55.9%

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

   4. Taylor expanded in t around 0 55.9%

      \[\leadsto \color{blue}{b \cdot \left(y - 2\right)} \]

   5. Taylor expanded in y around 0 36.6%

      \[\leadsto \color{blue}{-2 \cdot b} \]
   6. Step-by-step derivation

      1. *-commutative 36.6%

         \[\leadsto \color{blue}{b \cdot -2} \]

   7. Simplified 36.6%

      \[\leadsto \color{blue}{b \cdot -2} \]

   if 2.3e-280 < t < 1.10000000000000007e-200 or 8.50000000000000026e-68 < t < 1.4e22

   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 34.2%

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

   if 1.10000000000000007e-200 < t < 2e-176 or 2.24999999999999994e-135 < t < 8.50000000000000026e-68

   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 47.3%

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

   4. Taylor expanded in y around 0 31.3%

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

4. Final simplification 39.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.6 \cdot 10^{+108}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -1.1 \cdot 10^{-227}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 2.3 \cdot 10^{-280}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;t \leq 1.1 \cdot 10^{-200}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 2 \cdot 10^{-176}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq 2.25 \cdot 10^{-135}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-68}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{+22}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 62.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_3 := x + z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -1.05 \cdot 10^{+107}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq -1.42 \cdot 10^{+76}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -3.05 \cdot 10^{-12}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{-146}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq 1.5 \cdot 10^{-80}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 9500000:\\ \;\;\;\;t\_3\\ \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 (+ x (* b (- (+ y t) 2.0))))
        (t_3 (+ x (* z (- 1.0 y)))))
   (if (<= b -1.05e+107)
     t_2
     (if (<= b -1.42e+76)
       t_1
       (if (<= b -3.05e-12)
         t_2
         (if (<= b 4.6e-146)
           t_3
           (if (<= b 1.5e-80) t_1 (if (<= b 9500000.0) t_3 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 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -1.05e+107) {
		tmp = t_2;
	} else if (b <= -1.42e+76) {
		tmp = t_1;
	} else if (b <= -3.05e-12) {
		tmp = t_2;
	} else if (b <= 4.6e-146) {
		tmp = t_3;
	} else if (b <= 1.5e-80) {
		tmp = t_1;
	} else if (b <= 9500000.0) {
		tmp = t_3;
	} 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) :: t_3
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = x + (b * ((y + t) - 2.0d0))
    t_3 = x + (z * (1.0d0 - y))
    if (b <= (-1.05d+107)) then
        tmp = t_2
    else if (b <= (-1.42d+76)) then
        tmp = t_1
    else if (b <= (-3.05d-12)) then
        tmp = t_2
    else if (b <= 4.6d-146) then
        tmp = t_3
    else if (b <= 1.5d-80) then
        tmp = t_1
    else if (b <= 9500000.0d0) then
        tmp = t_3
    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 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -1.05e+107) {
		tmp = t_2;
	} else if (b <= -1.42e+76) {
		tmp = t_1;
	} else if (b <= -3.05e-12) {
		tmp = t_2;
	} else if (b <= 4.6e-146) {
		tmp = t_3;
	} else if (b <= 1.5e-80) {
		tmp = t_1;
	} else if (b <= 9500000.0) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = x + (b * ((y + t) - 2.0))
	t_3 = x + (z * (1.0 - y))
	tmp = 0
	if b <= -1.05e+107:
		tmp = t_2
	elif b <= -1.42e+76:
		tmp = t_1
	elif b <= -3.05e-12:
		tmp = t_2
	elif b <= 4.6e-146:
		tmp = t_3
	elif b <= 1.5e-80:
		tmp = t_1
	elif b <= 9500000.0:
		tmp = t_3
	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(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	t_3 = Float64(x + Float64(z * Float64(1.0 - y)))
	tmp = 0.0
	if (b <= -1.05e+107)
		tmp = t_2;
	elseif (b <= -1.42e+76)
		tmp = t_1;
	elseif (b <= -3.05e-12)
		tmp = t_2;
	elseif (b <= 4.6e-146)
		tmp = t_3;
	elseif (b <= 1.5e-80)
		tmp = t_1;
	elseif (b <= 9500000.0)
		tmp = t_3;
	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 = x + (b * ((y + t) - 2.0));
	t_3 = x + (z * (1.0 - y));
	tmp = 0.0;
	if (b <= -1.05e+107)
		tmp = t_2;
	elseif (b <= -1.42e+76)
		tmp = t_1;
	elseif (b <= -3.05e-12)
		tmp = t_2;
	elseif (b <= 4.6e-146)
		tmp = t_3;
	elseif (b <= 1.5e-80)
		tmp = t_1;
	elseif (b <= 9500000.0)
		tmp = t_3;
	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[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.05e+107], t$95$2, If[LessEqual[b, -1.42e+76], t$95$1, If[LessEqual[b, -3.05e-12], t$95$2, If[LessEqual[b, 4.6e-146], t$95$3, If[LessEqual[b, 1.5e-80], t$95$1, If[LessEqual[b, 9500000.0], t$95$3, t$95$2]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.05e107 or -1.41999999999999996e76 < b < -3.0500000000000001e-12 or 9.5e6 < 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 a around 0 88.1%

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

   4. Taylor expanded in z around 0 80.3%

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

   if -1.05e107 < b < -1.41999999999999996e76 or 4.6000000000000001e-146 < b < 1.50000000000000004e-80

   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 76.1%

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

   if -3.0500000000000001e-12 < b < 4.6000000000000001e-146 or 1.50000000000000004e-80 < b < 9.5e6

   1. Initial program 99.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 0 71.6%

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

   4. Taylor expanded in b around 0 62.9%

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

4. Final simplification 72.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.05 \cdot 10^{+107}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -1.42 \cdot 10^{+76}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -3.05 \cdot 10^{-12}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{-146}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 1.5 \cdot 10^{-80}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 9500000:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 61.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_2 := a \cdot \left(1 - t\right)\\ t_3 := x + z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -9 \cdot 10^{+64}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq -5.1 \cdot 10^{-12}:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{-146}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq 4.1 \cdot 10^{-81}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 2400000:\\ \;\;\;\;t\_3\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* b (- (+ y t) 2.0))))
        (t_2 (* a (- 1.0 t)))
        (t_3 (+ x (* z (- 1.0 y)))))
   (if (<= b -1e+107)
     t_1
     (if (<= b -9e+64)
       t_2
       (if (<= b -5.1e-12)
         (- (* -2.0 b) (* y (- z b)))
         (if (<= b 4.6e-146)
           t_3
           (if (<= b 4.1e-81) t_2 (if (<= b 2400000.0) t_3 t_1))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (b * ((y + t) - 2.0));
	double t_2 = a * (1.0 - t);
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -1e+107) {
		tmp = t_1;
	} else if (b <= -9e+64) {
		tmp = t_2;
	} else if (b <= -5.1e-12) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (b <= 4.6e-146) {
		tmp = t_3;
	} else if (b <= 4.1e-81) {
		tmp = t_2;
	} else if (b <= 2400000.0) {
		tmp = t_3;
	} 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) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = x + (b * ((y + t) - 2.0d0))
    t_2 = a * (1.0d0 - t)
    t_3 = x + (z * (1.0d0 - y))
    if (b <= (-1d+107)) then
        tmp = t_1
    else if (b <= (-9d+64)) then
        tmp = t_2
    else if (b <= (-5.1d-12)) then
        tmp = ((-2.0d0) * b) - (y * (z - b))
    else if (b <= 4.6d-146) then
        tmp = t_3
    else if (b <= 4.1d-81) then
        tmp = t_2
    else if (b <= 2400000.0d0) then
        tmp = t_3
    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 + (b * ((y + t) - 2.0));
	double t_2 = a * (1.0 - t);
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -1e+107) {
		tmp = t_1;
	} else if (b <= -9e+64) {
		tmp = t_2;
	} else if (b <= -5.1e-12) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (b <= 4.6e-146) {
		tmp = t_3;
	} else if (b <= 4.1e-81) {
		tmp = t_2;
	} else if (b <= 2400000.0) {
		tmp = t_3;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (b * ((y + t) - 2.0))
	t_2 = a * (1.0 - t)
	t_3 = x + (z * (1.0 - y))
	tmp = 0
	if b <= -1e+107:
		tmp = t_1
	elif b <= -9e+64:
		tmp = t_2
	elif b <= -5.1e-12:
		tmp = (-2.0 * b) - (y * (z - b))
	elif b <= 4.6e-146:
		tmp = t_3
	elif b <= 4.1e-81:
		tmp = t_2
	elif b <= 2400000.0:
		tmp = t_3
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	t_2 = Float64(a * Float64(1.0 - t))
	t_3 = Float64(x + Float64(z * Float64(1.0 - y)))
	tmp = 0.0
	if (b <= -1e+107)
		tmp = t_1;
	elseif (b <= -9e+64)
		tmp = t_2;
	elseif (b <= -5.1e-12)
		tmp = Float64(Float64(-2.0 * b) - Float64(y * Float64(z - b)));
	elseif (b <= 4.6e-146)
		tmp = t_3;
	elseif (b <= 4.1e-81)
		tmp = t_2;
	elseif (b <= 2400000.0)
		tmp = t_3;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (b * ((y + t) - 2.0));
	t_2 = a * (1.0 - t);
	t_3 = x + (z * (1.0 - y));
	tmp = 0.0;
	if (b <= -1e+107)
		tmp = t_1;
	elseif (b <= -9e+64)
		tmp = t_2;
	elseif (b <= -5.1e-12)
		tmp = (-2.0 * b) - (y * (z - b));
	elseif (b <= 4.6e-146)
		tmp = t_3;
	elseif (b <= 4.1e-81)
		tmp = t_2;
	elseif (b <= 2400000.0)
		tmp = t_3;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+107], t$95$1, If[LessEqual[b, -9e+64], t$95$2, If[LessEqual[b, -5.1e-12], N[(N[(-2.0 * b), $MachinePrecision] - N[(y * N[(z - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.6e-146], t$95$3, If[LessEqual[b, 4.1e-81], t$95$2, If[LessEqual[b, 2400000.0], t$95$3, t$95$1]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -9.9999999999999997e106 or 2.4e6 < b

   1. Initial program 93.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 a around 0 88.5%

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

   4. Taylor expanded in z around 0 83.7%

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

   if -9.9999999999999997e106 < b < -8.99999999999999946e64 or 4.6000000000000001e-146 < b < 4.09999999999999984e-81

   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 70.7%

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

   if -8.99999999999999946e64 < b < -5.09999999999999968e-12

   1. Initial program 93.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 76.5%

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

      1. mul-1-neg 76.5%

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

      2. distribute-rgt-neg-in 76.5%

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

   5. Simplified 76.5%

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

   6. Taylor expanded in t around 0 69.9%

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

      1. sub-neg 69.9%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \color{blue}{\left(y + \left(-2\right)\right)} \]

      2. metadata-eval 69.9%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \left(y + \color{blue}{-2}\right) \]

      3. distribute-rgt-in 69.9%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \color{blue}{\left(y \cdot b + -2 \cdot b\right)} \]

      4. *-commutative 69.9%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \left(\color{blue}{b \cdot y} + -2 \cdot b\right) \]

      5. associate-+r+ 69.9%

         \[\leadsto \color{blue}{\left(-1 \cdot \left(y \cdot z\right) + b \cdot y\right) + -2 \cdot b} \]

      6. mul-1-neg 69.9%

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

      7. distribute-rgt-neg-in 69.9%

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

      8. mul-1-neg 69.9%

         \[\leadsto \left(y \cdot \color{blue}{\left(-1 \cdot z\right)} + b \cdot y\right) + -2 \cdot b \]

      9. *-commutative 69.9%

         \[\leadsto \left(y \cdot \left(-1 \cdot z\right) + \color{blue}{y \cdot b}\right) + -2 \cdot b \]

      10. distribute-lft-in 69.8%

          \[\leadsto \color{blue}{y \cdot \left(-1 \cdot z + b\right)} + -2 \cdot b \]

      11. +-commutative 69.8%

          \[\leadsto y \cdot \color{blue}{\left(b + -1 \cdot z\right)} + -2 \cdot b \]

      12. mul-1-neg 69.8%

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

      13. sub-neg 69.8%

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

      14. *-commutative 69.8%

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

   8. Simplified 69.8%

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

   if -5.09999999999999968e-12 < b < 4.6000000000000001e-146 or 4.09999999999999984e-81 < b < 2.4e6

   1. Initial program 99.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 0 71.6%

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

   4. Taylor expanded in b around 0 62.9%

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

4. Final simplification 73.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -9 \cdot 10^{+64}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -5.1 \cdot 10^{-12}:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{-146}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 4.1 \cdot 10^{-81}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 2400000:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 50.3% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ t_2 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq -2.4 \cdot 10^{+63}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -1.12 \cdot 10^{-12}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;b \leq 6.5 \cdot 10^{-130}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 1.9 \cdot 10^{-31}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 1950000:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y))) (t_2 (* b (- (+ y t) 2.0))))
   (if (<= b -1e+107)
     t_2
     (if (<= b -2.4e+63)
       (* a (- 1.0 t))
       (if (<= b -1.12e-12)
         (* y (- b z))
         (if (<= b 6.5e-130)
           t_1
           (if (<= b 1.9e-31)
             (* t (- b a))
             (if (<= b 1950000.0) t_1 t_2))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_2;
	} else if (b <= -2.4e+63) {
		tmp = a * (1.0 - t);
	} else if (b <= -1.12e-12) {
		tmp = y * (b - z);
	} else if (b <= 6.5e-130) {
		tmp = t_1;
	} else if (b <= 1.9e-31) {
		tmp = t * (b - a);
	} else if (b <= 1950000.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 = z * (1.0d0 - y)
    t_2 = b * ((y + t) - 2.0d0)
    if (b <= (-1d+107)) then
        tmp = t_2
    else if (b <= (-2.4d+63)) then
        tmp = a * (1.0d0 - t)
    else if (b <= (-1.12d-12)) then
        tmp = y * (b - z)
    else if (b <= 6.5d-130) then
        tmp = t_1
    else if (b <= 1.9d-31) then
        tmp = t * (b - a)
    else if (b <= 1950000.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 = z * (1.0 - y);
	double t_2 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1e+107) {
		tmp = t_2;
	} else if (b <= -2.4e+63) {
		tmp = a * (1.0 - t);
	} else if (b <= -1.12e-12) {
		tmp = y * (b - z);
	} else if (b <= 6.5e-130) {
		tmp = t_1;
	} else if (b <= 1.9e-31) {
		tmp = t * (b - a);
	} else if (b <= 1950000.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	t_2 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -1e+107:
		tmp = t_2
	elif b <= -2.4e+63:
		tmp = a * (1.0 - t)
	elif b <= -1.12e-12:
		tmp = y * (b - z)
	elif b <= 6.5e-130:
		tmp = t_1
	elif b <= 1.9e-31:
		tmp = t * (b - a)
	elif b <= 1950000.0:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	t_2 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -1e+107)
		tmp = t_2;
	elseif (b <= -2.4e+63)
		tmp = Float64(a * Float64(1.0 - t));
	elseif (b <= -1.12e-12)
		tmp = Float64(y * Float64(b - z));
	elseif (b <= 6.5e-130)
		tmp = t_1;
	elseif (b <= 1.9e-31)
		tmp = Float64(t * Float64(b - a));
	elseif (b <= 1950000.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 = z * (1.0 - y);
	t_2 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -1e+107)
		tmp = t_2;
	elseif (b <= -2.4e+63)
		tmp = a * (1.0 - t);
	elseif (b <= -1.12e-12)
		tmp = y * (b - z);
	elseif (b <= 6.5e-130)
		tmp = t_1;
	elseif (b <= 1.9e-31)
		tmp = t * (b - a);
	elseif (b <= 1950000.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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+107], t$95$2, If[LessEqual[b, -2.4e+63], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.12e-12], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e-130], t$95$1, If[LessEqual[b, 1.9e-31], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1950000.0], t$95$1, t$95$2]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -9.9999999999999997e106 or 1.95e6 < b

   1. Initial program 93.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 b around inf 78.4%

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

   if -9.9999999999999997e106 < b < -2.4e63

   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 67.4%

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

   if -2.4e63 < b < -1.1200000000000001e-12

   1. Initial program 92.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 y around inf 64.9%

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

   if -1.1200000000000001e-12 < b < 6.5000000000000002e-130 or 1.9e-31 < b < 1.95e6

   1. Initial program 99.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 44.6%

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

   if 6.5000000000000002e-130 < b < 1.9e-31

   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 t around inf 60.6%

      \[\leadsto \color{blue}{t \cdot \left(b - a\right)} \]
3. Recombined 5 regimes into one program.

4. Final simplification 62.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+107}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -2.4 \cdot 10^{+63}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -1.12 \cdot 10^{-12}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;b \leq 6.5 \cdot 10^{-130}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 1.9 \cdot 10^{-31}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;b \leq 1950000:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 81.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(a \cdot \left(1 - t\right) - z \cdot \left(y + -1\right)\right)\\ t_2 := b \cdot \left(\left(y + t\right) - 2\right)\\ t_3 := x + t\_2\\ \mathbf{if}\;b \leq -5 \cdot 10^{+170}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+65}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-12}:\\ \;\;\;\;t\_2 - y \cdot z\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+53}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (- (* a (- 1.0 t)) (* z (+ y -1.0)))))
        (t_2 (* b (- (+ y t) 2.0)))
        (t_3 (+ x t_2)))
   (if (<= b -5e+170)
     t_3
     (if (<= b -6.5e+65)
       t_1
       (if (<= b -1.7e-12) (- t_2 (* y z)) (if (<= b 4.8e+53) t_1 t_3))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + ((a * (1.0 - t)) - (z * (y + -1.0)));
	double t_2 = b * ((y + t) - 2.0);
	double t_3 = x + t_2;
	double tmp;
	if (b <= -5e+170) {
		tmp = t_3;
	} else if (b <= -6.5e+65) {
		tmp = t_1;
	} else if (b <= -1.7e-12) {
		tmp = t_2 - (y * z);
	} else if (b <= 4.8e+53) {
		tmp = t_1;
	} 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) :: tmp
    t_1 = x + ((a * (1.0d0 - t)) - (z * (y + (-1.0d0))))
    t_2 = b * ((y + t) - 2.0d0)
    t_3 = x + t_2
    if (b <= (-5d+170)) then
        tmp = t_3
    else if (b <= (-6.5d+65)) then
        tmp = t_1
    else if (b <= (-1.7d-12)) then
        tmp = t_2 - (y * z)
    else if (b <= 4.8d+53) then
        tmp = t_1
    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 = x + ((a * (1.0 - t)) - (z * (y + -1.0)));
	double t_2 = b * ((y + t) - 2.0);
	double t_3 = x + t_2;
	double tmp;
	if (b <= -5e+170) {
		tmp = t_3;
	} else if (b <= -6.5e+65) {
		tmp = t_1;
	} else if (b <= -1.7e-12) {
		tmp = t_2 - (y * z);
	} else if (b <= 4.8e+53) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + ((a * (1.0 - t)) - (z * (y + -1.0)))
	t_2 = b * ((y + t) - 2.0)
	t_3 = x + t_2
	tmp = 0
	if b <= -5e+170:
		tmp = t_3
	elif b <= -6.5e+65:
		tmp = t_1
	elif b <= -1.7e-12:
		tmp = t_2 - (y * z)
	elif b <= 4.8e+53:
		tmp = t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(Float64(a * Float64(1.0 - t)) - Float64(z * Float64(y + -1.0))))
	t_2 = Float64(b * Float64(Float64(y + t) - 2.0))
	t_3 = Float64(x + t_2)
	tmp = 0.0
	if (b <= -5e+170)
		tmp = t_3;
	elseif (b <= -6.5e+65)
		tmp = t_1;
	elseif (b <= -1.7e-12)
		tmp = Float64(t_2 - Float64(y * z));
	elseif (b <= 4.8e+53)
		tmp = t_1;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + ((a * (1.0 - t)) - (z * (y + -1.0)));
	t_2 = b * ((y + t) - 2.0);
	t_3 = x + t_2;
	tmp = 0.0;
	if (b <= -5e+170)
		tmp = t_3;
	elseif (b <= -6.5e+65)
		tmp = t_1;
	elseif (b <= -1.7e-12)
		tmp = t_2 - (y * z);
	elseif (b <= 4.8e+53)
		tmp = t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision] - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + t$95$2), $MachinePrecision]}, If[LessEqual[b, -5e+170], t$95$3, If[LessEqual[b, -6.5e+65], t$95$1, If[LessEqual[b, -1.7e-12], N[(t$95$2 - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.8e+53], t$95$1, t$95$3]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -4.99999999999999977e170 or 4.8e53 < b

   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 a around 0 91.3%

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

   4. Taylor expanded in z around 0 89.9%

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

   if -4.99999999999999977e170 < b < -6.5000000000000003e65 or -1.7e-12 < b < 4.8e53

   1. Initial program 97.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 87.0%

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

   if -6.5000000000000003e65 < b < -1.7e-12

   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 y around inf 77.9%

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

      1. mul-1-neg 77.9%

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

      2. distribute-rgt-neg-in 77.9%

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

   5. Simplified 77.9%

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

4. Final simplification 87.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -5 \cdot 10^{+170}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -6.5 \cdot 10^{+65}:\\ \;\;\;\;x + \left(a \cdot \left(1 - t\right) - z \cdot \left(y + -1\right)\right)\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-12}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right) - y \cdot z\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+53}:\\ \;\;\;\;x + \left(a \cdot \left(1 - t\right) - z \cdot \left(y + -1\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 59.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -7.2 \cdot 10^{+55}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -6 \cdot 10^{-184}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-281}:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;t \leq 1.2 \cdot 10^{-207}:\\ \;\;\;\;a + \left(x + y \cdot b\right)\\ \mathbf{elif}\;t \leq 5.4 \cdot 10^{+84}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \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 -7.2e+55)
     t_1
     (if (<= t -6e-184)
       (+ x (* b (- (+ y t) 2.0)))
       (if (<= t 8.5e-281)
         (- (* -2.0 b) (* y (- z b)))
         (if (<= t 1.2e-207)
           (+ a (+ x (* y b)))
           (if (<= t 5.4e+84) (+ x (* z (- 1.0 y))) 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 <= -7.2e+55) {
		tmp = t_1;
	} else if (t <= -6e-184) {
		tmp = x + (b * ((y + t) - 2.0));
	} else if (t <= 8.5e-281) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (t <= 1.2e-207) {
		tmp = a + (x + (y * b));
	} else if (t <= 5.4e+84) {
		tmp = x + (z * (1.0 - y));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * (b - a)
    if (t <= (-7.2d+55)) then
        tmp = t_1
    else if (t <= (-6d-184)) then
        tmp = x + (b * ((y + t) - 2.0d0))
    else if (t <= 8.5d-281) then
        tmp = ((-2.0d0) * b) - (y * (z - b))
    else if (t <= 1.2d-207) then
        tmp = a + (x + (y * b))
    else if (t <= 5.4d+84) then
        tmp = x + (z * (1.0d0 - y))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -7.2e+55) {
		tmp = t_1;
	} else if (t <= -6e-184) {
		tmp = x + (b * ((y + t) - 2.0));
	} else if (t <= 8.5e-281) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (t <= 1.2e-207) {
		tmp = a + (x + (y * b));
	} else if (t <= 5.4e+84) {
		tmp = x + (z * (1.0 - y));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -7.2e+55:
		tmp = t_1
	elif t <= -6e-184:
		tmp = x + (b * ((y + t) - 2.0))
	elif t <= 8.5e-281:
		tmp = (-2.0 * b) - (y * (z - b))
	elif t <= 1.2e-207:
		tmp = a + (x + (y * b))
	elif t <= 5.4e+84:
		tmp = x + (z * (1.0 - y))
	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 <= -7.2e+55)
		tmp = t_1;
	elseif (t <= -6e-184)
		tmp = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)));
	elseif (t <= 8.5e-281)
		tmp = Float64(Float64(-2.0 * b) - Float64(y * Float64(z - b)));
	elseif (t <= 1.2e-207)
		tmp = Float64(a + Float64(x + Float64(y * b)));
	elseif (t <= 5.4e+84)
		tmp = Float64(x + Float64(z * Float64(1.0 - y)));
	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 <= -7.2e+55)
		tmp = t_1;
	elseif (t <= -6e-184)
		tmp = x + (b * ((y + t) - 2.0));
	elseif (t <= 8.5e-281)
		tmp = (-2.0 * b) - (y * (z - b));
	elseif (t <= 1.2e-207)
		tmp = a + (x + (y * b));
	elseif (t <= 5.4e+84)
		tmp = x + (z * (1.0 - y));
	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, -7.2e+55], t$95$1, If[LessEqual[t, -6e-184], N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e-281], N[(N[(-2.0 * b), $MachinePrecision] - N[(y * N[(z - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e-207], N[(a + N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.4e+84], N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -7.19999999999999975e55 or 5.4e84 < t

   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 t around inf 79.0%

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

   if -7.19999999999999975e55 < t < -5.99999999999999982e-184

   1. Initial program 99.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 a around 0 89.5%

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

   4. Taylor expanded in z around 0 62.5%

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

   if -5.99999999999999982e-184 < t < 8.4999999999999994e-281

   1. Initial program 95.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 y around inf 70.6%

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

      1. mul-1-neg 70.6%

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

      2. distribute-rgt-neg-in 70.6%

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

   5. Simplified 70.6%

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

   6. Taylor expanded in t around 0 70.6%

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

      1. sub-neg 70.6%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \color{blue}{\left(y + \left(-2\right)\right)} \]

      2. metadata-eval 70.6%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \left(y + \color{blue}{-2}\right) \]

      3. distribute-rgt-in 70.6%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \color{blue}{\left(y \cdot b + -2 \cdot b\right)} \]

      4. *-commutative 70.6%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \left(\color{blue}{b \cdot y} + -2 \cdot b\right) \]

      5. associate-+r+ 70.6%

         \[\leadsto \color{blue}{\left(-1 \cdot \left(y \cdot z\right) + b \cdot y\right) + -2 \cdot b} \]

      6. mul-1-neg 70.6%

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

      7. distribute-rgt-neg-in 70.6%

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

      8. mul-1-neg 70.6%

         \[\leadsto \left(y \cdot \color{blue}{\left(-1 \cdot z\right)} + b \cdot y\right) + -2 \cdot b \]

      9. *-commutative 70.6%

         \[\leadsto \left(y \cdot \left(-1 \cdot z\right) + \color{blue}{y \cdot b}\right) + -2 \cdot b \]

      10. distribute-lft-in 75.3%

          \[\leadsto \color{blue}{y \cdot \left(-1 \cdot z + b\right)} + -2 \cdot b \]

      11. +-commutative 75.3%

          \[\leadsto y \cdot \color{blue}{\left(b + -1 \cdot z\right)} + -2 \cdot b \]

      12. mul-1-neg 75.3%

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

      13. sub-neg 75.3%

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

      14. *-commutative 75.3%

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

   8. Simplified 75.3%

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

   if 8.4999999999999994e-281 < t < 1.19999999999999994e-207

   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 t around 0 100.0%

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

   4. Taylor expanded in z around 0 87.6%

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

   5. Taylor expanded in y around inf 75.1%

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

   if 1.19999999999999994e-207 < t < 5.4e84

   1. Initial program 98.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 a around 0 84.7%

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

   4. Taylor expanded in b around 0 60.4%

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

4. Final simplification 71.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -7.2 \cdot 10^{+55}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -6 \cdot 10^{-184}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-281}:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;t \leq 1.2 \cdot 10^{-207}:\\ \;\;\;\;a + \left(x + y \cdot b\right)\\ \mathbf{elif}\;t \leq 5.4 \cdot 10^{+84}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 64.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -7.8 \cdot 10^{+213}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -1.3 \cdot 10^{+54}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;y \leq -116000000000:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+29}:\\ \;\;\;\;x + \left(z + \left(t + -2\right) \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))))
   (if (<= y -7.8e+213)
     t_1
     (if (<= y -1.3e+54)
       (* b (- (+ y t) 2.0))
       (if (<= y -116000000000.0)
         (- (* -2.0 b) (* y (- z b)))
         (if (<= y 5.2e+29) (+ x (+ z (* (+ t -2.0) b))) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double tmp;
	if (y <= -7.8e+213) {
		tmp = t_1;
	} else if (y <= -1.3e+54) {
		tmp = b * ((y + t) - 2.0);
	} else if (y <= -116000000000.0) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (y <= 5.2e+29) {
		tmp = x + (z + ((t + -2.0) * 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 = y * (b - z)
    if (y <= (-7.8d+213)) then
        tmp = t_1
    else if (y <= (-1.3d+54)) then
        tmp = b * ((y + t) - 2.0d0)
    else if (y <= (-116000000000.0d0)) then
        tmp = ((-2.0d0) * b) - (y * (z - b))
    else if (y <= 5.2d+29) then
        tmp = x + (z + ((t + (-2.0d0)) * 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 = y * (b - z);
	double tmp;
	if (y <= -7.8e+213) {
		tmp = t_1;
	} else if (y <= -1.3e+54) {
		tmp = b * ((y + t) - 2.0);
	} else if (y <= -116000000000.0) {
		tmp = (-2.0 * b) - (y * (z - b));
	} else if (y <= 5.2e+29) {
		tmp = x + (z + ((t + -2.0) * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	tmp = 0
	if y <= -7.8e+213:
		tmp = t_1
	elif y <= -1.3e+54:
		tmp = b * ((y + t) - 2.0)
	elif y <= -116000000000.0:
		tmp = (-2.0 * b) - (y * (z - b))
	elif y <= 5.2e+29:
		tmp = x + (z + ((t + -2.0) * b))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -7.8e+213)
		tmp = t_1;
	elseif (y <= -1.3e+54)
		tmp = Float64(b * Float64(Float64(y + t) - 2.0));
	elseif (y <= -116000000000.0)
		tmp = Float64(Float64(-2.0 * b) - Float64(y * Float64(z - b)));
	elseif (y <= 5.2e+29)
		tmp = Float64(x + Float64(z + Float64(Float64(t + -2.0) * b)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	tmp = 0.0;
	if (y <= -7.8e+213)
		tmp = t_1;
	elseif (y <= -1.3e+54)
		tmp = b * ((y + t) - 2.0);
	elseif (y <= -116000000000.0)
		tmp = (-2.0 * b) - (y * (z - b));
	elseif (y <= 5.2e+29)
		tmp = x + (z + ((t + -2.0) * b));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7.8e+213], t$95$1, If[LessEqual[y, -1.3e+54], N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -116000000000.0], N[(N[(-2.0 * b), $MachinePrecision] - N[(y * N[(z - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.2e+29], N[(x + N[(z + N[(N[(t + -2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -7.8000000000000003e213 or 5.2e29 < y

   1. Initial program 91.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 76.6%

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

   if -7.8000000000000003e213 < y < -1.30000000000000003e54

   1. Initial program 92.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 inf 82.8%

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

   if -1.30000000000000003e54 < y < -1.16e11

   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 y around inf 68.5%

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

      1. mul-1-neg 68.5%

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

      2. distribute-rgt-neg-in 68.5%

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

   5. Simplified 68.5%

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

   6. Taylor expanded in t around 0 68.5%

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

      1. sub-neg 68.5%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \color{blue}{\left(y + \left(-2\right)\right)} \]

      2. metadata-eval 68.5%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + b \cdot \left(y + \color{blue}{-2}\right) \]

      3. distribute-rgt-in 68.5%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \color{blue}{\left(y \cdot b + -2 \cdot b\right)} \]

      4. *-commutative 68.5%

         \[\leadsto -1 \cdot \left(y \cdot z\right) + \left(\color{blue}{b \cdot y} + -2 \cdot b\right) \]

      5. associate-+r+ 68.5%

         \[\leadsto \color{blue}{\left(-1 \cdot \left(y \cdot z\right) + b \cdot y\right) + -2 \cdot b} \]

      6. mul-1-neg 68.5%

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

      7. distribute-rgt-neg-in 68.5%

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

      8. mul-1-neg 68.5%

         \[\leadsto \left(y \cdot \color{blue}{\left(-1 \cdot z\right)} + b \cdot y\right) + -2 \cdot b \]

      9. *-commutative 68.5%

         \[\leadsto \left(y \cdot \left(-1 \cdot z\right) + \color{blue}{y \cdot b}\right) + -2 \cdot b \]

      10. distribute-lft-in 68.5%

          \[\leadsto \color{blue}{y \cdot \left(-1 \cdot z + b\right)} + -2 \cdot b \]

      11. +-commutative 68.5%

          \[\leadsto y \cdot \color{blue}{\left(b + -1 \cdot z\right)} + -2 \cdot b \]

      12. mul-1-neg 68.5%

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

      13. sub-neg 68.5%

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

      14. *-commutative 68.5%

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

   8. Simplified 68.5%

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

   if -1.16e11 < y < 5.2e29

   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 a around 0 72.9%

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

   4. Taylor expanded in y around 0 72.3%

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

      1. neg-mul-1 72.3%

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

      2. associate--l+ 72.3%

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

      3. sub-neg 72.3%

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

      4. metadata-eval 72.3%

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

   6. Simplified 72.3%

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

4. Final simplification 74.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -7.8 \cdot 10^{+213}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;y \leq -1.3 \cdot 10^{+54}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;y \leq -116000000000:\\ \;\;\;\;-2 \cdot b - y \cdot \left(z - b\right)\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{+29}:\\ \;\;\;\;x + \left(z + \left(t + -2\right) \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 48.1% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(y - 2\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -1350000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq 7.5 \cdot 10^{-263}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 4.4 \cdot 10^{-224}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;t \leq 300:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (- y 2.0))) (t_2 (* t (- b a))))
   (if (<= t -1350000000000.0)
     t_2
     (if (<= t 7.5e-263)
       t_1
       (if (<= t 4.4e-224) (* a (- 1.0 t)) (if (<= t 300.0) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (y - 2.0);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -1350000000000.0) {
		tmp = t_2;
	} else if (t <= 7.5e-263) {
		tmp = t_1;
	} else if (t <= 4.4e-224) {
		tmp = a * (1.0 - t);
	} else if (t <= 300.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 = b * (y - 2.0d0)
    t_2 = t * (b - a)
    if (t <= (-1350000000000.0d0)) then
        tmp = t_2
    else if (t <= 7.5d-263) then
        tmp = t_1
    else if (t <= 4.4d-224) then
        tmp = a * (1.0d0 - t)
    else if (t <= 300.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 = b * (y - 2.0);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -1350000000000.0) {
		tmp = t_2;
	} else if (t <= 7.5e-263) {
		tmp = t_1;
	} else if (t <= 4.4e-224) {
		tmp = a * (1.0 - t);
	} else if (t <= 300.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * (y - 2.0)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -1350000000000.0:
		tmp = t_2
	elif t <= 7.5e-263:
		tmp = t_1
	elif t <= 4.4e-224:
		tmp = a * (1.0 - t)
	elif t <= 300.0:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(y - 2.0))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -1350000000000.0)
		tmp = t_2;
	elseif (t <= 7.5e-263)
		tmp = t_1;
	elseif (t <= 4.4e-224)
		tmp = Float64(a * Float64(1.0 - t));
	elseif (t <= 300.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 = b * (y - 2.0);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -1350000000000.0)
		tmp = t_2;
	elseif (t <= 7.5e-263)
		tmp = t_1;
	elseif (t <= 4.4e-224)
		tmp = a * (1.0 - t);
	elseif (t <= 300.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[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1350000000000.0], t$95$2, If[LessEqual[t, 7.5e-263], t$95$1, If[LessEqual[t, 4.4e-224], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 300.0], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.35e12 or 300 < t

   1. Initial program 94.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 t around inf 72.5%

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

   if -1.35e12 < t < 7.50000000000000044e-263 or 4.4000000000000002e-224 < t < 300

   1. Initial program 97.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 inf 42.2%

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

   4. Taylor expanded in t around 0 42.2%

      \[\leadsto \color{blue}{b \cdot \left(y - 2\right)} \]

   if 7.50000000000000044e-263 < t < 4.4000000000000002e-224

   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 51.1%

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

4. Final simplification 56.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1350000000000:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq 7.5 \cdot 10^{-263}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 4.4 \cdot 10^{-224}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;t \leq 300:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 86.6% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (or (<= b -1.25e-16) (not (<= b 1200000.0)))
     (+ (+ x (* b (- (+ y t) 2.0))) t_1)
     (+ x (- t_1 (* z (+ y -1.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 <= -1.25e-16) || !(b <= 1200000.0)) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else {
		tmp = x + (t_1 - (z * (y + -1.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 <= (-1.25d-16)) .or. (.not. (b <= 1200000.0d0))) then
        tmp = (x + (b * ((y + t) - 2.0d0))) + t_1
    else
        tmp = x + (t_1 - (z * (y + (-1.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 <= -1.25e-16) || !(b <= 1200000.0)) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else {
		tmp = x + (t_1 - (z * (y + -1.0)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	tmp = 0
	if (b <= -1.25e-16) or not (b <= 1200000.0):
		tmp = (x + (b * ((y + t) - 2.0))) + t_1
	else:
		tmp = x + (t_1 - (z * (y + -1.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 <= -1.25e-16) || !(b <= 1200000.0))
		tmp = Float64(Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))) + t_1);
	else
		tmp = Float64(x + Float64(t_1 - Float64(z * Float64(y + -1.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 <= -1.25e-16) || ~((b <= 1200000.0)))
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	else
		tmp = x + (t_1 - (z * (y + -1.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[Or[LessEqual[b, -1.25e-16], N[Not[LessEqual[b, 1200000.0]], $MachinePrecision]], N[(N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(x + N[(t$95$1 - N[(z * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if b < -1.2500000000000001e-16 or 1.2e6 < 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 z around 0 86.5%

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

   if -1.2500000000000001e-16 < b < 1.2e6

   1. Initial program 99.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 0 90.2%

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

4. Final simplification 88.2%

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

Alternative 14: 85.5% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* b (- (+ y t) 2.0)))))
   (if (or (<= a -5.2e+27) (not (<= a 3700000000000.0)))
     (+ t_1 (* a (- 1.0 t)))
     (+ t_1 (* z (- 1.0 y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (b * ((y + t) - 2.0));
	double tmp;
	if ((a <= -5.2e+27) || !(a <= 3700000000000.0)) {
		tmp = t_1 + (a * (1.0 - t));
	} else {
		tmp = t_1 + (z * (1.0 - y));
	}
	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 + (b * ((y + t) - 2.0d0))
    if ((a <= (-5.2d+27)) .or. (.not. (a <= 3700000000000.0d0))) then
        tmp = t_1 + (a * (1.0d0 - t))
    else
        tmp = t_1 + (z * (1.0d0 - y))
    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 + (b * ((y + t) - 2.0));
	double tmp;
	if ((a <= -5.2e+27) || !(a <= 3700000000000.0)) {
		tmp = t_1 + (a * (1.0 - t));
	} else {
		tmp = t_1 + (z * (1.0 - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (b * ((y + t) - 2.0))
	tmp = 0
	if (a <= -5.2e+27) or not (a <= 3700000000000.0):
		tmp = t_1 + (a * (1.0 - t))
	else:
		tmp = t_1 + (z * (1.0 - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	tmp = 0.0
	if ((a <= -5.2e+27) || !(a <= 3700000000000.0))
		tmp = Float64(t_1 + Float64(a * Float64(1.0 - t)));
	else
		tmp = Float64(t_1 + Float64(z * Float64(1.0 - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (b * ((y + t) - 2.0));
	tmp = 0.0;
	if ((a <= -5.2e+27) || ~((a <= 3700000000000.0)))
		tmp = t_1 + (a * (1.0 - t));
	else
		tmp = t_1 + (z * (1.0 - y));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if a < -5.20000000000000018e27 or 3.7e12 < a

   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 z around 0 85.3%

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

   if -5.20000000000000018e27 < a < 3.7e12

   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 a around 0 96.0%

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

4. Final simplification 91.1%

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

Alternative 15: 86.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -2.2 \cdot 10^{+25} \lor \neg \left(a \leq 4100000000000\right):\\ \;\;\;\;a + \left(x + \left(t \cdot \left(b - a\right) - b \cdot \left(2 - y\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x + b \cdot \left(\left(y + t\right) - 2\right)\right) + z \cdot \left(1 - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= a -2.2e+25) (not (<= a 4100000000000.0)))
   (+ a (+ x (- (* t (- b a)) (* b (- 2.0 y)))))
   (+ (+ x (* b (- (+ y t) 2.0))) (* z (- 1.0 y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((a <= -2.2e+25) || !(a <= 4100000000000.0)) {
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))));
	} else {
		tmp = (x + (b * ((y + t) - 2.0))) + (z * (1.0 - y));
	}
	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 ((a <= (-2.2d+25)) .or. (.not. (a <= 4100000000000.0d0))) then
        tmp = a + (x + ((t * (b - a)) - (b * (2.0d0 - y))))
    else
        tmp = (x + (b * ((y + t) - 2.0d0))) + (z * (1.0d0 - y))
    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 ((a <= -2.2e+25) || !(a <= 4100000000000.0)) {
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))));
	} else {
		tmp = (x + (b * ((y + t) - 2.0))) + (z * (1.0 - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (a <= -2.2e+25) or not (a <= 4100000000000.0):
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))))
	else:
		tmp = (x + (b * ((y + t) - 2.0))) + (z * (1.0 - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((a <= -2.2e+25) || !(a <= 4100000000000.0))
		tmp = Float64(a + Float64(x + Float64(Float64(t * Float64(b - a)) - Float64(b * Float64(2.0 - y)))));
	else
		tmp = Float64(Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))) + Float64(z * Float64(1.0 - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((a <= -2.2e+25) || ~((a <= 4100000000000.0)))
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))));
	else
		tmp = (x + (b * ((y + t) - 2.0))) + (z * (1.0 - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -2.2e+25], N[Not[LessEqual[a, 4100000000000.0]], $MachinePrecision]], N[(a + N[(x + N[(N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision] - N[(b * N[(2.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -2.2000000000000001e25 or 4.1e12 < a

   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 t around 0 94.0%

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

   4. Taylor expanded in z around 0 86.2%

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

   if -2.2000000000000001e25 < a < 4.1e12

   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 a around 0 96.0%

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

4. Final simplification 91.5%

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

Alternative 16: 26.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1350000000000:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -1.2 \cdot 10^{-186}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 9.5 \cdot 10^{-276}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;t \leq 4.5 \cdot 10^{+27}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -1350000000000.0)
   (* t b)
   (if (<= t -1.2e-186)
     x
     (if (<= t 9.5e-276) (* -2.0 b) (if (<= t 4.5e+27) x (* t b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1350000000000.0) {
		tmp = t * b;
	} else if (t <= -1.2e-186) {
		tmp = x;
	} else if (t <= 9.5e-276) {
		tmp = -2.0 * b;
	} else if (t <= 4.5e+27) {
		tmp = x;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-1350000000000.0d0)) then
        tmp = t * b
    else if (t <= (-1.2d-186)) then
        tmp = x
    else if (t <= 9.5d-276) then
        tmp = (-2.0d0) * b
    else if (t <= 4.5d+27) then
        tmp = x
    else
        tmp = t * b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -1350000000000.0) {
		tmp = t * b;
	} else if (t <= -1.2e-186) {
		tmp = x;
	} else if (t <= 9.5e-276) {
		tmp = -2.0 * b;
	} else if (t <= 4.5e+27) {
		tmp = x;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -1350000000000.0:
		tmp = t * b
	elif t <= -1.2e-186:
		tmp = x
	elif t <= 9.5e-276:
		tmp = -2.0 * b
	elif t <= 4.5e+27:
		tmp = x
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -1350000000000.0)
		tmp = Float64(t * b);
	elseif (t <= -1.2e-186)
		tmp = x;
	elseif (t <= 9.5e-276)
		tmp = Float64(-2.0 * b);
	elseif (t <= 4.5e+27)
		tmp = x;
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -1350000000000.0)
		tmp = t * b;
	elseif (t <= -1.2e-186)
		tmp = x;
	elseif (t <= 9.5e-276)
		tmp = -2.0 * b;
	elseif (t <= 4.5e+27)
		tmp = x;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1350000000000.0], N[(t * b), $MachinePrecision], If[LessEqual[t, -1.2e-186], x, If[LessEqual[t, 9.5e-276], N[(-2.0 * b), $MachinePrecision], If[LessEqual[t, 4.5e+27], x, N[(t * b), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.35e12 or 4.4999999999999999e27 < t

   1. Initial program 94.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 t around inf 73.7%

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

   4. Taylor expanded in b around inf 42.6%

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

   if -1.35e12 < t < -1.20000000000000002e-186 or 9.49999999999999929e-276 < t < 4.4999999999999999e27

   1. Initial program 99.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 25.9%

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

   if -1.20000000000000002e-186 < t < 9.49999999999999929e-276

   1. Initial program 95.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 b around inf 53.3%

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

   4. Taylor expanded in t around 0 53.3%

      \[\leadsto \color{blue}{b \cdot \left(y - 2\right)} \]

   5. Taylor expanded in y around 0 30.7%

      \[\leadsto \color{blue}{-2 \cdot b} \]
   6. Step-by-step derivation

      1. *-commutative 30.7%

         \[\leadsto \color{blue}{b \cdot -2} \]

   7. Simplified 30.7%

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

4. Final simplification 34.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1350000000000:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -1.2 \cdot 10^{-186}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 9.5 \cdot 10^{-276}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;t \leq 4.5 \cdot 10^{+27}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \]
5. Add Preprocessing

Alternative 17: 68.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* (+ t -2.0) b)))
   (if (or (<= y -195000000000.0) (not (<= y 1000000.0)))
     (- t_1 (* y (- z b)))
     (+ x (+ z t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t + -2.0) * b;
	double tmp;
	if ((y <= -195000000000.0) || !(y <= 1000000.0)) {
		tmp = t_1 - (y * (z - b));
	} else {
		tmp = x + (z + 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 + (-2.0d0)) * b
    if ((y <= (-195000000000.0d0)) .or. (.not. (y <= 1000000.0d0))) then
        tmp = t_1 - (y * (z - b))
    else
        tmp = x + (z + 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 + -2.0) * b;
	double tmp;
	if ((y <= -195000000000.0) || !(y <= 1000000.0)) {
		tmp = t_1 - (y * (z - b));
	} else {
		tmp = x + (z + t_1);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t + -2.0) * b
	tmp = 0
	if (y <= -195000000000.0) or not (y <= 1000000.0):
		tmp = t_1 - (y * (z - b))
	else:
		tmp = x + (z + t_1)
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if y < -1.95e11 or 1e6 < y

   1. Initial program 92.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 y around inf 77.3%

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

      1. mul-1-neg 77.3%

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

      2. distribute-rgt-neg-in 77.3%

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

   5. Simplified 77.3%

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

   6. Taylor expanded in y around -inf 76.4%

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

      1. +-commutative 76.4%

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

      2. mul-1-neg 76.4%

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

      3. unsub-neg 76.4%

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

      4. sub-neg 76.4%

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

      5. metadata-eval 76.4%

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

      6. mul-1-neg 76.4%

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

      7. unsub-neg 76.4%

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

   8. Simplified 76.4%

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

   if -1.95e11 < y < 1e6

   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 a around 0 73.3%

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

   4. Taylor expanded in y around 0 73.2%

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

      1. neg-mul-1 73.2%

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

      2. associate--l+ 73.2%

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

      3. sub-neg 73.2%

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

      4. metadata-eval 73.2%

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

   6. Simplified 73.2%

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

4. Final simplification 74.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -195000000000 \lor \neg \left(y \leq 1000000\right):\\ \;\;\;\;\left(t + -2\right) \cdot b - y \cdot \left(z - b\right)\\ \mathbf{else}:\\ \;\;\;\;x + \left(z + \left(t + -2\right) \cdot b\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 68.5% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t + (-2.0d0)) * b
    if (y <= (-2600000000.0d0)) then
        tmp = (b * ((y + t) - 2.0d0)) - (y * z)
    else if (y <= 12500000.0d0) then
        tmp = x + (z + t_1)
    else
        tmp = t_1 - (y * (z - b))
    end if
    code = tmp
end function

Java

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

Python

def code(x, y, z, t, a, b):
	t_1 = (t + -2.0) * b
	tmp = 0
	if y <= -2600000000.0:
		tmp = (b * ((y + t) - 2.0)) - (y * z)
	elif y <= 12500000.0:
		tmp = x + (z + t_1)
	else:
		tmp = t_1 - (y * (z - b))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if y < -2.6e9

   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 86.9%

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

      1. mul-1-neg 86.9%

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

      2. distribute-rgt-neg-in 86.9%

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

   5. Simplified 86.9%

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

   if -2.6e9 < y < 1.25e7

   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 a around 0 73.3%

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

   4. Taylor expanded in y around 0 73.2%

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

      1. neg-mul-1 73.2%

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

      2. associate--l+ 73.2%

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

      3. sub-neg 73.2%

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

      4. metadata-eval 73.2%

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

   6. Simplified 73.2%

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

   if 1.25e7 < y

   1. Initial program 91.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 y around inf 68.8%

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

      1. mul-1-neg 68.8%

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

      2. distribute-rgt-neg-in 68.8%

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

   5. Simplified 68.8%

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

   6. Taylor expanded in y around -inf 70.6%

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

      1. +-commutative 70.6%

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

      2. mul-1-neg 70.6%

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

      3. unsub-neg 70.6%

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

      4. sub-neg 70.6%

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

      5. metadata-eval 70.6%

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

      6. mul-1-neg 70.6%

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

      7. unsub-neg 70.6%

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

   8. Simplified 70.6%

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

4. Final simplification 75.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2600000000:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right) - y \cdot z\\ \mathbf{elif}\;y \leq 12500000:\\ \;\;\;\;x + \left(z + \left(t + -2\right) \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;\left(t + -2\right) \cdot b - y \cdot \left(z - b\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 36.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;a \leq -8 \cdot 10^{+40}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -1.75 \cdot 10^{-193}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;a \leq 1.5 \cdot 10^{-23}:\\ \;\;\;\;t \cdot b\\ \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 -8e+40)
     t_1
     (if (<= a -1.75e-193) (* y b) (if (<= a 1.5e-23) (* t b) 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 <= -8e+40) {
		tmp = t_1;
	} else if (a <= -1.75e-193) {
		tmp = y * b;
	} else if (a <= 1.5e-23) {
		tmp = t * 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 = a * (1.0d0 - t)
    if (a <= (-8d+40)) then
        tmp = t_1
    else if (a <= (-1.75d-193)) then
        tmp = y * b
    else if (a <= 1.5d-23) then
        tmp = t * 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 = a * (1.0 - t);
	double tmp;
	if (a <= -8e+40) {
		tmp = t_1;
	} else if (a <= -1.75e-193) {
		tmp = y * b;
	} else if (a <= 1.5e-23) {
		tmp = t * b;
	} 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 <= -8e+40:
		tmp = t_1
	elif a <= -1.75e-193:
		tmp = y * b
	elif a <= 1.5e-23:
		tmp = t * b
	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 <= -8e+40)
		tmp = t_1;
	elseif (a <= -1.75e-193)
		tmp = Float64(y * b);
	elseif (a <= 1.5e-23)
		tmp = Float64(t * b);
	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 <= -8e+40)
		tmp = t_1;
	elseif (a <= -1.75e-193)
		tmp = y * b;
	elseif (a <= 1.5e-23)
		tmp = t * b;
	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, -8e+40], t$95$1, If[LessEqual[a, -1.75e-193], N[(y * b), $MachinePrecision], If[LessEqual[a, 1.5e-23], N[(t * b), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if a < -8.00000000000000024e40 or 1.50000000000000001e-23 < a

   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 a around inf 52.7%

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

   if -8.00000000000000024e40 < a < -1.75000000000000002e-193

   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 inf 51.8%

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

   4. Taylor expanded in y around inf 31.8%

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

   if -1.75000000000000002e-193 < a < 1.50000000000000001e-23

   1. Initial program 98.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 t around inf 29.2%

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

   4. Taylor expanded in b around inf 29.1%

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

4. Final simplification 40.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -8 \cdot 10^{+40}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;a \leq -1.75 \cdot 10^{-193}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;a \leq 1.5 \cdot 10^{-23}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 39.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;a \leq -9.2 \cdot 10^{+107}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -2.15 \cdot 10^{-193}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;a \leq 4.9 \cdot 10^{+61}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \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 -9.2e+107)
     t_1
     (if (<= a -2.15e-193)
       (* b (- y 2.0))
       (if (<= a 4.9e+61) (* b (- t 2.0)) 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 <= -9.2e+107) {
		tmp = t_1;
	} else if (a <= -2.15e-193) {
		tmp = b * (y - 2.0);
	} else if (a <= 4.9e+61) {
		tmp = b * (t - 2.0);
	} 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 <= (-9.2d+107)) then
        tmp = t_1
    else if (a <= (-2.15d-193)) then
        tmp = b * (y - 2.0d0)
    else if (a <= 4.9d+61) then
        tmp = b * (t - 2.0d0)
    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 <= -9.2e+107) {
		tmp = t_1;
	} else if (a <= -2.15e-193) {
		tmp = b * (y - 2.0);
	} else if (a <= 4.9e+61) {
		tmp = b * (t - 2.0);
	} 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 <= -9.2e+107:
		tmp = t_1
	elif a <= -2.15e-193:
		tmp = b * (y - 2.0)
	elif a <= 4.9e+61:
		tmp = b * (t - 2.0)
	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 <= -9.2e+107)
		tmp = t_1;
	elseif (a <= -2.15e-193)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (a <= 4.9e+61)
		tmp = Float64(b * Float64(t - 2.0));
	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 <= -9.2e+107)
		tmp = t_1;
	elseif (a <= -2.15e-193)
		tmp = b * (y - 2.0);
	elseif (a <= 4.9e+61)
		tmp = b * (t - 2.0);
	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, -9.2e+107], t$95$1, If[LessEqual[a, -2.15e-193], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.9e+61], N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if a < -9.2000000000000001e107 or 4.90000000000000025e61 < a

   1. Initial program 92.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 a around inf 65.5%

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

   if -9.2000000000000001e107 < a < -2.1500000000000001e-193

   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 inf 48.9%

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

   4. Taylor expanded in t around 0 35.6%

      \[\leadsto \color{blue}{b \cdot \left(y - 2\right)} \]

   if -2.1500000000000001e-193 < a < 4.90000000000000025e61

   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 y around inf 65.4%

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

      1. mul-1-neg 65.4%

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

      2. distribute-rgt-neg-in 65.4%

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

   5. Simplified 65.4%

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

   6. Taylor expanded in y around 0 37.6%

      \[\leadsto \color{blue}{b \cdot \left(t - 2\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 45.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -9.2 \cdot 10^{+107}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;a \leq -2.15 \cdot 10^{-193}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;a \leq 4.9 \cdot 10^{+61}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 21: 40.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -1.8 \cdot 10^{+43} \lor \neg \left(a \leq 1.3 \cdot 10^{+62}\right):\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= a -1.8e+43) (not (<= a 1.3e+62)))
   (* a (- 1.0 t))
   (* b (- t 2.0))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((a <= -1.8e+43) || !(a <= 1.3e+62)) {
		tmp = a * (1.0 - t);
	} else {
		tmp = b * (t - 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 ((a <= (-1.8d+43)) .or. (.not. (a <= 1.3d+62))) then
        tmp = a * (1.0d0 - t)
    else
        tmp = b * (t - 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 ((a <= -1.8e+43) || !(a <= 1.3e+62)) {
		tmp = a * (1.0 - t);
	} else {
		tmp = b * (t - 2.0);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (a <= -1.8e+43) or not (a <= 1.3e+62):
		tmp = a * (1.0 - t)
	else:
		tmp = b * (t - 2.0)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((a <= -1.8e+43) || !(a <= 1.3e+62))
		tmp = Float64(a * Float64(1.0 - t));
	else
		tmp = Float64(b * Float64(t - 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((a <= -1.8e+43) || ~((a <= 1.3e+62)))
		tmp = a * (1.0 - t);
	else
		tmp = b * (t - 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -1.8e+43], N[Not[LessEqual[a, 1.3e+62]], $MachinePrecision]], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -1.80000000000000005e43 or 1.29999999999999992e62 < a

   1. Initial program 92.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 a around inf 59.6%

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

   if -1.80000000000000005e43 < a < 1.29999999999999992e62

   1. Initial program 98.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 y around inf 67.7%

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

      1. mul-1-neg 67.7%

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

      2. distribute-rgt-neg-in 67.7%

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

   5. Simplified 67.7%

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

   6. Taylor expanded in y around 0 33.4%

      \[\leadsto \color{blue}{b \cdot \left(t - 2\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 43.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.8 \cdot 10^{+43} \lor \neg \left(a \leq 1.3 \cdot 10^{+62}\right):\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 22: 50.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.4 \cdot 10^{+114} \lor \neg \left(y \leq 5.2 \cdot 10^{+33}\right):\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -1.4e+114) (not (<= y 5.2e+33))) (* y (- b z)) (* t (- b a))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -1.4e+114) || !(y <= 5.2e+33)) {
		tmp = y * (b - z);
	} else {
		tmp = t * (b - a);
	}
	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 ((y <= (-1.4d+114)) .or. (.not. (y <= 5.2d+33))) then
        tmp = y * (b - z)
    else
        tmp = t * (b - a)
    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 ((y <= -1.4e+114) || !(y <= 5.2e+33)) {
		tmp = y * (b - z);
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -1.4e+114) or not (y <= 5.2e+33):
		tmp = y * (b - z)
	else:
		tmp = t * (b - a)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -1.4e+114) || !(y <= 5.2e+33))
		tmp = Float64(y * Float64(b - z));
	else
		tmp = Float64(t * Float64(b - a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -1.4e+114) || ~((y <= 5.2e+33)))
		tmp = y * (b - z);
	else
		tmp = t * (b - a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -1.4e+114], N[Not[LessEqual[y, 5.2e+33]], $MachinePrecision]], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -1.4e114 or 5.1999999999999995e33 < y

   1. Initial program 92.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 y around inf 79.2%

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

   if -1.4e114 < y < 5.1999999999999995e33

   1. Initial program 98.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 t around inf 40.2%

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

4. Final simplification 53.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -1.4 \cdot 10^{+114} \lor \neg \left(y \leq 5.2 \cdot 10^{+33}\right):\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 20.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.15 \cdot 10^{+91}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2.6 \cdot 10^{-24}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.15e+91) x (if (<= x 2.6e-24) z x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.15e+91) {
		tmp = x;
	} else if (x <= 2.6e-24) {
		tmp = z;
	} 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 <= (-1.15d+91)) then
        tmp = x
    else if (x <= 2.6d-24) then
        tmp = z
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.15e+91) {
		tmp = x;
	} else if (x <= 2.6e-24) {
		tmp = z;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.15e+91:
		tmp = x
	elif x <= 2.6e-24:
		tmp = z
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.15e+91)
		tmp = x;
	elseif (x <= 2.6e-24)
		tmp = z;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.15e+91)
		tmp = x;
	elseif (x <= 2.6e-24)
		tmp = z;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.15e+91], x, If[LessEqual[x, 2.6e-24], z, x]]

Derivation

1. Split input into 2 regimes

2. if x < -1.14999999999999996e91 or 2.6e-24 < x

   1. Initial program 95.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 26.9%

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

   if -1.14999999999999996e91 < x < 2.6e-24

   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 32.5%

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

   4. Taylor expanded in y around 0 18.2%

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

4. Final simplification 21.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.15 \cdot 10^{+91}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2.6 \cdot 10^{-24}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 24: 14.8% accurate, 21.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 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 x around inf 13.6%

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

4. Final simplification 13.6%

   \[\leadsto x \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024034 
(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)))