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

Percentage Accurate: 95.5% → 97.5%

Time: 18.6s

Alternatives: 25

Speedup: 0.5×

• 35.2% 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.5% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 97.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := \left(\left(x + z \cdot \left(1 - y\right)\right) + t_1\right) + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;t_2 \leq \infty:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;\left(x + y \cdot b\right) + t_1\\ \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_1) (* b (- (+ y t) 2.0)))))
   (if (<= t_2 INFINITY) t_2 (+ (+ x (* y 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 t_2 = ((x + (z * (1.0 - y))) + t_1) + (b * ((y + t) - 2.0));
	double tmp;
	if (t_2 <= ((double) INFINITY)) {
		tmp = t_2;
	} else {
		tmp = (x + (y * b)) + t_1;
	}
	return tmp;
}

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))) + t_1) + (b * ((y + t) - 2.0));
	double tmp;
	if (t_2 <= Double.POSITIVE_INFINITY) {
		tmp = t_2;
	} else {
		tmp = (x + (y * b)) + t_1;
	}
	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_1) + (b * ((y + t) - 2.0))
	tmp = 0
	if t_2 <= math.inf:
		tmp = t_2
	else:
		tmp = (x + (y * b)) + t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(Float64(Float64(x + Float64(z * Float64(1.0 - y))) + t_1) + Float64(b * Float64(Float64(y + t) - 2.0)))
	tmp = 0.0
	if (t_2 <= Inf)
		tmp = t_2;
	else
		tmp = Float64(Float64(x + Float64(y * b)) + t_1);
	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_1) + (b * ((y + t) - 2.0));
	tmp = 0.0;
	if (t_2 <= Inf)
		tmp = t_2;
	else
		tmp = (x + (y * b)) + 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]}, Block[{t$95$2 = N[(N[(N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision] + t$95$1), $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 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

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

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

   4. Taylor expanded in y around inf 71.4%

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

      1. *-commutative 71.4%

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

   6. Simplified 71.4%

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

4. Final simplification 99.2%

   \[\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}:\\ \;\;\;\;\left(x + y \cdot b\right) + a \cdot \left(1 - t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 97.8% 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 97.2%

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

   1. +-commutative 97.2%

      \[\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-def 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.4%

      \[\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.4%

      \[\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.4%

       \[\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.4%

       \[\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.4%

       \[\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.4%

       \[\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.4%

   \[\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.4%

   \[\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: 51.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z - y \cdot z\\ t_2 := x + y \cdot b\\ t_3 := a \cdot \left(1 - t\right)\\ t_4 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -1.1 \cdot 10^{+28}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq -7.8 \cdot 10^{-171}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.3 \cdot 10^{-284}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{-221}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 2.1 \cdot 10^{-201}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 2.5 \cdot 10^{-170}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 1.35 \cdot 10^{-129}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 2.9 \cdot 10^{-30}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_4\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- z (* y z)))
        (t_2 (+ x (* y b)))
        (t_3 (* a (- 1.0 t)))
        (t_4 (* b (- (+ y t) 2.0))))
   (if (<= b -1.1e+28)
     t_4
     (if (<= b -7.8e-171)
       t_1
       (if (<= b 1.3e-284)
         t_3
         (if (<= b 3.8e-221)
           t_1
           (if (<= b 2.1e-201)
             t_3
             (if (<= b 2.5e-170)
               t_2
               (if (<= b 1.35e-129) t_3 (if (<= b 2.9e-30) t_2 t_4))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z - (y * z);
	double t_2 = x + (y * b);
	double t_3 = a * (1.0 - t);
	double t_4 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1.1e+28) {
		tmp = t_4;
	} else if (b <= -7.8e-171) {
		tmp = t_1;
	} else if (b <= 1.3e-284) {
		tmp = t_3;
	} else if (b <= 3.8e-221) {
		tmp = t_1;
	} else if (b <= 2.1e-201) {
		tmp = t_3;
	} else if (b <= 2.5e-170) {
		tmp = t_2;
	} else if (b <= 1.35e-129) {
		tmp = t_3;
	} else if (b <= 2.9e-30) {
		tmp = t_2;
	} else {
		tmp = t_4;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = z - (y * z)
    t_2 = x + (y * b)
    t_3 = a * (1.0d0 - t)
    t_4 = b * ((y + t) - 2.0d0)
    if (b <= (-1.1d+28)) then
        tmp = t_4
    else if (b <= (-7.8d-171)) then
        tmp = t_1
    else if (b <= 1.3d-284) then
        tmp = t_3
    else if (b <= 3.8d-221) then
        tmp = t_1
    else if (b <= 2.1d-201) then
        tmp = t_3
    else if (b <= 2.5d-170) then
        tmp = t_2
    else if (b <= 1.35d-129) then
        tmp = t_3
    else if (b <= 2.9d-30) then
        tmp = t_2
    else
        tmp = t_4
    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 - (y * z);
	double t_2 = x + (y * b);
	double t_3 = a * (1.0 - t);
	double t_4 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1.1e+28) {
		tmp = t_4;
	} else if (b <= -7.8e-171) {
		tmp = t_1;
	} else if (b <= 1.3e-284) {
		tmp = t_3;
	} else if (b <= 3.8e-221) {
		tmp = t_1;
	} else if (b <= 2.1e-201) {
		tmp = t_3;
	} else if (b <= 2.5e-170) {
		tmp = t_2;
	} else if (b <= 1.35e-129) {
		tmp = t_3;
	} else if (b <= 2.9e-30) {
		tmp = t_2;
	} else {
		tmp = t_4;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z - (y * z)
	t_2 = x + (y * b)
	t_3 = a * (1.0 - t)
	t_4 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -1.1e+28:
		tmp = t_4
	elif b <= -7.8e-171:
		tmp = t_1
	elif b <= 1.3e-284:
		tmp = t_3
	elif b <= 3.8e-221:
		tmp = t_1
	elif b <= 2.1e-201:
		tmp = t_3
	elif b <= 2.5e-170:
		tmp = t_2
	elif b <= 1.35e-129:
		tmp = t_3
	elif b <= 2.9e-30:
		tmp = t_2
	else:
		tmp = t_4
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z - Float64(y * z))
	t_2 = Float64(x + Float64(y * b))
	t_3 = Float64(a * Float64(1.0 - t))
	t_4 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -1.1e+28)
		tmp = t_4;
	elseif (b <= -7.8e-171)
		tmp = t_1;
	elseif (b <= 1.3e-284)
		tmp = t_3;
	elseif (b <= 3.8e-221)
		tmp = t_1;
	elseif (b <= 2.1e-201)
		tmp = t_3;
	elseif (b <= 2.5e-170)
		tmp = t_2;
	elseif (b <= 1.35e-129)
		tmp = t_3;
	elseif (b <= 2.9e-30)
		tmp = t_2;
	else
		tmp = t_4;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z - (y * z);
	t_2 = x + (y * b);
	t_3 = a * (1.0 - t);
	t_4 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -1.1e+28)
		tmp = t_4;
	elseif (b <= -7.8e-171)
		tmp = t_1;
	elseif (b <= 1.3e-284)
		tmp = t_3;
	elseif (b <= 3.8e-221)
		tmp = t_1;
	elseif (b <= 2.1e-201)
		tmp = t_3;
	elseif (b <= 2.5e-170)
		tmp = t_2;
	elseif (b <= 1.35e-129)
		tmp = t_3;
	elseif (b <= 2.9e-30)
		tmp = t_2;
	else
		tmp = t_4;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.1e+28], t$95$4, If[LessEqual[b, -7.8e-171], t$95$1, If[LessEqual[b, 1.3e-284], t$95$3, If[LessEqual[b, 3.8e-221], t$95$1, If[LessEqual[b, 2.1e-201], t$95$3, If[LessEqual[b, 2.5e-170], t$95$2, If[LessEqual[b, 1.35e-129], t$95$3, If[LessEqual[b, 2.9e-30], t$95$2, t$95$4]]]]]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -1.09999999999999993e28 or 2.89999999999999989e-30 < b

   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 b around inf 69.7%

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

   if -1.09999999999999993e28 < b < -7.7999999999999997e-171 or 1.3e-284 < b < 3.8000000000000001e-221

   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 z around inf 52.3%

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

      1. sub-neg 52.3%

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

      2. distribute-rgt-in 52.4%

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

      3. *-un-lft-identity 52.4%

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

   5. Applied egg-rr 52.4%

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

   if -7.7999999999999997e-171 < b < 1.3e-284 or 3.8000000000000001e-221 < b < 2.10000000000000012e-201 or 2.50000000000000005e-170 < b < 1.35e-129

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

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

   if 2.10000000000000012e-201 < b < 2.50000000000000005e-170 or 1.35e-129 < b < 2.89999999999999989e-30

   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 0 77.0%

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

   4. Taylor expanded in a around 0 56.8%

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

   5. Taylor expanded in y around inf 56.8%

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

      1. *-commutative 77.0%

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

   7. Simplified 56.8%

      \[\leadsto x + \color{blue}{y \cdot b} \]
3. Recombined 4 regimes into one program.

4. Final simplification 60.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.1 \cdot 10^{+28}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -7.8 \cdot 10^{-171}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 1.3 \cdot 10^{-284}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 2.1 \cdot 10^{-201}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 2.5 \cdot 10^{-170}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{elif}\;b \leq 1.35 \cdot 10^{-129}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 2.9 \cdot 10^{-30}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 48.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ t_3 := x + -2 \cdot b\\ \mathbf{if}\;t \leq -2.8 \cdot 10^{+89}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -1.45 \cdot 10^{+58}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -920000000000:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -2.7 \cdot 10^{-170}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;t \leq -1.8 \cdot 10^{-231}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 2.4 \cdot 10^{-276}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;t \leq 4.6 \cdot 10^{+84}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))) (t_3 (+ x (* -2.0 b))))
   (if (<= t -2.8e+89)
     t_2
     (if (<= t -1.45e+58)
       t_1
       (if (<= t -920000000000.0)
         t_2
         (if (<= t -2.7e-170)
           t_3
           (if (<= t -1.8e-231)
             t_1
             (if (<= t 2.4e-276) t_3 (if (<= t 4.6e+84) t_1 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double t_3 = x + (-2.0 * b);
	double tmp;
	if (t <= -2.8e+89) {
		tmp = t_2;
	} else if (t <= -1.45e+58) {
		tmp = t_1;
	} else if (t <= -920000000000.0) {
		tmp = t_2;
	} else if (t <= -2.7e-170) {
		tmp = t_3;
	} else if (t <= -1.8e-231) {
		tmp = t_1;
	} else if (t <= 2.4e-276) {
		tmp = t_3;
	} else if (t <= 4.6e+84) {
		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) :: t_3
    real(8) :: tmp
    t_1 = y * (b - z)
    t_2 = t * (b - a)
    t_3 = x + ((-2.0d0) * b)
    if (t <= (-2.8d+89)) then
        tmp = t_2
    else if (t <= (-1.45d+58)) then
        tmp = t_1
    else if (t <= (-920000000000.0d0)) then
        tmp = t_2
    else if (t <= (-2.7d-170)) then
        tmp = t_3
    else if (t <= (-1.8d-231)) then
        tmp = t_1
    else if (t <= 2.4d-276) then
        tmp = t_3
    else if (t <= 4.6d+84) 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 = y * (b - z);
	double t_2 = t * (b - a);
	double t_3 = x + (-2.0 * b);
	double tmp;
	if (t <= -2.8e+89) {
		tmp = t_2;
	} else if (t <= -1.45e+58) {
		tmp = t_1;
	} else if (t <= -920000000000.0) {
		tmp = t_2;
	} else if (t <= -2.7e-170) {
		tmp = t_3;
	} else if (t <= -1.8e-231) {
		tmp = t_1;
	} else if (t <= 2.4e-276) {
		tmp = t_3;
	} else if (t <= 4.6e+84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	t_3 = x + (-2.0 * b)
	tmp = 0
	if t <= -2.8e+89:
		tmp = t_2
	elif t <= -1.45e+58:
		tmp = t_1
	elif t <= -920000000000.0:
		tmp = t_2
	elif t <= -2.7e-170:
		tmp = t_3
	elif t <= -1.8e-231:
		tmp = t_1
	elif t <= 2.4e-276:
		tmp = t_3
	elif t <= 4.6e+84:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	t_3 = Float64(x + Float64(-2.0 * b))
	tmp = 0.0
	if (t <= -2.8e+89)
		tmp = t_2;
	elseif (t <= -1.45e+58)
		tmp = t_1;
	elseif (t <= -920000000000.0)
		tmp = t_2;
	elseif (t <= -2.7e-170)
		tmp = t_3;
	elseif (t <= -1.8e-231)
		tmp = t_1;
	elseif (t <= 2.4e-276)
		tmp = t_3;
	elseif (t <= 4.6e+84)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	t_3 = x + (-2.0 * b);
	tmp = 0.0;
	if (t <= -2.8e+89)
		tmp = t_2;
	elseif (t <= -1.45e+58)
		tmp = t_1;
	elseif (t <= -920000000000.0)
		tmp = t_2;
	elseif (t <= -2.7e-170)
		tmp = t_3;
	elseif (t <= -1.8e-231)
		tmp = t_1;
	elseif (t <= 2.4e-276)
		tmp = t_3;
	elseif (t <= 4.6e+84)
		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[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e+89], t$95$2, If[LessEqual[t, -1.45e+58], t$95$1, If[LessEqual[t, -920000000000.0], t$95$2, If[LessEqual[t, -2.7e-170], t$95$3, If[LessEqual[t, -1.8e-231], t$95$1, If[LessEqual[t, 2.4e-276], t$95$3, If[LessEqual[t, 4.6e+84], t$95$1, t$95$2]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -2.7999999999999998e89 or -1.45000000000000001e58 < t < -9.2e11 or 4.5999999999999998e84 < t

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

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

   if -2.7999999999999998e89 < t < -1.45000000000000001e58 or -2.6999999999999999e-170 < t < -1.79999999999999987e-231 or 2.39999999999999983e-276 < t < 4.5999999999999998e84

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

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

   if -9.2e11 < t < -2.6999999999999999e-170 or -1.79999999999999987e-231 < t < 2.39999999999999983e-276

   1. Initial program 98.3%

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

   3. Taylor expanded in z around 0 75.8%

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

   4. Taylor expanded in a around 0 55.1%

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

   5. Taylor expanded in t around 0 55.1%

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

   6. Taylor expanded in y around 0 47.1%

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

      1. *-commutative 47.1%

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

   8. Simplified 47.1%

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

4. Final simplification 55.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2.8 \cdot 10^{+89}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -1.45 \cdot 10^{+58}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq -920000000000:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -2.7 \cdot 10^{-170}:\\ \;\;\;\;x + -2 \cdot b\\ \mathbf{elif}\;t \leq -1.8 \cdot 10^{-231}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq 2.4 \cdot 10^{-276}:\\ \;\;\;\;x + -2 \cdot b\\ \mathbf{elif}\;t \leq 4.6 \cdot 10^{+84}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 34.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;a \leq -1.15 \cdot 10^{+29}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -1.12 \cdot 10^{-306}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 5 \cdot 10^{-289}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;a \leq 7.2 \cdot 10^{-151}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.35 \cdot 10^{+29}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;a \leq 5.5 \cdot 10^{+54}:\\ \;\;\;\;x\\ \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 -1.15e+29)
     t_1
     (if (<= a -1.12e-306)
       x
       (if (<= a 5e-289)
         (* t b)
         (if (<= a 7.2e-151)
           x
           (if (<= a 1.35e+29) (* y b) (if (<= a 5.5e+54) x 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 <= -1.15e+29) {
		tmp = t_1;
	} else if (a <= -1.12e-306) {
		tmp = x;
	} else if (a <= 5e-289) {
		tmp = t * b;
	} else if (a <= 7.2e-151) {
		tmp = x;
	} else if (a <= 1.35e+29) {
		tmp = y * b;
	} else if (a <= 5.5e+54) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    if (a <= (-1.15d+29)) then
        tmp = t_1
    else if (a <= (-1.12d-306)) then
        tmp = x
    else if (a <= 5d-289) then
        tmp = t * b
    else if (a <= 7.2d-151) then
        tmp = x
    else if (a <= 1.35d+29) then
        tmp = y * b
    else if (a <= 5.5d+54) then
        tmp = x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (a <= -1.15e+29) {
		tmp = t_1;
	} else if (a <= -1.12e-306) {
		tmp = x;
	} else if (a <= 5e-289) {
		tmp = t * b;
	} else if (a <= 7.2e-151) {
		tmp = x;
	} else if (a <= 1.35e+29) {
		tmp = y * b;
	} else if (a <= 5.5e+54) {
		tmp = x;
	} 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 <= -1.15e+29:
		tmp = t_1
	elif a <= -1.12e-306:
		tmp = x
	elif a <= 5e-289:
		tmp = t * b
	elif a <= 7.2e-151:
		tmp = x
	elif a <= 1.35e+29:
		tmp = y * b
	elif a <= 5.5e+54:
		tmp = x
	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 <= -1.15e+29)
		tmp = t_1;
	elseif (a <= -1.12e-306)
		tmp = x;
	elseif (a <= 5e-289)
		tmp = Float64(t * b);
	elseif (a <= 7.2e-151)
		tmp = x;
	elseif (a <= 1.35e+29)
		tmp = Float64(y * b);
	elseif (a <= 5.5e+54)
		tmp = x;
	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 <= -1.15e+29)
		tmp = t_1;
	elseif (a <= -1.12e-306)
		tmp = x;
	elseif (a <= 5e-289)
		tmp = t * b;
	elseif (a <= 7.2e-151)
		tmp = x;
	elseif (a <= 1.35e+29)
		tmp = y * b;
	elseif (a <= 5.5e+54)
		tmp = x;
	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, -1.15e+29], t$95$1, If[LessEqual[a, -1.12e-306], x, If[LessEqual[a, 5e-289], N[(t * b), $MachinePrecision], If[LessEqual[a, 7.2e-151], x, If[LessEqual[a, 1.35e+29], N[(y * b), $MachinePrecision], If[LessEqual[a, 5.5e+54], x, t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -1.1500000000000001e29 or 5.50000000000000026e54 < a

   1. Initial program 95.9%

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

   3. Taylor expanded in a around inf 61.1%

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

   if -1.1500000000000001e29 < a < -1.12e-306 or 5.00000000000000029e-289 < a < 7.20000000000000064e-151 or 1.35e29 < a < 5.50000000000000026e54

   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 x around inf 34.3%

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

   if -1.12e-306 < a < 5.00000000000000029e-289

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

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

   4. Taylor expanded in b around inf 75.5%

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

      1. *-commutative 75.5%

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

   6. Simplified 75.5%

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

   if 7.20000000000000064e-151 < a < 1.35e29

   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 b around inf 53.1%

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

   4. Taylor expanded in y around inf 32.4%

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

      1. *-commutative 50.6%

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

   6. Simplified 32.4%

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

4. Final simplification 45.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.15 \cdot 10^{+29}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;a \leq -1.12 \cdot 10^{-306}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 5 \cdot 10^{-289}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;a \leq 7.2 \cdot 10^{-151}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 1.35 \cdot 10^{+29}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;a \leq 5.5 \cdot 10^{+54}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 37.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(y - 2\right)\\ t_2 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;a \leq -7.8 \cdot 10^{+28}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;a \leq -0.075:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -5.4 \cdot 10^{-115}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;a \leq -3.5 \cdot 10^{-303}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq 3.5 \cdot 10^{-151}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 2.15 \cdot 10^{+76}:\\ \;\;\;\;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 (* a (- 1.0 t))))
   (if (<= a -7.8e+28)
     t_2
     (if (<= a -0.075)
       t_1
       (if (<= a -5.4e-115)
         (* y (- z))
         (if (<= a -3.5e-303)
           t_1
           (if (<= a 3.5e-151) x (if (<= a 2.15e+76) 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 = a * (1.0 - t);
	double tmp;
	if (a <= -7.8e+28) {
		tmp = t_2;
	} else if (a <= -0.075) {
		tmp = t_1;
	} else if (a <= -5.4e-115) {
		tmp = y * -z;
	} else if (a <= -3.5e-303) {
		tmp = t_1;
	} else if (a <= 3.5e-151) {
		tmp = x;
	} else if (a <= 2.15e+76) {
		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 = a * (1.0d0 - t)
    if (a <= (-7.8d+28)) then
        tmp = t_2
    else if (a <= (-0.075d0)) then
        tmp = t_1
    else if (a <= (-5.4d-115)) then
        tmp = y * -z
    else if (a <= (-3.5d-303)) then
        tmp = t_1
    else if (a <= 3.5d-151) then
        tmp = x
    else if (a <= 2.15d+76) 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 = a * (1.0 - t);
	double tmp;
	if (a <= -7.8e+28) {
		tmp = t_2;
	} else if (a <= -0.075) {
		tmp = t_1;
	} else if (a <= -5.4e-115) {
		tmp = y * -z;
	} else if (a <= -3.5e-303) {
		tmp = t_1;
	} else if (a <= 3.5e-151) {
		tmp = x;
	} else if (a <= 2.15e+76) {
		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 = a * (1.0 - t)
	tmp = 0
	if a <= -7.8e+28:
		tmp = t_2
	elif a <= -0.075:
		tmp = t_1
	elif a <= -5.4e-115:
		tmp = y * -z
	elif a <= -3.5e-303:
		tmp = t_1
	elif a <= 3.5e-151:
		tmp = x
	elif a <= 2.15e+76:
		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(a * Float64(1.0 - t))
	tmp = 0.0
	if (a <= -7.8e+28)
		tmp = t_2;
	elseif (a <= -0.075)
		tmp = t_1;
	elseif (a <= -5.4e-115)
		tmp = Float64(y * Float64(-z));
	elseif (a <= -3.5e-303)
		tmp = t_1;
	elseif (a <= 3.5e-151)
		tmp = x;
	elseif (a <= 2.15e+76)
		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 = a * (1.0 - t);
	tmp = 0.0;
	if (a <= -7.8e+28)
		tmp = t_2;
	elseif (a <= -0.075)
		tmp = t_1;
	elseif (a <= -5.4e-115)
		tmp = y * -z;
	elseif (a <= -3.5e-303)
		tmp = t_1;
	elseif (a <= 3.5e-151)
		tmp = x;
	elseif (a <= 2.15e+76)
		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[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -7.8e+28], t$95$2, If[LessEqual[a, -0.075], t$95$1, If[LessEqual[a, -5.4e-115], N[(y * (-z)), $MachinePrecision], If[LessEqual[a, -3.5e-303], t$95$1, If[LessEqual[a, 3.5e-151], x, If[LessEqual[a, 2.15e+76], t$95$1, t$95$2]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if a < -7.7999999999999997e28 or 2.14999999999999989e76 < a

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

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

   if -7.7999999999999997e28 < a < -0.0749999999999999972 or -5.4e-115 < a < -3.5e-303 or 3.49999999999999995e-151 < a < 2.14999999999999989e76

   1. Initial program 95.9%

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

   3. Taylor expanded in b around inf 49.9%

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

   4. Taylor expanded in t around 0 40.5%

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

   if -0.0749999999999999972 < a < -5.4e-115

   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 z around inf 51.1%

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

   4. Taylor expanded in y around inf 37.7%

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

      1. mul-1-neg 37.7%

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

      2. distribute-lft-neg-out 37.7%

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

      3. *-commutative 37.7%

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

   6. Simplified 37.7%

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

   if -3.5e-303 < a < 3.49999999999999995e-151

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

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

4. Final simplification 49.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -7.8 \cdot 10^{+28}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;a \leq -0.075:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;a \leq -5.4 \cdot 10^{-115}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;a \leq -3.5 \cdot 10^{-303}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;a \leq 3.5 \cdot 10^{-151}:\\ \;\;\;\;x\\ \mathbf{elif}\;a \leq 2.15 \cdot 10^{+76}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 49.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -6.5 \cdot 10^{+87}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -2.5 \cdot 10^{+54}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq -1.7 \cdot 10^{+14}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -1.45 \cdot 10^{-171}:\\ \;\;\;\;x + -2 \cdot b\\ \mathbf{elif}\;t \leq -9.2 \cdot 10^{-208}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;t \leq 6.8 \cdot 10^{+89}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))))
   (if (<= t -6.5e+87)
     t_1
     (if (<= t -2.5e+54)
       (* y (- b z))
       (if (<= t -1.7e+14)
         t_1
         (if (<= t -1.45e-171)
           (+ x (* -2.0 b))
           (if (<= t -9.2e-208)
             (* z (- 1.0 y))
             (if (<= t 6.8e+89) (+ x (* y b)) 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 <= -6.5e+87) {
		tmp = t_1;
	} else if (t <= -2.5e+54) {
		tmp = y * (b - z);
	} else if (t <= -1.7e+14) {
		tmp = t_1;
	} else if (t <= -1.45e-171) {
		tmp = x + (-2.0 * b);
	} else if (t <= -9.2e-208) {
		tmp = z * (1.0 - y);
	} else if (t <= 6.8e+89) {
		tmp = x + (y * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * (b - a)
    if (t <= (-6.5d+87)) then
        tmp = t_1
    else if (t <= (-2.5d+54)) then
        tmp = y * (b - z)
    else if (t <= (-1.7d+14)) then
        tmp = t_1
    else if (t <= (-1.45d-171)) then
        tmp = x + ((-2.0d0) * b)
    else if (t <= (-9.2d-208)) then
        tmp = z * (1.0d0 - y)
    else if (t <= 6.8d+89) then
        tmp = x + (y * b)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -6.5e+87) {
		tmp = t_1;
	} else if (t <= -2.5e+54) {
		tmp = y * (b - z);
	} else if (t <= -1.7e+14) {
		tmp = t_1;
	} else if (t <= -1.45e-171) {
		tmp = x + (-2.0 * b);
	} else if (t <= -9.2e-208) {
		tmp = z * (1.0 - y);
	} else if (t <= 6.8e+89) {
		tmp = x + (y * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -6.5e+87:
		tmp = t_1
	elif t <= -2.5e+54:
		tmp = y * (b - z)
	elif t <= -1.7e+14:
		tmp = t_1
	elif t <= -1.45e-171:
		tmp = x + (-2.0 * b)
	elif t <= -9.2e-208:
		tmp = z * (1.0 - y)
	elif t <= 6.8e+89:
		tmp = x + (y * b)
	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 <= -6.5e+87)
		tmp = t_1;
	elseif (t <= -2.5e+54)
		tmp = Float64(y * Float64(b - z));
	elseif (t <= -1.7e+14)
		tmp = t_1;
	elseif (t <= -1.45e-171)
		tmp = Float64(x + Float64(-2.0 * b));
	elseif (t <= -9.2e-208)
		tmp = Float64(z * Float64(1.0 - y));
	elseif (t <= 6.8e+89)
		tmp = Float64(x + Float64(y * b));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	tmp = 0.0;
	if (t <= -6.5e+87)
		tmp = t_1;
	elseif (t <= -2.5e+54)
		tmp = y * (b - z);
	elseif (t <= -1.7e+14)
		tmp = t_1;
	elseif (t <= -1.45e-171)
		tmp = x + (-2.0 * b);
	elseif (t <= -9.2e-208)
		tmp = z * (1.0 - y);
	elseif (t <= 6.8e+89)
		tmp = x + (y * b);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.5e+87], t$95$1, If[LessEqual[t, -2.5e+54], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.7e+14], t$95$1, If[LessEqual[t, -1.45e-171], N[(x + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9.2e-208], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.8e+89], N[(x + N[(y * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -6.5000000000000002e87 or -2.50000000000000003e54 < t < -1.7e14 or 6.8000000000000004e89 < t

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

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

   if -6.5000000000000002e87 < t < -2.50000000000000003e54

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

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

   if -1.7e14 < t < -1.4499999999999999e-171

   1. Initial program 97.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 z around 0 76.1%

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

   4. Taylor expanded in a around 0 58.0%

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

   5. Taylor expanded in t around 0 58.0%

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

   6. Taylor expanded in y around 0 49.8%

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

      1. *-commutative 49.8%

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

   8. Simplified 49.8%

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

   if -1.4499999999999999e-171 < t < -9.19999999999999986e-208

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

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

   if -9.19999999999999986e-208 < t < 6.8000000000000004e89

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

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

   4. Taylor expanded in a around 0 58.9%

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

   5. Taylor expanded in y around inf 45.7%

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

      1. *-commutative 61.6%

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

   7. Simplified 45.7%

      \[\leadsto x + \color{blue}{y \cdot b} \]
3. Recombined 5 regimes into one program.

4. Final simplification 56.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -6.5 \cdot 10^{+87}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -2.5 \cdot 10^{+54}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq -1.7 \cdot 10^{+14}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -1.45 \cdot 10^{-171}:\\ \;\;\;\;x + -2 \cdot b\\ \mathbf{elif}\;t \leq -9.2 \cdot 10^{-208}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;t \leq 6.8 \cdot 10^{+89}:\\ \;\;\;\;x + y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 65.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_2 := x - a \cdot \left(t + -1\right)\\ \mathbf{if}\;b \leq -4.2 \cdot 10^{+25}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -4 \cdot 10^{-171}:\\ \;\;\;\;\left(x + z\right) - y \cdot z\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-255}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 1.36 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 6 \cdot 10^{-24}:\\ \;\;\;\;t_2\\ \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 (- x (* a (+ t -1.0)))))
   (if (<= b -4.2e+25)
     t_1
     (if (<= b -4e-171)
       (- (+ x z) (* y z))
       (if (<= b 2e-255)
         t_2
         (if (<= b 1.36e-221) (- z (* y z)) (if (<= b 6e-24) t_2 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 = x - (a * (t + -1.0));
	double tmp;
	if (b <= -4.2e+25) {
		tmp = t_1;
	} else if (b <= -4e-171) {
		tmp = (x + z) - (y * z);
	} else if (b <= 2e-255) {
		tmp = t_2;
	} else if (b <= 1.36e-221) {
		tmp = z - (y * z);
	} else if (b <= 6e-24) {
		tmp = t_2;
	} 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) :: tmp
    t_1 = x + (b * ((y + t) - 2.0d0))
    t_2 = x - (a * (t + (-1.0d0)))
    if (b <= (-4.2d+25)) then
        tmp = t_1
    else if (b <= (-4d-171)) then
        tmp = (x + z) - (y * z)
    else if (b <= 2d-255) then
        tmp = t_2
    else if (b <= 1.36d-221) then
        tmp = z - (y * z)
    else if (b <= 6d-24) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (b * ((y + t) - 2.0));
	double t_2 = x - (a * (t + -1.0));
	double tmp;
	if (b <= -4.2e+25) {
		tmp = t_1;
	} else if (b <= -4e-171) {
		tmp = (x + z) - (y * z);
	} else if (b <= 2e-255) {
		tmp = t_2;
	} else if (b <= 1.36e-221) {
		tmp = z - (y * z);
	} else if (b <= 6e-24) {
		tmp = t_2;
	} 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 = x - (a * (t + -1.0))
	tmp = 0
	if b <= -4.2e+25:
		tmp = t_1
	elif b <= -4e-171:
		tmp = (x + z) - (y * z)
	elif b <= 2e-255:
		tmp = t_2
	elif b <= 1.36e-221:
		tmp = z - (y * z)
	elif b <= 6e-24:
		tmp = t_2
	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(x - Float64(a * Float64(t + -1.0)))
	tmp = 0.0
	if (b <= -4.2e+25)
		tmp = t_1;
	elseif (b <= -4e-171)
		tmp = Float64(Float64(x + z) - Float64(y * z));
	elseif (b <= 2e-255)
		tmp = t_2;
	elseif (b <= 1.36e-221)
		tmp = Float64(z - Float64(y * z));
	elseif (b <= 6e-24)
		tmp = t_2;
	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 = x - (a * (t + -1.0));
	tmp = 0.0;
	if (b <= -4.2e+25)
		tmp = t_1;
	elseif (b <= -4e-171)
		tmp = (x + z) - (y * z);
	elseif (b <= 2e-255)
		tmp = t_2;
	elseif (b <= 1.36e-221)
		tmp = z - (y * z);
	elseif (b <= 6e-24)
		tmp = t_2;
	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[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.2e+25], t$95$1, If[LessEqual[b, -4e-171], N[(N[(x + z), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e-255], t$95$2, If[LessEqual[b, 1.36e-221], N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6e-24], t$95$2, t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -4.1999999999999998e25 or 5.99999999999999991e-24 < b

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

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

   4. Taylor expanded in a around 0 80.9%

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

   if -4.1999999999999998e25 < b < -3.9999999999999999e-171

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

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

   4. Taylor expanded in b around 0 87.5%

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

      1. sub-neg 87.5%

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

      2. metadata-eval 87.5%

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

      3. associate--r+ 87.5%

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

      4. *-commutative 87.5%

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

      5. cancel-sign-sub-inv 87.5%

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

      6. sub-neg 87.5%

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

      7. mul-1-neg 87.5%

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

      8. unsub-neg 87.5%

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

      9. mul-1-neg 87.5%

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

      10. remove-double-neg 87.5%

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

      11. +-commutative 87.5%

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

      12. distribute-neg-in 87.5%

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

      13. metadata-eval 87.5%

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

      14. sub-neg 87.5%

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

      15. *-commutative 87.5%

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

   6. Simplified 87.5%

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

   7. Taylor expanded in a around 0 71.6%

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

   if -3.9999999999999999e-171 < b < 2e-255 or 1.3600000000000001e-221 < b < 5.99999999999999991e-24

   1. Initial program 97.8%

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

   3. Taylor expanded in z around 0 76.3%

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

   4. Taylor expanded in b around 0 71.4%

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

   if 2e-255 < b < 1.3600000000000001e-221

   1. Initial program 99.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 z around inf 99.7%

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

      1. sub-neg 99.7%

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

      2. distribute-rgt-in 100.0%

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

      3. *-un-lft-identity 100.0%

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

   5. Applied egg-rr 100.0%

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

4. Final simplification 76.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -4.2 \cdot 10^{+25}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -4 \cdot 10^{-171}:\\ \;\;\;\;\left(x + z\right) - y \cdot z\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-255}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 1.36 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 6 \cdot 10^{-24}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{else}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 61.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(\left(y + t\right) - 2\right)\\ t_2 := x - a \cdot \left(t + -1\right)\\ \mathbf{if}\;b \leq -1.9 \cdot 10^{+32}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -4.4 \cdot 10^{-172}:\\ \;\;\;\;\left(x + z\right) - y \cdot z\\ \mathbf{elif}\;b \leq 3.1 \cdot 10^{-255}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 9 \cdot 10^{-22}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (- (+ y t) 2.0))) (t_2 (- x (* a (+ t -1.0)))))
   (if (<= b -1.9e+32)
     t_1
     (if (<= b -4.4e-172)
       (- (+ x z) (* y z))
       (if (<= b 3.1e-255)
         t_2
         (if (<= b 1.1e-221) (- z (* y z)) (if (<= b 9e-22) t_2 t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * ((y + t) - 2.0);
	double t_2 = x - (a * (t + -1.0));
	double tmp;
	if (b <= -1.9e+32) {
		tmp = t_1;
	} else if (b <= -4.4e-172) {
		tmp = (x + z) - (y * z);
	} else if (b <= 3.1e-255) {
		tmp = t_2;
	} else if (b <= 1.1e-221) {
		tmp = z - (y * z);
	} else if (b <= 9e-22) {
		tmp = t_2;
	} 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) :: tmp
    t_1 = b * ((y + t) - 2.0d0)
    t_2 = x - (a * (t + (-1.0d0)))
    if (b <= (-1.9d+32)) then
        tmp = t_1
    else if (b <= (-4.4d-172)) then
        tmp = (x + z) - (y * z)
    else if (b <= 3.1d-255) then
        tmp = t_2
    else if (b <= 1.1d-221) then
        tmp = z - (y * z)
    else if (b <= 9d-22) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * ((y + t) - 2.0);
	double t_2 = x - (a * (t + -1.0));
	double tmp;
	if (b <= -1.9e+32) {
		tmp = t_1;
	} else if (b <= -4.4e-172) {
		tmp = (x + z) - (y * z);
	} else if (b <= 3.1e-255) {
		tmp = t_2;
	} else if (b <= 1.1e-221) {
		tmp = z - (y * z);
	} else if (b <= 9e-22) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * ((y + t) - 2.0)
	t_2 = x - (a * (t + -1.0))
	tmp = 0
	if b <= -1.9e+32:
		tmp = t_1
	elif b <= -4.4e-172:
		tmp = (x + z) - (y * z)
	elif b <= 3.1e-255:
		tmp = t_2
	elif b <= 1.1e-221:
		tmp = z - (y * z)
	elif b <= 9e-22:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(Float64(y + t) - 2.0))
	t_2 = Float64(x - Float64(a * Float64(t + -1.0)))
	tmp = 0.0
	if (b <= -1.9e+32)
		tmp = t_1;
	elseif (b <= -4.4e-172)
		tmp = Float64(Float64(x + z) - Float64(y * z));
	elseif (b <= 3.1e-255)
		tmp = t_2;
	elseif (b <= 1.1e-221)
		tmp = Float64(z - Float64(y * z));
	elseif (b <= 9e-22)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = b * ((y + t) - 2.0);
	t_2 = x - (a * (t + -1.0));
	tmp = 0.0;
	if (b <= -1.9e+32)
		tmp = t_1;
	elseif (b <= -4.4e-172)
		tmp = (x + z) - (y * z);
	elseif (b <= 3.1e-255)
		tmp = t_2;
	elseif (b <= 1.1e-221)
		tmp = z - (y * z);
	elseif (b <= 9e-22)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.9e+32], t$95$1, If[LessEqual[b, -4.4e-172], N[(N[(x + z), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.1e-255], t$95$2, If[LessEqual[b, 1.1e-221], N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9e-22], t$95$2, t$95$1]]]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -1.9000000000000002e32 or 8.99999999999999973e-22 < b

   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 b around inf 71.6%

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

   if -1.9000000000000002e32 < b < -4.40000000000000018e-172

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

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

   4. Taylor expanded in b around 0 87.5%

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

      1. sub-neg 87.5%

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

      2. metadata-eval 87.5%

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

      3. associate--r+ 87.5%

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

      4. *-commutative 87.5%

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

      5. cancel-sign-sub-inv 87.5%

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

      6. sub-neg 87.5%

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

      7. mul-1-neg 87.5%

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

      8. unsub-neg 87.5%

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

      9. mul-1-neg 87.5%

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

      10. remove-double-neg 87.5%

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

      11. +-commutative 87.5%

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

      12. distribute-neg-in 87.5%

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

      13. metadata-eval 87.5%

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

      14. sub-neg 87.5%

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

      15. *-commutative 87.5%

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

   6. Simplified 87.5%

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

   7. Taylor expanded in a around 0 71.6%

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

   if -4.40000000000000018e-172 < b < 3.09999999999999997e-255 or 1.10000000000000001e-221 < b < 8.99999999999999973e-22

   1. Initial program 97.8%

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

   3. Taylor expanded in z around 0 76.3%

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

   4. Taylor expanded in b around 0 71.4%

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

   if 3.09999999999999997e-255 < b < 1.10000000000000001e-221

   1. Initial program 99.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 z around inf 99.7%

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

      1. sub-neg 99.7%

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

      2. distribute-rgt-in 100.0%

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

      3. *-un-lft-identity 100.0%

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

   5. Applied egg-rr 100.0%

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

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.9 \cdot 10^{+32}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -4.4 \cdot 10^{-172}:\\ \;\;\;\;\left(x + z\right) - y \cdot z\\ \mathbf{elif}\;b \leq 3.1 \cdot 10^{-255}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 9 \cdot 10^{-22}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 46.5% accurate, 0.7× 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 -120000:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -2.4 \cdot 10^{-143}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 2.25 \cdot 10^{-110}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 1.65 \cdot 10^{-47}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;t \leq 16000000000000:\\ \;\;\;\;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 -120000.0)
     t_2
     (if (<= t -2.4e-143)
       x
       (if (<= t 2.25e-110)
         t_1
         (if (<= t 1.65e-47)
           (* y (- z))
           (if (<= t 16000000000000.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 <= -120000.0) {
		tmp = t_2;
	} else if (t <= -2.4e-143) {
		tmp = x;
	} else if (t <= 2.25e-110) {
		tmp = t_1;
	} else if (t <= 1.65e-47) {
		tmp = y * -z;
	} else if (t <= 16000000000000.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 <= (-120000.0d0)) then
        tmp = t_2
    else if (t <= (-2.4d-143)) then
        tmp = x
    else if (t <= 2.25d-110) then
        tmp = t_1
    else if (t <= 1.65d-47) then
        tmp = y * -z
    else if (t <= 16000000000000.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 <= -120000.0) {
		tmp = t_2;
	} else if (t <= -2.4e-143) {
		tmp = x;
	} else if (t <= 2.25e-110) {
		tmp = t_1;
	} else if (t <= 1.65e-47) {
		tmp = y * -z;
	} else if (t <= 16000000000000.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 <= -120000.0:
		tmp = t_2
	elif t <= -2.4e-143:
		tmp = x
	elif t <= 2.25e-110:
		tmp = t_1
	elif t <= 1.65e-47:
		tmp = y * -z
	elif t <= 16000000000000.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 <= -120000.0)
		tmp = t_2;
	elseif (t <= -2.4e-143)
		tmp = x;
	elseif (t <= 2.25e-110)
		tmp = t_1;
	elseif (t <= 1.65e-47)
		tmp = Float64(y * Float64(-z));
	elseif (t <= 16000000000000.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 <= -120000.0)
		tmp = t_2;
	elseif (t <= -2.4e-143)
		tmp = x;
	elseif (t <= 2.25e-110)
		tmp = t_1;
	elseif (t <= 1.65e-47)
		tmp = y * -z;
	elseif (t <= 16000000000000.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, -120000.0], t$95$2, If[LessEqual[t, -2.4e-143], x, If[LessEqual[t, 2.25e-110], t$95$1, If[LessEqual[t, 1.65e-47], N[(y * (-z)), $MachinePrecision], If[LessEqual[t, 16000000000000.0], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -1.2e5 or 1.6e13 < t

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

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

   if -1.2e5 < t < -2.3999999999999999e-143

   1. Initial program 96.7%

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

   3. Taylor expanded in x around inf 38.7%

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

   if -2.3999999999999999e-143 < t < 2.25e-110 or 1.65000000000000002e-47 < t < 1.6e13

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

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

   4. Taylor expanded in t around 0 41.7%

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

   if 2.25e-110 < t < 1.65000000000000002e-47

   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.0%

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

   4. Taylor expanded in y around inf 47.1%

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

      1. mul-1-neg 47.1%

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

      2. distribute-lft-neg-out 47.1%

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

      3. *-commutative 47.1%

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

   6. Simplified 47.1%

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

4. Final simplification 50.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -120000:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -2.4 \cdot 10^{-143}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 2.25 \cdot 10^{-110}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 1.65 \cdot 10^{-47}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;t \leq 16000000000000:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 47.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -6.5 \cdot 10^{+87}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -8.5 \cdot 10^{+57}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -6500000000:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -1.65 \cdot 10^{-163}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 8 \cdot 10^{+87}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
   (if (<= t -6.5e+87)
     t_2
     (if (<= t -8.5e+57)
       t_1
       (if (<= t -6500000000.0)
         t_2
         (if (<= t -1.65e-163) x (if (<= t 8e+87) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -6.5e+87) {
		tmp = t_2;
	} else if (t <= -8.5e+57) {
		tmp = t_1;
	} else if (t <= -6500000000.0) {
		tmp = t_2;
	} else if (t <= -1.65e-163) {
		tmp = x;
	} else if (t <= 8e+87) {
		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 = y * (b - z)
    t_2 = t * (b - a)
    if (t <= (-6.5d+87)) then
        tmp = t_2
    else if (t <= (-8.5d+57)) then
        tmp = t_1
    else if (t <= (-6500000000.0d0)) then
        tmp = t_2
    else if (t <= (-1.65d-163)) then
        tmp = x
    else if (t <= 8d+87) 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 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -6.5e+87) {
		tmp = t_2;
	} else if (t <= -8.5e+57) {
		tmp = t_1;
	} else if (t <= -6500000000.0) {
		tmp = t_2;
	} else if (t <= -1.65e-163) {
		tmp = x;
	} else if (t <= 8e+87) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -6.5e+87:
		tmp = t_2
	elif t <= -8.5e+57:
		tmp = t_1
	elif t <= -6500000000.0:
		tmp = t_2
	elif t <= -1.65e-163:
		tmp = x
	elif t <= 8e+87:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -6.5e+87)
		tmp = t_2;
	elseif (t <= -8.5e+57)
		tmp = t_1;
	elseif (t <= -6500000000.0)
		tmp = t_2;
	elseif (t <= -1.65e-163)
		tmp = x;
	elseif (t <= 8e+87)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -6.5e+87)
		tmp = t_2;
	elseif (t <= -8.5e+57)
		tmp = t_1;
	elseif (t <= -6500000000.0)
		tmp = t_2;
	elseif (t <= -1.65e-163)
		tmp = x;
	elseif (t <= 8e+87)
		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[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.5e+87], t$95$2, If[LessEqual[t, -8.5e+57], t$95$1, If[LessEqual[t, -6500000000.0], t$95$2, If[LessEqual[t, -1.65e-163], x, If[LessEqual[t, 8e+87], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -6.5000000000000002e87 or -8.5000000000000001e57 < t < -6.5e9 or 7.9999999999999997e87 < t

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

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

   if -6.5000000000000002e87 < t < -8.5000000000000001e57 or -1.65e-163 < t < 7.9999999999999997e87

   1. Initial program 98.3%

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

   3. Taylor expanded in y around inf 41.1%

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

   if -6.5e9 < t < -1.65e-163

   1. Initial program 97.1%

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

   3. Taylor expanded in x around inf 36.3%

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

4. Final simplification 51.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -6.5 \cdot 10^{+87}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -8.5 \cdot 10^{+57}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq -6500000000:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq -1.65 \cdot 10^{-163}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 8 \cdot 10^{+87}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 24.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.9 \cdot 10^{+49}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq -4.8 \cdot 10^{-304}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-174}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-95}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 8.4 \cdot 10^{+40}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.9e+49)
   x
   (if (<= x -4.8e-304)
     (* y b)
     (if (<= x 1.5e-174)
       (* t b)
       (if (<= x 4.5e-95) (* y b) (if (<= x 8.4e+40) (* t b) x))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.9e+49) {
		tmp = x;
	} else if (x <= -4.8e-304) {
		tmp = y * b;
	} else if (x <= 1.5e-174) {
		tmp = t * b;
	} else if (x <= 4.5e-95) {
		tmp = y * b;
	} else if (x <= 8.4e+40) {
		tmp = t * b;
	} 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.9d+49)) then
        tmp = x
    else if (x <= (-4.8d-304)) then
        tmp = y * b
    else if (x <= 1.5d-174) then
        tmp = t * b
    else if (x <= 4.5d-95) then
        tmp = y * b
    else if (x <= 8.4d+40) then
        tmp = t * b
    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.9e+49) {
		tmp = x;
	} else if (x <= -4.8e-304) {
		tmp = y * b;
	} else if (x <= 1.5e-174) {
		tmp = t * b;
	} else if (x <= 4.5e-95) {
		tmp = y * b;
	} else if (x <= 8.4e+40) {
		tmp = t * b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.9e+49:
		tmp = x
	elif x <= -4.8e-304:
		tmp = y * b
	elif x <= 1.5e-174:
		tmp = t * b
	elif x <= 4.5e-95:
		tmp = y * b
	elif x <= 8.4e+40:
		tmp = t * b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.9e+49)
		tmp = x;
	elseif (x <= -4.8e-304)
		tmp = Float64(y * b);
	elseif (x <= 1.5e-174)
		tmp = Float64(t * b);
	elseif (x <= 4.5e-95)
		tmp = Float64(y * b);
	elseif (x <= 8.4e+40)
		tmp = Float64(t * b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.9e+49)
		tmp = x;
	elseif (x <= -4.8e-304)
		tmp = y * b;
	elseif (x <= 1.5e-174)
		tmp = t * b;
	elseif (x <= 4.5e-95)
		tmp = y * b;
	elseif (x <= 8.4e+40)
		tmp = t * b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.9e+49], x, If[LessEqual[x, -4.8e-304], N[(y * b), $MachinePrecision], If[LessEqual[x, 1.5e-174], N[(t * b), $MachinePrecision], If[LessEqual[x, 4.5e-95], N[(y * b), $MachinePrecision], If[LessEqual[x, 8.4e+40], N[(t * b), $MachinePrecision], x]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.8999999999999999e49 or 8.4000000000000004e40 < x

   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 x around inf 42.8%

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

   if -1.8999999999999999e49 < x < -4.8000000000000002e-304 or 1.50000000000000011e-174 < x < 4.5e-95

   1. Initial program 95.6%

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

   3. Taylor expanded in b around inf 46.4%

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

   4. Taylor expanded in y around inf 27.5%

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

      1. *-commutative 53.1%

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

   6. Simplified 27.5%

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

   if -4.8000000000000002e-304 < x < 1.50000000000000011e-174 or 4.5e-95 < x < 8.4000000000000004e40

   1. Initial program 95.9%

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

   3. Taylor expanded in t around inf 51.2%

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

   4. Taylor expanded in b around inf 31.5%

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

      1. *-commutative 31.5%

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

   6. Simplified 31.5%

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

4. Final simplification 35.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.9 \cdot 10^{+49}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq -4.8 \cdot 10^{-304}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-174}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-95}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 8.4 \cdot 10^{+40}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 25.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.25 \cdot 10^{+83}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq -1 \cdot 10^{-172}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-286}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;x \leq 1.1 \cdot 10^{-110}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 1.4 \cdot 10^{+44}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.25e+83)
   x
   (if (<= x -1e-172)
     (* t (- a))
     (if (<= x 1.7e-286)
       (* y (- z))
       (if (<= x 1.1e-110) (* y b) (if (<= x 1.4e+44) (* t b) x))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.25e+83) {
		tmp = x;
	} else if (x <= -1e-172) {
		tmp = t * -a;
	} else if (x <= 1.7e-286) {
		tmp = y * -z;
	} else if (x <= 1.1e-110) {
		tmp = y * b;
	} else if (x <= 1.4e+44) {
		tmp = t * b;
	} 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.25d+83)) then
        tmp = x
    else if (x <= (-1d-172)) then
        tmp = t * -a
    else if (x <= 1.7d-286) then
        tmp = y * -z
    else if (x <= 1.1d-110) then
        tmp = y * b
    else if (x <= 1.4d+44) then
        tmp = t * b
    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.25e+83) {
		tmp = x;
	} else if (x <= -1e-172) {
		tmp = t * -a;
	} else if (x <= 1.7e-286) {
		tmp = y * -z;
	} else if (x <= 1.1e-110) {
		tmp = y * b;
	} else if (x <= 1.4e+44) {
		tmp = t * b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.25e+83:
		tmp = x
	elif x <= -1e-172:
		tmp = t * -a
	elif x <= 1.7e-286:
		tmp = y * -z
	elif x <= 1.1e-110:
		tmp = y * b
	elif x <= 1.4e+44:
		tmp = t * b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.25e+83)
		tmp = x;
	elseif (x <= -1e-172)
		tmp = Float64(t * Float64(-a));
	elseif (x <= 1.7e-286)
		tmp = Float64(y * Float64(-z));
	elseif (x <= 1.1e-110)
		tmp = Float64(y * b);
	elseif (x <= 1.4e+44)
		tmp = Float64(t * b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.25e+83)
		tmp = x;
	elseif (x <= -1e-172)
		tmp = t * -a;
	elseif (x <= 1.7e-286)
		tmp = y * -z;
	elseif (x <= 1.1e-110)
		tmp = y * b;
	elseif (x <= 1.4e+44)
		tmp = t * b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.25e+83], x, If[LessEqual[x, -1e-172], N[(t * (-a)), $MachinePrecision], If[LessEqual[x, 1.7e-286], N[(y * (-z)), $MachinePrecision], If[LessEqual[x, 1.1e-110], N[(y * b), $MachinePrecision], If[LessEqual[x, 1.4e+44], N[(t * b), $MachinePrecision], x]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -1.25000000000000007e83 or 1.4e44 < x

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

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

   if -1.25000000000000007e83 < x < -1e-172

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

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

   4. Taylor expanded in t around inf 26.8%

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

      1. mul-1-neg 26.8%

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

      2. *-commutative 26.8%

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

      3. distribute-rgt-neg-in 26.8%

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

   6. Simplified 26.8%

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

   if -1e-172 < x < 1.7000000000000001e-286

   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 z around inf 56.6%

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

   4. Taylor expanded in y around inf 40.8%

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

      1. mul-1-neg 40.8%

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

      2. distribute-lft-neg-out 40.8%

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

      3. *-commutative 40.8%

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

   6. Simplified 40.8%

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

   if 1.7000000000000001e-286 < x < 1.1e-110

   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 b around inf 54.4%

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

   4. Taylor expanded in y around inf 29.6%

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

      1. *-commutative 59.4%

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

   6. Simplified 29.6%

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

   if 1.1e-110 < x < 1.4e44

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

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

   4. Taylor expanded in b around inf 30.8%

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

      1. *-commutative 30.8%

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

   6. Simplified 30.8%

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

4. Final simplification 37.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.25 \cdot 10^{+83}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq -1 \cdot 10^{-172}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-286}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;x \leq 1.1 \cdot 10^{-110}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 1.4 \cdot 10^{+44}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 61.2% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - a \cdot \left(t + -1\right)\\ t_2 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -4.5 \cdot 10^{+48}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 3.1 \cdot 10^{-255}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 2.85 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{-21}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- x (* a (+ t -1.0)))) (t_2 (* b (- (+ y t) 2.0))))
   (if (<= b -4.5e+48)
     t_2
     (if (<= b 3.1e-255)
       t_1
       (if (<= b 2.85e-221) (- z (* y z)) (if (<= b 1.1e-21) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (a * (t + -1.0));
	double t_2 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -4.5e+48) {
		tmp = t_2;
	} else if (b <= 3.1e-255) {
		tmp = t_1;
	} else if (b <= 2.85e-221) {
		tmp = z - (y * z);
	} else if (b <= 1.1e-21) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x - (a * (t + (-1.0d0)))
    t_2 = b * ((y + t) - 2.0d0)
    if (b <= (-4.5d+48)) then
        tmp = t_2
    else if (b <= 3.1d-255) then
        tmp = t_1
    else if (b <= 2.85d-221) then
        tmp = z - (y * z)
    else if (b <= 1.1d-21) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (a * (t + -1.0));
	double t_2 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -4.5e+48) {
		tmp = t_2;
	} else if (b <= 3.1e-255) {
		tmp = t_1;
	} else if (b <= 2.85e-221) {
		tmp = z - (y * z);
	} else if (b <= 1.1e-21) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x - (a * (t + -1.0))
	t_2 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -4.5e+48:
		tmp = t_2
	elif b <= 3.1e-255:
		tmp = t_1
	elif b <= 2.85e-221:
		tmp = z - (y * z)
	elif b <= 1.1e-21:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x - Float64(a * Float64(t + -1.0)))
	t_2 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -4.5e+48)
		tmp = t_2;
	elseif (b <= 3.1e-255)
		tmp = t_1;
	elseif (b <= 2.85e-221)
		tmp = Float64(z - Float64(y * z));
	elseif (b <= 1.1e-21)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x - (a * (t + -1.0));
	t_2 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -4.5e+48)
		tmp = t_2;
	elseif (b <= 3.1e-255)
		tmp = t_1;
	elseif (b <= 2.85e-221)
		tmp = z - (y * z);
	elseif (b <= 1.1e-21)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.5e+48], t$95$2, If[LessEqual[b, 3.1e-255], t$95$1, If[LessEqual[b, 2.85e-221], N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.1e-21], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -4.49999999999999995e48 or 1.1e-21 < b

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

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

   if -4.49999999999999995e48 < b < 3.09999999999999997e-255 or 2.8500000000000001e-221 < b < 1.1e-21

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

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

   4. Taylor expanded in b around 0 60.4%

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

   if 3.09999999999999997e-255 < b < 2.8500000000000001e-221

   1. Initial program 99.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 z around inf 99.7%

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

      1. sub-neg 99.7%

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

      2. distribute-rgt-in 100.0%

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

      3. *-un-lft-identity 100.0%

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

   5. Applied egg-rr 100.0%

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

4. Final simplification 66.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -4.5 \cdot 10^{+48}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq 3.1 \cdot 10^{-255}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 2.85 \cdot 10^{-221}:\\ \;\;\;\;z - y \cdot z\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{-21}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 86.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;b \leq -1.55 \cdot 10^{+25} \lor \neg \left(b \leq 9.2 \cdot 10^{-37}\right):\\ \;\;\;\;\left(x + b \cdot \left(\left(y + t\right) - 2\right)\right) + t_1\\ \mathbf{else}:\\ \;\;\;\;\left(z + \left(x - y \cdot z\right)\right) + t_1\\ \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.55e+25) (not (<= b 9.2e-37)))
     (+ (+ x (* b (- (+ y t) 2.0))) t_1)
     (+ (+ z (- x (* y z))) t_1))))

C

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

Python

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

Derivation

1. Split input into 2 regimes

2. if b < -1.5499999999999999e25 or 9.1999999999999999e-37 < b

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

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

   if -1.5499999999999999e25 < b < 9.1999999999999999e-37

   1. Initial program 98.6%

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

   3. Taylor expanded in y around 0 98.6%

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

   4. Taylor expanded in b around 0 92.4%

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

      1. sub-neg 92.4%

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

      2. metadata-eval 92.4%

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

      3. associate--r+ 92.4%

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

      4. *-commutative 92.4%

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

      5. cancel-sign-sub-inv 92.4%

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

      6. sub-neg 92.4%

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

      7. mul-1-neg 92.4%

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

      8. unsub-neg 92.4%

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

      9. mul-1-neg 92.4%

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

      10. remove-double-neg 92.4%

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

      11. +-commutative 92.4%

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

      12. distribute-neg-in 92.4%

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

      13. metadata-eval 92.4%

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

      14. sub-neg 92.4%

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

      15. *-commutative 92.4%

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

   6. Simplified 92.4%

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

4. Final simplification 92.1%

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

Alternative 16: 86.2% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (<= b -1.4e+25)
     (+ (+ x (* b (- (+ y t) 2.0))) t_1)
     (if (<= b 1.55e-37)
       (+ (+ z (- x (* y z))) t_1)
       (+ a (+ x (- (* t (- b a)) (* b (- 2.0 y)))))))))

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.4e+25) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else if (b <= 1.55e-37) {
		tmp = (z + (x - (y * z))) + t_1;
	} else {
		tmp = a + (x + ((t * (b - a)) - (b * (2.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 = a * (1.0d0 - t)
    if (b <= (-1.4d+25)) then
        tmp = (x + (b * ((y + t) - 2.0d0))) + t_1
    else if (b <= 1.55d-37) then
        tmp = (z + (x - (y * z))) + t_1
    else
        tmp = a + (x + ((t * (b - a)) - (b * (2.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 = a * (1.0 - t);
	double tmp;
	if (b <= -1.4e+25) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else if (b <= 1.55e-37) {
		tmp = (z + (x - (y * z))) + t_1;
	} else {
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	tmp = 0
	if b <= -1.4e+25:
		tmp = (x + (b * ((y + t) - 2.0))) + t_1
	elif b <= 1.55e-37:
		tmp = (z + (x - (y * z))) + t_1
	else:
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))))
	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.4e+25)
		tmp = Float64(Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))) + t_1);
	elseif (b <= 1.55e-37)
		tmp = Float64(Float64(z + Float64(x - Float64(y * z))) + t_1);
	else
		tmp = Float64(a + Float64(x + Float64(Float64(t * Float64(b - a)) - Float64(b * Float64(2.0 - y)))));
	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.4e+25)
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	elseif (b <= 1.55e-37)
		tmp = (z + (x - (y * z))) + t_1;
	else
		tmp = a + (x + ((t * (b - a)) - (b * (2.0 - y))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if b < -1.4000000000000001e25

   1. Initial program 94.5%

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

   3. Taylor expanded in z around 0 94.0%

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

   if -1.4000000000000001e25 < b < 1.54999999999999997e-37

   1. Initial program 98.6%

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

   3. Taylor expanded in y around 0 98.6%

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

   4. Taylor expanded in b around 0 92.4%

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

      1. sub-neg 92.4%

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

      2. metadata-eval 92.4%

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

      3. associate--r+ 92.4%

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

      4. *-commutative 92.4%

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

      5. cancel-sign-sub-inv 92.4%

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

      6. sub-neg 92.4%

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

      7. mul-1-neg 92.4%

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

      8. unsub-neg 92.4%

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

      9. mul-1-neg 92.4%

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

      10. remove-double-neg 92.4%

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

      11. +-commutative 92.4%

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

      12. distribute-neg-in 92.4%

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

      13. metadata-eval 92.4%

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

      14. sub-neg 92.4%

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

      15. *-commutative 92.4%

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

   6. Simplified 92.4%

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

   if 1.54999999999999997e-37 < b

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

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

   4. Taylor expanded in t around 0 89.6%

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

4. Final simplification 92.1%

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

Alternative 17: 25.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.8 \cdot 10^{+81}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2 \cdot 10^{-172}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;x \leq 1.25 \cdot 10^{-95}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 4.2 \cdot 10^{+41}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.8e+81)
   x
   (if (<= x 2e-172)
     (* t (- a))
     (if (<= x 1.25e-95) (* y b) (if (<= x 4.2e+41) (* t b) x)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.8e+81) {
		tmp = x;
	} else if (x <= 2e-172) {
		tmp = t * -a;
	} else if (x <= 1.25e-95) {
		tmp = y * b;
	} else if (x <= 4.2e+41) {
		tmp = t * b;
	} 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.8d+81)) then
        tmp = x
    else if (x <= 2d-172) then
        tmp = t * -a
    else if (x <= 1.25d-95) then
        tmp = y * b
    else if (x <= 4.2d+41) then
        tmp = t * b
    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.8e+81) {
		tmp = x;
	} else if (x <= 2e-172) {
		tmp = t * -a;
	} else if (x <= 1.25e-95) {
		tmp = y * b;
	} else if (x <= 4.2e+41) {
		tmp = t * b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.8e+81:
		tmp = x
	elif x <= 2e-172:
		tmp = t * -a
	elif x <= 1.25e-95:
		tmp = y * b
	elif x <= 4.2e+41:
		tmp = t * b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.8e+81)
		tmp = x;
	elseif (x <= 2e-172)
		tmp = Float64(t * Float64(-a));
	elseif (x <= 1.25e-95)
		tmp = Float64(y * b);
	elseif (x <= 4.2e+41)
		tmp = Float64(t * b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.8e+81)
		tmp = x;
	elseif (x <= 2e-172)
		tmp = t * -a;
	elseif (x <= 1.25e-95)
		tmp = y * b;
	elseif (x <= 4.2e+41)
		tmp = t * b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.8e+81], x, If[LessEqual[x, 2e-172], N[(t * (-a)), $MachinePrecision], If[LessEqual[x, 1.25e-95], N[(y * b), $MachinePrecision], If[LessEqual[x, 4.2e+41], N[(t * b), $MachinePrecision], x]]]]

Derivation

1. Split input into 4 regimes

2. if x < -1.80000000000000003e81 or 4.1999999999999999e41 < x

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

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

   if -1.80000000000000003e81 < x < 2.0000000000000001e-172

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

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

   4. Taylor expanded in t around inf 23.8%

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

      1. mul-1-neg 23.8%

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

      2. *-commutative 23.8%

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

      3. distribute-rgt-neg-in 23.8%

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

   6. Simplified 23.8%

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

   if 2.0000000000000001e-172 < x < 1.2499999999999999e-95

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

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

   4. Taylor expanded in y around inf 39.4%

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

      1. *-commutative 53.5%

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

   6. Simplified 39.4%

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

   if 1.2499999999999999e-95 < x < 4.1999999999999999e41

   1. Initial program 96.4%

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

   3. Taylor expanded in t around inf 54.3%

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

   4. Taylor expanded in b around inf 36.9%

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

      1. *-commutative 36.9%

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

   6. Simplified 36.9%

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

4. Final simplification 35.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.8 \cdot 10^{+81}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2 \cdot 10^{-172}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;x \leq 1.25 \cdot 10^{-95}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;x \leq 4.2 \cdot 10^{+41}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 81.9% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -3e+48) (not (<= b 1.1e-21)))
   (+ x (* b (- (+ y t) 2.0)))
   (+ (+ z (- x (* y z))) (* a (- 1.0 t)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -3e+48) || !(b <= 1.1e-21)) {
		tmp = x + (b * ((y + t) - 2.0));
	} else {
		tmp = (z + (x - (y * z))) + (a * (1.0 - t));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((b <= (-3d+48)) .or. (.not. (b <= 1.1d-21))) then
        tmp = x + (b * ((y + t) - 2.0d0))
    else
        tmp = (z + (x - (y * z))) + (a * (1.0d0 - t))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -3e+48) || !(b <= 1.1e-21)) {
		tmp = x + (b * ((y + t) - 2.0));
	} else {
		tmp = (z + (x - (y * z))) + (a * (1.0 - t));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (b <= -3e+48) or not (b <= 1.1e-21):
		tmp = x + (b * ((y + t) - 2.0))
	else:
		tmp = (z + (x - (y * z))) + (a * (1.0 - t))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if b < -3e48 or 1.1e-21 < b

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

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

   4. Taylor expanded in a around 0 83.2%

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

   if -3e48 < b < 1.1e-21

   1. Initial program 98.6%

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

   3. Taylor expanded in y around 0 98.7%

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

   4. Taylor expanded in b around 0 90.4%

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

      1. sub-neg 90.4%

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

      2. metadata-eval 90.4%

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

      3. associate--r+ 90.4%

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

      4. *-commutative 90.4%

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

      5. cancel-sign-sub-inv 90.4%

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

      6. sub-neg 90.4%

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

      7. mul-1-neg 90.4%

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

      8. unsub-neg 90.4%

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

      9. mul-1-neg 90.4%

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

      10. remove-double-neg 90.4%

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

      11. +-commutative 90.4%

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

      12. distribute-neg-in 90.4%

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

      13. metadata-eval 90.4%

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

      14. sub-neg 90.4%

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

      15. *-commutative 90.4%

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

   6. Simplified 90.4%

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

4. Final simplification 87.5%

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

Alternative 19: 95.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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 + ((b * (t - 2.0d0)) + (y * (b - z)))) + (z - (a * (t + (-1.0d0))))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.2%

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

3. Taylor expanded in y around 0 97.6%

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

4. Final simplification 97.6%

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

Alternative 20: 71.7% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -5.4e+47) (not (<= b 6e-22)))
   (+ x (* b (- (+ y t) 2.0)))
   (+ (+ x z) (* a (- 1.0 t)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -5.4e+47) || !(b <= 6e-22)) {
		tmp = x + (b * ((y + t) - 2.0));
	} else {
		tmp = (x + z) + (a * (1.0 - t));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((b <= (-5.4d+47)) .or. (.not. (b <= 6d-22))) then
        tmp = x + (b * ((y + t) - 2.0d0))
    else
        tmp = (x + z) + (a * (1.0d0 - t))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -5.4e+47) || !(b <= 6e-22)) {
		tmp = x + (b * ((y + t) - 2.0));
	} else {
		tmp = (x + z) + (a * (1.0 - t));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (b <= -5.4e+47) or not (b <= 6e-22):
		tmp = x + (b * ((y + t) - 2.0))
	else:
		tmp = (x + z) + (a * (1.0 - t))
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if b < -5.39999999999999991e47 or 5.9999999999999998e-22 < b

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

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

   4. Taylor expanded in a around 0 83.2%

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

   if -5.39999999999999991e47 < b < 5.9999999999999998e-22

   1. Initial program 98.6%

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

   3. Taylor expanded in y around 0 98.7%

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

   4. Taylor expanded in b around 0 90.4%

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

      1. sub-neg 90.4%

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

      2. metadata-eval 90.4%

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

      3. associate--r+ 90.4%

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

      4. *-commutative 90.4%

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

      5. cancel-sign-sub-inv 90.4%

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

      6. sub-neg 90.4%

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

      7. mul-1-neg 90.4%

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

      8. unsub-neg 90.4%

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

      9. mul-1-neg 90.4%

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

      10. remove-double-neg 90.4%

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

      11. +-commutative 90.4%

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

      12. distribute-neg-in 90.4%

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

      13. metadata-eval 90.4%

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

      14. sub-neg 90.4%

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

      15. *-commutative 90.4%

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

   6. Simplified 90.4%

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

   7. Taylor expanded in y around 0 72.2%

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

      1. associate-+r+ 72.2%

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

      2. +-commutative 72.2%

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

   9. Simplified 72.2%

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

4. Final simplification 76.6%

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

Alternative 21: 57.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.8 \cdot 10^{+74} \lor \neg \left(t \leq 1.45 \cdot 10^{+63}\right):\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{else}:\\ \;\;\;\;x - b \cdot \left(2 - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= t -2.8e+74) (not (<= t 1.45e+63)))
   (* t (- b a))
   (- x (* b (- 2.0 y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((t <= -2.8e+74) || !(t <= 1.45e+63)) {
		tmp = t * (b - a);
	} else {
		tmp = x - (b * (2.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 ((t <= (-2.8d+74)) .or. (.not. (t <= 1.45d+63))) then
        tmp = t * (b - a)
    else
        tmp = x - (b * (2.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 ((t <= -2.8e+74) || !(t <= 1.45e+63)) {
		tmp = t * (b - a);
	} else {
		tmp = x - (b * (2.0 - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (t <= -2.8e+74) or not (t <= 1.45e+63):
		tmp = t * (b - a)
	else:
		tmp = x - (b * (2.0 - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((t <= -2.8e+74) || !(t <= 1.45e+63))
		tmp = Float64(t * Float64(b - a));
	else
		tmp = Float64(x - Float64(b * Float64(2.0 - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((t <= -2.8e+74) || ~((t <= 1.45e+63)))
		tmp = t * (b - a);
	else
		tmp = x - (b * (2.0 - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -2.8e+74], N[Not[LessEqual[t, 1.45e+63]], $MachinePrecision]], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision], N[(x - N[(b * N[(2.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -2.80000000000000002e74 or 1.45e63 < t

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

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

   if -2.80000000000000002e74 < t < 1.45e63

   1. Initial program 97.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 z around 0 73.4%

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

   4. Taylor expanded in a around 0 57.3%

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

   5. Taylor expanded in t around 0 54.2%

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

4. Final simplification 59.0%

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

Alternative 22: 25.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -7 \cdot 10^{+102} \lor \neg \left(b \leq 1.85 \cdot 10^{-41}\right):\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -7e+102) (not (<= b 1.85e-41))) (* t b) x))

C

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

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (b <= -7e+102) or not (b <= 1.85e-41):
		tmp = t * b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((b <= -7e+102) || !(b <= 1.85e-41))
		tmp = Float64(t * b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((b <= -7e+102) || ~((b <= 1.85e-41)))
		tmp = t * b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -7e+102], N[Not[LessEqual[b, 1.85e-41]], $MachinePrecision]], N[(t * b), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if b < -7.00000000000000021e102 or 1.8500000000000001e-41 < b

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

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

   4. Taylor expanded in b around inf 32.7%

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

      1. *-commutative 32.7%

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

   6. Simplified 32.7%

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

   if -7.00000000000000021e102 < b < 1.8500000000000001e-41

   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 x around inf 27.8%

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

4. Final simplification 29.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -7 \cdot 10^{+102} \lor \neg \left(b \leq 1.85 \cdot 10^{-41}\right):\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 23: 21.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -1.6 \cdot 10^{+192}:\\ \;\;\;\;a\\ \mathbf{elif}\;a \leq 8.2 \cdot 10^{+154}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= a -1.6e+192) a (if (<= a 8.2e+154) x a)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (a <= -1.6e+192) {
		tmp = a;
	} else if (a <= 8.2e+154) {
		tmp = x;
	} else {
		tmp = 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 (a <= (-1.6d+192)) then
        tmp = a
    else if (a <= 8.2d+154) then
        tmp = x
    else
        tmp = 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 (a <= -1.6e+192) {
		tmp = a;
	} else if (a <= 8.2e+154) {
		tmp = x;
	} else {
		tmp = a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if a <= -1.6e+192:
		tmp = a
	elif a <= 8.2e+154:
		tmp = x
	else:
		tmp = a
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (a <= -1.6e+192)
		tmp = a;
	elseif (a <= 8.2e+154)
		tmp = x;
	else
		tmp = a;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (a <= -1.6e+192)
		tmp = a;
	elseif (a <= 8.2e+154)
		tmp = x;
	else
		tmp = a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -1.6e+192], a, If[LessEqual[a, 8.2e+154], x, a]]

Derivation

1. Split input into 2 regimes

2. if a < -1.60000000000000012e192 or 8.2e154 < a

   1. Initial program 96.1%

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

   3. Taylor expanded in a around inf 74.9%

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

   4. Taylor expanded in t around 0 38.1%

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

   if -1.60000000000000012e192 < a < 8.2e154

   1. Initial program 97.5%

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

   3. Taylor expanded in x around inf 24.4%

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

4. Final simplification 27.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.6 \cdot 10^{+192}:\\ \;\;\;\;a\\ \mathbf{elif}\;a \leq 8.2 \cdot 10^{+154}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;a\\ \end{array} \]
5. Add Preprocessing

Alternative 24: 18.6% accurate, 3.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.6 \cdot 10^{+88}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b) :precision binary64 (if (<= z -8.6e+88) z x))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -8.6e+88) {
		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 (z <= (-8.6d+88)) 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 (z <= -8.6e+88) {
		tmp = z;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -8.6e+88:
		tmp = z
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -8.6e+88)
		tmp = z;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -8.6e+88)
		tmp = z;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -8.6e+88], z, x]

Derivation

1. Split input into 2 regimes

2. if z < -8.59999999999999947e88

   1. Initial program 91.8%

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

   3. Taylor expanded in z around inf 54.3%

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

   4. Taylor expanded in y around 0 30.6%

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

   if -8.59999999999999947e88 < z

   1. Initial program 98.5%

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

   3. Taylor expanded in x around inf 24.6%

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

4. Final simplification 25.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -8.6 \cdot 10^{+88}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 25: 11.2% accurate, 21.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.2%

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

3. Taylor expanded in a around inf 26.7%

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

4. Taylor expanded in t around 0 10.1%

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

5. Final simplification 10.1%

   \[\leadsto a \]
6. Add Preprocessing

Reproduce

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