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

Percentage Accurate: 95.5% → 98.0%

Time: 18.5s

Alternatives: 20

Speedup: 0.5×

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

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   1. Initial program 100.0%

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

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

   1. Initial program 0.0%

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

   3. Taylor expanded in y around inf 87.5%

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

4. Final simplification 99.6%

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

Alternative 2: 97.6% accurate, 0.1× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 96.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. Step-by-step derivation

   1. +-commutative 96.9%

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

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

   9. sub-neg 98.0%

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

   10. metadata-eval 98.0%

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

   11. remove-double-neg 98.0%

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

   12. sub-neg 98.0%

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

   13. metadata-eval 98.0%

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

3. Simplified 98.0%

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

5. Final simplification 98.0%

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

Alternative 3: 38.2% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := y \cdot \left(-z\right)\\ t_3 := b \cdot \left(t - 2\right)\\ \mathbf{if}\;b \leq -11500000000000:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-131}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -2.5 \cdot 10^{-189}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -7 \cdot 10^{-286}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 4.5 \cdot 10^{-233}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;b \leq 2.6 \cdot 10^{-155}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.52 \cdot 10^{-137}:\\ \;\;\;\;x\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{+25}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))) (t_2 (* y (- z))) (t_3 (* b (- t 2.0))))
   (if (<= b -11500000000000.0)
     t_3
     (if (<= b -6.8e-131)
       t_1
       (if (<= b -2.5e-189)
         t_2
         (if (<= b -7e-286)
           t_1
           (if (<= b 4.5e-233)
             (+ x a)
             (if (<= b 2.6e-155)
               t_1
               (if (<= b 1.52e-137) x (if (<= b 3.4e+25) t_2 t_3))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = y * -z;
	double t_3 = b * (t - 2.0);
	double tmp;
	if (b <= -11500000000000.0) {
		tmp = t_3;
	} else if (b <= -6.8e-131) {
		tmp = t_1;
	} else if (b <= -2.5e-189) {
		tmp = t_2;
	} else if (b <= -7e-286) {
		tmp = t_1;
	} else if (b <= 4.5e-233) {
		tmp = x + a;
	} else if (b <= 2.6e-155) {
		tmp = t_1;
	} else if (b <= 1.52e-137) {
		tmp = x;
	} else if (b <= 3.4e+25) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = y * -z
    t_3 = b * (t - 2.0d0)
    if (b <= (-11500000000000.0d0)) then
        tmp = t_3
    else if (b <= (-6.8d-131)) then
        tmp = t_1
    else if (b <= (-2.5d-189)) then
        tmp = t_2
    else if (b <= (-7d-286)) then
        tmp = t_1
    else if (b <= 4.5d-233) then
        tmp = x + a
    else if (b <= 2.6d-155) then
        tmp = t_1
    else if (b <= 1.52d-137) then
        tmp = x
    else if (b <= 3.4d+25) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = y * -z;
	double t_3 = b * (t - 2.0);
	double tmp;
	if (b <= -11500000000000.0) {
		tmp = t_3;
	} else if (b <= -6.8e-131) {
		tmp = t_1;
	} else if (b <= -2.5e-189) {
		tmp = t_2;
	} else if (b <= -7e-286) {
		tmp = t_1;
	} else if (b <= 4.5e-233) {
		tmp = x + a;
	} else if (b <= 2.6e-155) {
		tmp = t_1;
	} else if (b <= 1.52e-137) {
		tmp = x;
	} else if (b <= 3.4e+25) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = y * -z
	t_3 = b * (t - 2.0)
	tmp = 0
	if b <= -11500000000000.0:
		tmp = t_3
	elif b <= -6.8e-131:
		tmp = t_1
	elif b <= -2.5e-189:
		tmp = t_2
	elif b <= -7e-286:
		tmp = t_1
	elif b <= 4.5e-233:
		tmp = x + a
	elif b <= 2.6e-155:
		tmp = t_1
	elif b <= 1.52e-137:
		tmp = x
	elif b <= 3.4e+25:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(y * Float64(-z))
	t_3 = Float64(b * Float64(t - 2.0))
	tmp = 0.0
	if (b <= -11500000000000.0)
		tmp = t_3;
	elseif (b <= -6.8e-131)
		tmp = t_1;
	elseif (b <= -2.5e-189)
		tmp = t_2;
	elseif (b <= -7e-286)
		tmp = t_1;
	elseif (b <= 4.5e-233)
		tmp = Float64(x + a);
	elseif (b <= 2.6e-155)
		tmp = t_1;
	elseif (b <= 1.52e-137)
		tmp = x;
	elseif (b <= 3.4e+25)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	t_2 = y * -z;
	t_3 = b * (t - 2.0);
	tmp = 0.0;
	if (b <= -11500000000000.0)
		tmp = t_3;
	elseif (b <= -6.8e-131)
		tmp = t_1;
	elseif (b <= -2.5e-189)
		tmp = t_2;
	elseif (b <= -7e-286)
		tmp = t_1;
	elseif (b <= 4.5e-233)
		tmp = x + a;
	elseif (b <= 2.6e-155)
		tmp = t_1;
	elseif (b <= 1.52e-137)
		tmp = x;
	elseif (b <= 3.4e+25)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * (-z)), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -11500000000000.0], t$95$3, If[LessEqual[b, -6.8e-131], t$95$1, If[LessEqual[b, -2.5e-189], t$95$2, If[LessEqual[b, -7e-286], t$95$1, If[LessEqual[b, 4.5e-233], N[(x + a), $MachinePrecision], If[LessEqual[b, 2.6e-155], t$95$1, If[LessEqual[b, 1.52e-137], x, If[LessEqual[b, 3.4e+25], t$95$2, t$95$3]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -1.15e13 or 3.39999999999999984e25 < b

   1. Initial program 94.6%

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

   3. Taylor expanded in b around inf 78.1%

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

   4. Taylor expanded in y around 0 53.1%

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

   if -1.15e13 < b < -6.7999999999999999e-131 or -2.4999999999999999e-189 < b < -6.99999999999999977e-286 or 4.5000000000000002e-233 < b < 2.60000000000000008e-155

   1. Initial program 99.9%

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

   3. Taylor expanded in a around inf 51.1%

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

   if -6.7999999999999999e-131 < b < -2.4999999999999999e-189 or 1.5200000000000001e-137 < b < 3.39999999999999984e25

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

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

   4. Taylor expanded in b around 0 46.9%

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

      1. mul-1-neg 46.9%

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

      2. distribute-rgt-neg-in 46.9%

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

   6. Simplified 46.9%

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

   if -6.99999999999999977e-286 < b < 4.5000000000000002e-233

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 100.0%

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

   4. Taylor expanded in a around inf 70.2%

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

   5. Taylor expanded in t around 0 61.7%

      \[\leadsto \color{blue}{x - -1 \cdot a} \]
   6. Step-by-step derivation

      1. cancel-sign-sub-inv 61.7%

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

      2. metadata-eval 61.7%

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

      3. *-lft-identity 61.7%

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

      4. +-commutative 61.7%

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

   7. Simplified 61.7%

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

   if 2.60000000000000008e-155 < b < 1.5200000000000001e-137

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

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

4. Final simplification 52.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -11500000000000:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{elif}\;b \leq -6.8 \cdot 10^{-131}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq -2.5 \cdot 10^{-189}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;b \leq -7 \cdot 10^{-286}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 4.5 \cdot 10^{-233}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;b \leq 2.6 \cdot 10^{-155}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 1.52 \cdot 10^{-137}:\\ \;\;\;\;x\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{+25}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 54.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ t_2 := x - t \cdot a\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -3.9 \cdot 10^{+89}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -5.1 \cdot 10^{+76}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.05 \cdot 10^{+14}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -2.8 \cdot 10^{-117}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -4.5 \cdot 10^{-218}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.78 \cdot 10^{-134}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 5.8 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y))) (t_2 (- x (* t a))) (t_3 (* b (- (+ y t) 2.0))))
   (if (<= b -3.9e+89)
     t_3
     (if (<= b -5.1e+76)
       t_2
       (if (<= b -1.05e+14)
         t_3
         (if (<= b -2.8e-117)
           t_2
           (if (<= b -4.5e-218)
             t_1
             (if (<= b 1.78e-134) t_2 (if (<= b 5.8e+23) t_1 t_3)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x - (t * a);
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -3.9e+89) {
		tmp = t_3;
	} else if (b <= -5.1e+76) {
		tmp = t_2;
	} else if (b <= -1.05e+14) {
		tmp = t_3;
	} else if (b <= -2.8e-117) {
		tmp = t_2;
	} else if (b <= -4.5e-218) {
		tmp = t_1;
	} else if (b <= 1.78e-134) {
		tmp = t_2;
	} else if (b <= 5.8e+23) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = z * (1.0d0 - y)
    t_2 = x - (t * a)
    t_3 = b * ((y + t) - 2.0d0)
    if (b <= (-3.9d+89)) then
        tmp = t_3
    else if (b <= (-5.1d+76)) then
        tmp = t_2
    else if (b <= (-1.05d+14)) then
        tmp = t_3
    else if (b <= (-2.8d-117)) then
        tmp = t_2
    else if (b <= (-4.5d-218)) then
        tmp = t_1
    else if (b <= 1.78d-134) then
        tmp = t_2
    else if (b <= 5.8d+23) then
        tmp = t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x - (t * a);
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -3.9e+89) {
		tmp = t_3;
	} else if (b <= -5.1e+76) {
		tmp = t_2;
	} else if (b <= -1.05e+14) {
		tmp = t_3;
	} else if (b <= -2.8e-117) {
		tmp = t_2;
	} else if (b <= -4.5e-218) {
		tmp = t_1;
	} else if (b <= 1.78e-134) {
		tmp = t_2;
	} else if (b <= 5.8e+23) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	t_2 = x - (t * a)
	t_3 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -3.9e+89:
		tmp = t_3
	elif b <= -5.1e+76:
		tmp = t_2
	elif b <= -1.05e+14:
		tmp = t_3
	elif b <= -2.8e-117:
		tmp = t_2
	elif b <= -4.5e-218:
		tmp = t_1
	elif b <= 1.78e-134:
		tmp = t_2
	elif b <= 5.8e+23:
		tmp = t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	t_2 = Float64(x - Float64(t * a))
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -3.9e+89)
		tmp = t_3;
	elseif (b <= -5.1e+76)
		tmp = t_2;
	elseif (b <= -1.05e+14)
		tmp = t_3;
	elseif (b <= -2.8e-117)
		tmp = t_2;
	elseif (b <= -4.5e-218)
		tmp = t_1;
	elseif (b <= 1.78e-134)
		tmp = t_2;
	elseif (b <= 5.8e+23)
		tmp = t_1;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (1.0 - y);
	t_2 = x - (t * a);
	t_3 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -3.9e+89)
		tmp = t_3;
	elseif (b <= -5.1e+76)
		tmp = t_2;
	elseif (b <= -1.05e+14)
		tmp = t_3;
	elseif (b <= -2.8e-117)
		tmp = t_2;
	elseif (b <= -4.5e-218)
		tmp = t_1;
	elseif (b <= 1.78e-134)
		tmp = t_2;
	elseif (b <= 5.8e+23)
		tmp = t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.9e+89], t$95$3, If[LessEqual[b, -5.1e+76], t$95$2, If[LessEqual[b, -1.05e+14], t$95$3, If[LessEqual[b, -2.8e-117], t$95$2, If[LessEqual[b, -4.5e-218], t$95$1, If[LessEqual[b, 1.78e-134], t$95$2, If[LessEqual[b, 5.8e+23], t$95$1, t$95$3]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -3.90000000000000011e89 or -5.1000000000000002e76 < b < -1.05e14 or 5.80000000000000025e23 < b

   1. Initial program 94.3%

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

   3. Taylor expanded in b around inf 80.8%

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

   if -3.90000000000000011e89 < b < -5.1000000000000002e76 or -1.05e14 < b < -2.8e-117 or -4.49999999999999977e-218 < b < 1.7800000000000001e-134

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 95.9%

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

   4. Taylor expanded in t around inf 57.5%

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

      1. *-commutative 57.5%

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

   6. Simplified 57.5%

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

   if -2.8e-117 < b < -4.49999999999999977e-218 or 1.7800000000000001e-134 < b < 5.80000000000000025e23

   1. Initial program 98.0%

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

   3. Taylor expanded in z around inf 61.6%

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

4. Final simplification 69.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -3.9 \cdot 10^{+89}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -5.1 \cdot 10^{+76}:\\ \;\;\;\;x - t \cdot a\\ \mathbf{elif}\;b \leq -1.05 \cdot 10^{+14}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -2.8 \cdot 10^{-117}:\\ \;\;\;\;x - t \cdot a\\ \mathbf{elif}\;b \leq -4.5 \cdot 10^{-218}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 1.78 \cdot 10^{-134}:\\ \;\;\;\;x - t \cdot a\\ \mathbf{elif}\;b \leq 5.8 \cdot 10^{+23}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 59.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ t_2 := x - a \cdot \left(t + -1\right)\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -1.45 \cdot 10^{+90}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -4.4 \cdot 10^{+73}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -7.5 \cdot 10^{+14}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -1.35 \cdot 10^{-117}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -4 \cdot 10^{-189}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 4.1 \cdot 10^{-134}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 3 \cdot 10^{+24}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y)))
        (t_2 (- x (* a (+ t -1.0))))
        (t_3 (* b (- (+ y t) 2.0))))
   (if (<= b -1.45e+90)
     t_3
     (if (<= b -4.4e+73)
       t_2
       (if (<= b -7.5e+14)
         t_3
         (if (<= b -1.35e-117)
           t_2
           (if (<= b -4e-189)
             t_1
             (if (<= b 4.1e-134) t_2 (if (<= b 3e+24) t_1 t_3)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x - (a * (t + -1.0));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1.45e+90) {
		tmp = t_3;
	} else if (b <= -4.4e+73) {
		tmp = t_2;
	} else if (b <= -7.5e+14) {
		tmp = t_3;
	} else if (b <= -1.35e-117) {
		tmp = t_2;
	} else if (b <= -4e-189) {
		tmp = t_1;
	} else if (b <= 4.1e-134) {
		tmp = t_2;
	} else if (b <= 3e+24) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = z * (1.0d0 - y)
    t_2 = x - (a * (t + (-1.0d0)))
    t_3 = b * ((y + t) - 2.0d0)
    if (b <= (-1.45d+90)) then
        tmp = t_3
    else if (b <= (-4.4d+73)) then
        tmp = t_2
    else if (b <= (-7.5d+14)) then
        tmp = t_3
    else if (b <= (-1.35d-117)) then
        tmp = t_2
    else if (b <= (-4d-189)) then
        tmp = t_1
    else if (b <= 4.1d-134) then
        tmp = t_2
    else if (b <= 3d+24) then
        tmp = t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x - (a * (t + -1.0));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -1.45e+90) {
		tmp = t_3;
	} else if (b <= -4.4e+73) {
		tmp = t_2;
	} else if (b <= -7.5e+14) {
		tmp = t_3;
	} else if (b <= -1.35e-117) {
		tmp = t_2;
	} else if (b <= -4e-189) {
		tmp = t_1;
	} else if (b <= 4.1e-134) {
		tmp = t_2;
	} else if (b <= 3e+24) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	t_2 = x - (a * (t + -1.0))
	t_3 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -1.45e+90:
		tmp = t_3
	elif b <= -4.4e+73:
		tmp = t_2
	elif b <= -7.5e+14:
		tmp = t_3
	elif b <= -1.35e-117:
		tmp = t_2
	elif b <= -4e-189:
		tmp = t_1
	elif b <= 4.1e-134:
		tmp = t_2
	elif b <= 3e+24:
		tmp = t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	t_2 = Float64(x - Float64(a * Float64(t + -1.0)))
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -1.45e+90)
		tmp = t_3;
	elseif (b <= -4.4e+73)
		tmp = t_2;
	elseif (b <= -7.5e+14)
		tmp = t_3;
	elseif (b <= -1.35e-117)
		tmp = t_2;
	elseif (b <= -4e-189)
		tmp = t_1;
	elseif (b <= 4.1e-134)
		tmp = t_2;
	elseif (b <= 3e+24)
		tmp = t_1;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (1.0 - y);
	t_2 = x - (a * (t + -1.0));
	t_3 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -1.45e+90)
		tmp = t_3;
	elseif (b <= -4.4e+73)
		tmp = t_2;
	elseif (b <= -7.5e+14)
		tmp = t_3;
	elseif (b <= -1.35e-117)
		tmp = t_2;
	elseif (b <= -4e-189)
		tmp = t_1;
	elseif (b <= 4.1e-134)
		tmp = t_2;
	elseif (b <= 3e+24)
		tmp = t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.45e+90], t$95$3, If[LessEqual[b, -4.4e+73], t$95$2, If[LessEqual[b, -7.5e+14], t$95$3, If[LessEqual[b, -1.35e-117], t$95$2, If[LessEqual[b, -4e-189], t$95$1, If[LessEqual[b, 4.1e-134], t$95$2, If[LessEqual[b, 3e+24], t$95$1, t$95$3]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.4500000000000001e90 or -4.4e73 < b < -7.5e14 or 2.99999999999999995e24 < b

   1. Initial program 94.3%

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

   3. Taylor expanded in b around inf 81.5%

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

   if -1.4500000000000001e90 < b < -4.4e73 or -7.5e14 < b < -1.35000000000000001e-117 or -4.00000000000000027e-189 < b < 4.1000000000000002e-134

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 96.0%

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

   4. Taylor expanded in a around inf 72.3%

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

   if -1.35000000000000001e-117 < b < -4.00000000000000027e-189 or 4.1000000000000002e-134 < b < 2.99999999999999995e24

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

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

4. Final simplification 74.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.45 \cdot 10^{+90}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -4.4 \cdot 10^{+73}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq -7.5 \cdot 10^{+14}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -1.35 \cdot 10^{-117}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq -4 \cdot 10^{-189}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 4.1 \cdot 10^{-134}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 3 \cdot 10^{+24}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 62.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + z \cdot \left(1 - y\right)\\ t_2 := x - a \cdot \left(t + -1\right)\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -2.4 \cdot 10^{+89}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -4 \cdot 10^{+73}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -510000000000:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -6.3 \cdot 10^{-80}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -2.3 \cdot 10^{-189}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.6 \cdot 10^{-155}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 8.6 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* z (- 1.0 y))))
        (t_2 (- x (* a (+ t -1.0))))
        (t_3 (* b (- (+ y t) 2.0))))
   (if (<= b -2.4e+89)
     t_3
     (if (<= b -4e+73)
       t_2
       (if (<= b -510000000000.0)
         t_3
         (if (<= b -6.3e-80)
           t_2
           (if (<= b -2.3e-189)
             t_1
             (if (<= b 1.6e-155) t_2 (if (<= b 8.6e+23) t_1 t_3)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (z * (1.0 - y));
	double t_2 = x - (a * (t + -1.0));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -2.4e+89) {
		tmp = t_3;
	} else if (b <= -4e+73) {
		tmp = t_2;
	} else if (b <= -510000000000.0) {
		tmp = t_3;
	} else if (b <= -6.3e-80) {
		tmp = t_2;
	} else if (b <= -2.3e-189) {
		tmp = t_1;
	} else if (b <= 1.6e-155) {
		tmp = t_2;
	} else if (b <= 8.6e+23) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = x + (z * (1.0d0 - y))
    t_2 = x - (a * (t + (-1.0d0)))
    t_3 = b * ((y + t) - 2.0d0)
    if (b <= (-2.4d+89)) then
        tmp = t_3
    else if (b <= (-4d+73)) then
        tmp = t_2
    else if (b <= (-510000000000.0d0)) then
        tmp = t_3
    else if (b <= (-6.3d-80)) then
        tmp = t_2
    else if (b <= (-2.3d-189)) then
        tmp = t_1
    else if (b <= 1.6d-155) then
        tmp = t_2
    else if (b <= 8.6d+23) then
        tmp = t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (z * (1.0 - y));
	double t_2 = x - (a * (t + -1.0));
	double t_3 = b * ((y + t) - 2.0);
	double tmp;
	if (b <= -2.4e+89) {
		tmp = t_3;
	} else if (b <= -4e+73) {
		tmp = t_2;
	} else if (b <= -510000000000.0) {
		tmp = t_3;
	} else if (b <= -6.3e-80) {
		tmp = t_2;
	} else if (b <= -2.3e-189) {
		tmp = t_1;
	} else if (b <= 1.6e-155) {
		tmp = t_2;
	} else if (b <= 8.6e+23) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (z * (1.0 - y))
	t_2 = x - (a * (t + -1.0))
	t_3 = b * ((y + t) - 2.0)
	tmp = 0
	if b <= -2.4e+89:
		tmp = t_3
	elif b <= -4e+73:
		tmp = t_2
	elif b <= -510000000000.0:
		tmp = t_3
	elif b <= -6.3e-80:
		tmp = t_2
	elif b <= -2.3e-189:
		tmp = t_1
	elif b <= 1.6e-155:
		tmp = t_2
	elif b <= 8.6e+23:
		tmp = t_1
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(z * Float64(1.0 - y)))
	t_2 = Float64(x - Float64(a * Float64(t + -1.0)))
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	tmp = 0.0
	if (b <= -2.4e+89)
		tmp = t_3;
	elseif (b <= -4e+73)
		tmp = t_2;
	elseif (b <= -510000000000.0)
		tmp = t_3;
	elseif (b <= -6.3e-80)
		tmp = t_2;
	elseif (b <= -2.3e-189)
		tmp = t_1;
	elseif (b <= 1.6e-155)
		tmp = t_2;
	elseif (b <= 8.6e+23)
		tmp = t_1;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (z * (1.0 - y));
	t_2 = x - (a * (t + -1.0));
	t_3 = b * ((y + t) - 2.0);
	tmp = 0.0;
	if (b <= -2.4e+89)
		tmp = t_3;
	elseif (b <= -4e+73)
		tmp = t_2;
	elseif (b <= -510000000000.0)
		tmp = t_3;
	elseif (b <= -6.3e-80)
		tmp = t_2;
	elseif (b <= -2.3e-189)
		tmp = t_1;
	elseif (b <= 1.6e-155)
		tmp = t_2;
	elseif (b <= 8.6e+23)
		tmp = t_1;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.4e+89], t$95$3, If[LessEqual[b, -4e+73], t$95$2, If[LessEqual[b, -510000000000.0], t$95$3, If[LessEqual[b, -6.3e-80], t$95$2, If[LessEqual[b, -2.3e-189], t$95$1, If[LessEqual[b, 1.6e-155], t$95$2, If[LessEqual[b, 8.6e+23], t$95$1, t$95$3]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -2.40000000000000004e89 or -3.99999999999999993e73 < b < -5.1e11 or 8.5999999999999997e23 < b

   1. Initial program 94.3%

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

   3. Taylor expanded in b around inf 81.5%

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

   if -2.40000000000000004e89 < b < -3.99999999999999993e73 or -5.1e11 < b < -6.29999999999999966e-80 or -2.2999999999999998e-189 < b < 1.60000000000000006e-155

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 95.6%

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

   4. Taylor expanded in a around inf 74.2%

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

   if -6.29999999999999966e-80 < b < -2.2999999999999998e-189 or 1.60000000000000006e-155 < b < 8.5999999999999997e23

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 92.2%

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

   4. Taylor expanded in a around 0 74.3%

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

4. Final simplification 77.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2.4 \cdot 10^{+89}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -4 \cdot 10^{+73}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq -510000000000:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -6.3 \cdot 10^{-80}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq -2.3 \cdot 10^{-189}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 1.6 \cdot 10^{-155}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 8.6 \cdot 10^{+23}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 35.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(-a\right)\\ \mathbf{if}\;t \leq -5.5 \cdot 10^{+198}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -9 \cdot 10^{+138}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -4.2 \cdot 10^{+27}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;t \leq 3.4 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 4.4 \cdot 10^{+31}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 5.8 \cdot 10^{+173}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- a))))
   (if (<= t -5.5e+198)
     (* t b)
     (if (<= t -9e+138)
       t_1
       (if (<= t -4.2e+27)
         (* y (- z))
         (if (<= t 3.4e-18)
           (+ x a)
           (if (<= t 4.4e+31) (* y b) (if (<= t 5.8e+173) (* t b) t_1))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * -a;
	double tmp;
	if (t <= -5.5e+198) {
		tmp = t * b;
	} else if (t <= -9e+138) {
		tmp = t_1;
	} else if (t <= -4.2e+27) {
		tmp = y * -z;
	} else if (t <= 3.4e-18) {
		tmp = x + a;
	} else if (t <= 4.4e+31) {
		tmp = y * b;
	} else if (t <= 5.8e+173) {
		tmp = t * b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = t * -a
    if (t <= (-5.5d+198)) then
        tmp = t * b
    else if (t <= (-9d+138)) then
        tmp = t_1
    else if (t <= (-4.2d+27)) then
        tmp = y * -z
    else if (t <= 3.4d-18) then
        tmp = x + a
    else if (t <= 4.4d+31) then
        tmp = y * b
    else if (t <= 5.8d+173) then
        tmp = t * b
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * -a;
	double tmp;
	if (t <= -5.5e+198) {
		tmp = t * b;
	} else if (t <= -9e+138) {
		tmp = t_1;
	} else if (t <= -4.2e+27) {
		tmp = y * -z;
	} else if (t <= 3.4e-18) {
		tmp = x + a;
	} else if (t <= 4.4e+31) {
		tmp = y * b;
	} else if (t <= 5.8e+173) {
		tmp = t * b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * -a
	tmp = 0
	if t <= -5.5e+198:
		tmp = t * b
	elif t <= -9e+138:
		tmp = t_1
	elif t <= -4.2e+27:
		tmp = y * -z
	elif t <= 3.4e-18:
		tmp = x + a
	elif t <= 4.4e+31:
		tmp = y * b
	elif t <= 5.8e+173:
		tmp = t * b
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(-a))
	tmp = 0.0
	if (t <= -5.5e+198)
		tmp = Float64(t * b);
	elseif (t <= -9e+138)
		tmp = t_1;
	elseif (t <= -4.2e+27)
		tmp = Float64(y * Float64(-z));
	elseif (t <= 3.4e-18)
		tmp = Float64(x + a);
	elseif (t <= 4.4e+31)
		tmp = Float64(y * b);
	elseif (t <= 5.8e+173)
		tmp = Float64(t * b);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * -a;
	tmp = 0.0;
	if (t <= -5.5e+198)
		tmp = t * b;
	elseif (t <= -9e+138)
		tmp = t_1;
	elseif (t <= -4.2e+27)
		tmp = y * -z;
	elseif (t <= 3.4e-18)
		tmp = x + a;
	elseif (t <= 4.4e+31)
		tmp = y * b;
	elseif (t <= 5.8e+173)
		tmp = t * b;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * (-a)), $MachinePrecision]}, If[LessEqual[t, -5.5e+198], N[(t * b), $MachinePrecision], If[LessEqual[t, -9e+138], t$95$1, If[LessEqual[t, -4.2e+27], N[(y * (-z)), $MachinePrecision], If[LessEqual[t, 3.4e-18], N[(x + a), $MachinePrecision], If[LessEqual[t, 4.4e+31], N[(y * b), $MachinePrecision], If[LessEqual[t, 5.8e+173], N[(t * b), $MachinePrecision], t$95$1]]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -5.5000000000000004e198 or 4.4000000000000002e31 < t < 5.80000000000000014e173

   1. Initial program 92.7%

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

   3. Taylor expanded in b around inf 61.5%

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

   4. Taylor expanded in t around inf 56.0%

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

   if -5.5000000000000004e198 < t < -8.99999999999999963e138 or 5.80000000000000014e173 < t

   1. Initial program 100.0%

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

   3. Taylor expanded in a around inf 57.5%

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

   4. Taylor expanded in t around 0 57.5%

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

   5. Taylor expanded in t around inf 57.5%

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

      1. associate-*r* 57.5%

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

      2. neg-mul-1 57.5%

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

   7. Simplified 57.5%

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

   if -8.99999999999999963e138 < t < -4.19999999999999989e27

   1. Initial program 100.0%

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

   3. Taylor expanded in y around inf 49.5%

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

   4. Taylor expanded in b around 0 37.1%

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

      1. mul-1-neg 37.1%

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

      2. distribute-rgt-neg-in 37.1%

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

   6. Simplified 37.1%

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

   if -4.19999999999999989e27 < t < 3.40000000000000001e-18

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

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

   4. Taylor expanded in a around inf 41.0%

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

   5. Taylor expanded in t around 0 40.6%

      \[\leadsto \color{blue}{x - -1 \cdot a} \]
   6. Step-by-step derivation

      1. cancel-sign-sub-inv 40.6%

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

      2. metadata-eval 40.6%

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

      3. *-lft-identity 40.6%

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

      4. +-commutative 40.6%

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

   7. Simplified 40.6%

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

   if 3.40000000000000001e-18 < t < 4.4000000000000002e31

   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 0 70.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 y around inf 44.0%

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

4. Final simplification 46.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -5.5 \cdot 10^{+198}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -9 \cdot 10^{+138}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;t \leq -4.2 \cdot 10^{+27}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;t \leq 3.4 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 4.4 \cdot 10^{+31}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 5.8 \cdot 10^{+173}:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 66.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - a \cdot \left(t + -1\right)\\ t_2 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_3 := x + z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -3.9 \cdot 10^{+14}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -5.2 \cdot 10^{-81}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -2.6 \cdot 10^{-189}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-155}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.4 \cdot 10^{+24}:\\ \;\;\;\;t_3\\ \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 (+ x (* b (- (+ y t) 2.0))))
        (t_3 (+ x (* z (- 1.0 y)))))
   (if (<= b -3.9e+14)
     t_2
     (if (<= b -5.2e-81)
       t_1
       (if (<= b -2.6e-189)
         t_3
         (if (<= b 2e-155) t_1 (if (<= b 1.4e+24) t_3 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 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -3.9e+14) {
		tmp = t_2;
	} else if (b <= -5.2e-81) {
		tmp = t_1;
	} else if (b <= -2.6e-189) {
		tmp = t_3;
	} else if (b <= 2e-155) {
		tmp = t_1;
	} else if (b <= 1.4e+24) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = x - (a * (t + (-1.0d0)))
    t_2 = x + (b * ((y + t) - 2.0d0))
    t_3 = x + (z * (1.0d0 - y))
    if (b <= (-3.9d+14)) then
        tmp = t_2
    else if (b <= (-5.2d-81)) then
        tmp = t_1
    else if (b <= (-2.6d-189)) then
        tmp = t_3
    else if (b <= 2d-155) then
        tmp = t_1
    else if (b <= 1.4d+24) then
        tmp = t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (a * (t + -1.0));
	double t_2 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -3.9e+14) {
		tmp = t_2;
	} else if (b <= -5.2e-81) {
		tmp = t_1;
	} else if (b <= -2.6e-189) {
		tmp = t_3;
	} else if (b <= 2e-155) {
		tmp = t_1;
	} else if (b <= 1.4e+24) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x - (a * (t + -1.0))
	t_2 = x + (b * ((y + t) - 2.0))
	t_3 = x + (z * (1.0 - y))
	tmp = 0
	if b <= -3.9e+14:
		tmp = t_2
	elif b <= -5.2e-81:
		tmp = t_1
	elif b <= -2.6e-189:
		tmp = t_3
	elif b <= 2e-155:
		tmp = t_1
	elif b <= 1.4e+24:
		tmp = t_3
	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(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	t_3 = Float64(x + Float64(z * Float64(1.0 - y)))
	tmp = 0.0
	if (b <= -3.9e+14)
		tmp = t_2;
	elseif (b <= -5.2e-81)
		tmp = t_1;
	elseif (b <= -2.6e-189)
		tmp = t_3;
	elseif (b <= 2e-155)
		tmp = t_1;
	elseif (b <= 1.4e+24)
		tmp = t_3;
	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 = x + (b * ((y + t) - 2.0));
	t_3 = x + (z * (1.0 - y));
	tmp = 0.0;
	if (b <= -3.9e+14)
		tmp = t_2;
	elseif (b <= -5.2e-81)
		tmp = t_1;
	elseif (b <= -2.6e-189)
		tmp = t_3;
	elseif (b <= 2e-155)
		tmp = t_1;
	elseif (b <= 1.4e+24)
		tmp = t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.9e+14], t$95$2, If[LessEqual[b, -5.2e-81], t$95$1, If[LessEqual[b, -2.6e-189], t$95$3, If[LessEqual[b, 2e-155], t$95$1, If[LessEqual[b, 1.4e+24], t$95$3, t$95$2]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -3.9e14 or 1.4000000000000001e24 < b

   1. Initial program 94.6%

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

   3. Taylor expanded in a around 0 87.7%

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

   4. Taylor expanded in z around 0 84.9%

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

   if -3.9e14 < b < -5.1999999999999998e-81 or -2.5999999999999999e-189 < b < 2.00000000000000003e-155

   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 b around 0 95.2%

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

   4. Taylor expanded in a around inf 71.4%

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

   if -5.1999999999999998e-81 < b < -2.5999999999999999e-189 or 2.00000000000000003e-155 < b < 1.4000000000000001e24

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 92.2%

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

   4. Taylor expanded in a around 0 74.3%

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

4. Final simplification 78.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -3.9 \cdot 10^{+14}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{elif}\;b \leq -5.2 \cdot 10^{-81}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq -2.6 \cdot 10^{-189}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-155}:\\ \;\;\;\;x - a \cdot \left(t + -1\right)\\ \mathbf{elif}\;b \leq 1.4 \cdot 10^{+24}:\\ \;\;\;\;x + z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + b \cdot \left(\left(y + t\right) - 2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 66.5% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x + t \cdot b\right) - a \cdot \left(t + -1\right)\\ t_2 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_3 := x + z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -3 \cdot 10^{+102}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.55 \cdot 10^{-83}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -3 \cdot 10^{-189}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-155}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 5 \cdot 10^{+24}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- (+ x (* t b)) (* a (+ t -1.0))))
        (t_2 (+ x (* b (- (+ y t) 2.0))))
        (t_3 (+ x (* z (- 1.0 y)))))
   (if (<= b -3e+102)
     t_2
     (if (<= b -1.55e-83)
       t_1
       (if (<= b -3e-189)
         t_3
         (if (<= b 2e-155) t_1 (if (<= b 5e+24) t_3 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x + (t * b)) - (a * (t + -1.0));
	double t_2 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -3e+102) {
		tmp = t_2;
	} else if (b <= -1.55e-83) {
		tmp = t_1;
	} else if (b <= -3e-189) {
		tmp = t_3;
	} else if (b <= 2e-155) {
		tmp = t_1;
	} else if (b <= 5e+24) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = (x + (t * b)) - (a * (t + (-1.0d0)))
    t_2 = x + (b * ((y + t) - 2.0d0))
    t_3 = x + (z * (1.0d0 - y))
    if (b <= (-3d+102)) then
        tmp = t_2
    else if (b <= (-1.55d-83)) then
        tmp = t_1
    else if (b <= (-3d-189)) then
        tmp = t_3
    else if (b <= 2d-155) then
        tmp = t_1
    else if (b <= 5d+24) then
        tmp = t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (x + (t * b)) - (a * (t + -1.0));
	double t_2 = x + (b * ((y + t) - 2.0));
	double t_3 = x + (z * (1.0 - y));
	double tmp;
	if (b <= -3e+102) {
		tmp = t_2;
	} else if (b <= -1.55e-83) {
		tmp = t_1;
	} else if (b <= -3e-189) {
		tmp = t_3;
	} else if (b <= 2e-155) {
		tmp = t_1;
	} else if (b <= 5e+24) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (x + (t * b)) - (a * (t + -1.0))
	t_2 = x + (b * ((y + t) - 2.0))
	t_3 = x + (z * (1.0 - y))
	tmp = 0
	if b <= -3e+102:
		tmp = t_2
	elif b <= -1.55e-83:
		tmp = t_1
	elif b <= -3e-189:
		tmp = t_3
	elif b <= 2e-155:
		tmp = t_1
	elif b <= 5e+24:
		tmp = t_3
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(x + Float64(t * b)) - Float64(a * Float64(t + -1.0)))
	t_2 = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	t_3 = Float64(x + Float64(z * Float64(1.0 - y)))
	tmp = 0.0
	if (b <= -3e+102)
		tmp = t_2;
	elseif (b <= -1.55e-83)
		tmp = t_1;
	elseif (b <= -3e-189)
		tmp = t_3;
	elseif (b <= 2e-155)
		tmp = t_1;
	elseif (b <= 5e+24)
		tmp = t_3;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (x + (t * b)) - (a * (t + -1.0));
	t_2 = x + (b * ((y + t) - 2.0));
	t_3 = x + (z * (1.0 - y));
	tmp = 0.0;
	if (b <= -3e+102)
		tmp = t_2;
	elseif (b <= -1.55e-83)
		tmp = t_1;
	elseif (b <= -3e-189)
		tmp = t_3;
	elseif (b <= 2e-155)
		tmp = t_1;
	elseif (b <= 5e+24)
		tmp = t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(t * b), $MachinePrecision]), $MachinePrecision] - N[(a * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3e+102], t$95$2, If[LessEqual[b, -1.55e-83], t$95$1, If[LessEqual[b, -3e-189], t$95$3, If[LessEqual[b, 2e-155], t$95$1, If[LessEqual[b, 5e+24], t$95$3, t$95$2]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -2.9999999999999998e102 or 5.00000000000000045e24 < b

   1. Initial program 93.8%

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

   3. Taylor expanded in a around 0 89.3%

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

   4. Taylor expanded in z around 0 86.8%

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

   if -2.9999999999999998e102 < b < -1.54999999999999996e-83 or -3e-189 < b < 2.00000000000000003e-155

   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 80.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 t around inf 76.4%

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

   if -1.54999999999999996e-83 < b < -3e-189 or 2.00000000000000003e-155 < b < 5.00000000000000045e24

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 92.2%

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

   4. Taylor expanded in a around 0 74.3%

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

4. Final simplification 80.5%

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

Alternative 10: 27.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.3 \cdot 10^{+67}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -4.2 \cdot 10^{-103}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq -6.8 \cdot 10^{-156}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq -4.6 \cdot 10^{-241}:\\ \;\;\;\;a\\ \mathbf{elif}\;t \leq -1.2 \cdot 10^{-263}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 3.25 \cdot 10^{+31}:\\ \;\;\;\;y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -2.3e+67)
   (* t b)
   (if (<= t -4.2e-103)
     (* y b)
     (if (<= t -6.8e-156)
       z
       (if (<= t -4.6e-241)
         a
         (if (<= t -1.2e-263) x (if (<= t 3.25e+31) (* y b) (* t b))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.3e+67) {
		tmp = t * b;
	} else if (t <= -4.2e-103) {
		tmp = y * b;
	} else if (t <= -6.8e-156) {
		tmp = z;
	} else if (t <= -4.6e-241) {
		tmp = a;
	} else if (t <= -1.2e-263) {
		tmp = x;
	} else if (t <= 3.25e+31) {
		tmp = y * b;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-2.3d+67)) then
        tmp = t * b
    else if (t <= (-4.2d-103)) then
        tmp = y * b
    else if (t <= (-6.8d-156)) then
        tmp = z
    else if (t <= (-4.6d-241)) then
        tmp = a
    else if (t <= (-1.2d-263)) then
        tmp = x
    else if (t <= 3.25d+31) then
        tmp = y * b
    else
        tmp = t * b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.3e+67) {
		tmp = t * b;
	} else if (t <= -4.2e-103) {
		tmp = y * b;
	} else if (t <= -6.8e-156) {
		tmp = z;
	} else if (t <= -4.6e-241) {
		tmp = a;
	} else if (t <= -1.2e-263) {
		tmp = x;
	} else if (t <= 3.25e+31) {
		tmp = y * b;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -2.3e+67:
		tmp = t * b
	elif t <= -4.2e-103:
		tmp = y * b
	elif t <= -6.8e-156:
		tmp = z
	elif t <= -4.6e-241:
		tmp = a
	elif t <= -1.2e-263:
		tmp = x
	elif t <= 3.25e+31:
		tmp = y * b
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -2.3e+67)
		tmp = Float64(t * b);
	elseif (t <= -4.2e-103)
		tmp = Float64(y * b);
	elseif (t <= -6.8e-156)
		tmp = z;
	elseif (t <= -4.6e-241)
		tmp = a;
	elseif (t <= -1.2e-263)
		tmp = x;
	elseif (t <= 3.25e+31)
		tmp = Float64(y * b);
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -2.3e+67)
		tmp = t * b;
	elseif (t <= -4.2e-103)
		tmp = y * b;
	elseif (t <= -6.8e-156)
		tmp = z;
	elseif (t <= -4.6e-241)
		tmp = a;
	elseif (t <= -1.2e-263)
		tmp = x;
	elseif (t <= 3.25e+31)
		tmp = y * b;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.3e+67], N[(t * b), $MachinePrecision], If[LessEqual[t, -4.2e-103], N[(y * b), $MachinePrecision], If[LessEqual[t, -6.8e-156], z, If[LessEqual[t, -4.6e-241], a, If[LessEqual[t, -1.2e-263], x, If[LessEqual[t, 3.25e+31], N[(y * b), $MachinePrecision], N[(t * b), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -2.2999999999999999e67 or 3.2500000000000002e31 < t

   1. Initial program 96.3%

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

   3. Taylor expanded in b around inf 50.3%

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

   4. Taylor expanded in t around inf 47.5%

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

   if -2.2999999999999999e67 < t < -4.20000000000000009e-103 or -1.2e-263 < t < 3.2500000000000002e31

   1. Initial program 96.3%

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

   3. Taylor expanded in z around 0 74.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 26.5%

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

   if -4.20000000000000009e-103 < t < -6.79999999999999981e-156

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

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

   4. Taylor expanded in y around 0 73.2%

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

   if -6.79999999999999981e-156 < t < -4.5999999999999999e-241

   1. Initial program 100.0%

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

   3. Taylor expanded in a around inf 40.7%

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

   4. Taylor expanded in t around 0 40.7%

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

   if -4.5999999999999999e-241 < t < -1.2e-263

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

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

4. Final simplification 39.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2.3 \cdot 10^{+67}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -4.2 \cdot 10^{-103}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq -6.8 \cdot 10^{-156}:\\ \;\;\;\;z\\ \mathbf{elif}\;t \leq -4.6 \cdot 10^{-241}:\\ \;\;\;\;a\\ \mathbf{elif}\;t \leq -1.2 \cdot 10^{-263}:\\ \;\;\;\;x\\ \mathbf{elif}\;t \leq 3.25 \cdot 10^{+31}:\\ \;\;\;\;y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 48.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(t - 2\right)\\ t_2 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -4.2 \cdot 10^{+18}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -4.6 \cdot 10^{-113}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;y \leq -5 \cdot 10^{-167}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 8 \cdot 10^{-298}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;y \leq 4 \cdot 10^{+15}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (- t 2.0))) (t_2 (* y (- b z))))
   (if (<= y -4.2e+18)
     t_2
     (if (<= y -4.6e-113)
       (+ x a)
       (if (<= y -5e-167)
         t_1
         (if (<= y 8e-298) (+ x a) (if (<= y 4e+15) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (t - 2.0);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -4.2e+18) {
		tmp = t_2;
	} else if (y <= -4.6e-113) {
		tmp = x + a;
	} else if (y <= -5e-167) {
		tmp = t_1;
	} else if (y <= 8e-298) {
		tmp = x + a;
	} else if (y <= 4e+15) {
		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 * (t - 2.0d0)
    t_2 = y * (b - z)
    if (y <= (-4.2d+18)) then
        tmp = t_2
    else if (y <= (-4.6d-113)) then
        tmp = x + a
    else if (y <= (-5d-167)) then
        tmp = t_1
    else if (y <= 8d-298) then
        tmp = x + a
    else if (y <= 4d+15) 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 * (t - 2.0);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -4.2e+18) {
		tmp = t_2;
	} else if (y <= -4.6e-113) {
		tmp = x + a;
	} else if (y <= -5e-167) {
		tmp = t_1;
	} else if (y <= 8e-298) {
		tmp = x + a;
	} else if (y <= 4e+15) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * (t - 2.0)
	t_2 = y * (b - z)
	tmp = 0
	if y <= -4.2e+18:
		tmp = t_2
	elif y <= -4.6e-113:
		tmp = x + a
	elif y <= -5e-167:
		tmp = t_1
	elif y <= 8e-298:
		tmp = x + a
	elif y <= 4e+15:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(t - 2.0))
	t_2 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -4.2e+18)
		tmp = t_2;
	elseif (y <= -4.6e-113)
		tmp = Float64(x + a);
	elseif (y <= -5e-167)
		tmp = t_1;
	elseif (y <= 8e-298)
		tmp = Float64(x + a);
	elseif (y <= 4e+15)
		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 * (t - 2.0);
	t_2 = y * (b - z);
	tmp = 0.0;
	if (y <= -4.2e+18)
		tmp = t_2;
	elseif (y <= -4.6e-113)
		tmp = x + a;
	elseif (y <= -5e-167)
		tmp = t_1;
	elseif (y <= 8e-298)
		tmp = x + a;
	elseif (y <= 4e+15)
		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[(t - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.2e+18], t$95$2, If[LessEqual[y, -4.6e-113], N[(x + a), $MachinePrecision], If[LessEqual[y, -5e-167], t$95$1, If[LessEqual[y, 8e-298], N[(x + a), $MachinePrecision], If[LessEqual[y, 4e+15], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -4.2e18 or 4e15 < y

   1. Initial program 93.1%

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

   3. Taylor expanded in y around inf 70.8%

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

   if -4.2e18 < y < -4.60000000000000016e-113 or -5.0000000000000002e-167 < y < 7.9999999999999993e-298

   1. Initial program 100.0%

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

   3. Taylor expanded in b around 0 82.3%

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

   4. Taylor expanded in a around inf 67.7%

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

   5. Taylor expanded in t around 0 51.7%

      \[\leadsto \color{blue}{x - -1 \cdot a} \]
   6. Step-by-step derivation

      1. cancel-sign-sub-inv 51.7%

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

      2. metadata-eval 51.7%

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

      3. *-lft-identity 51.7%

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

      4. +-commutative 51.7%

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

   7. Simplified 51.7%

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

   if -4.60000000000000016e-113 < y < -5.0000000000000002e-167 or 7.9999999999999993e-298 < y < 4e15

   1. Initial program 100.0%

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

   3. Taylor expanded in b around inf 51.1%

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

   4. Taylor expanded in y around 0 51.1%

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

4. Final simplification 60.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.2 \cdot 10^{+18}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;y \leq -4.6 \cdot 10^{-113}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;y \leq -5 \cdot 10^{-167}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{elif}\;y \leq 8 \cdot 10^{-298}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;y \leq 4 \cdot 10^{+15}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 49.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - t \cdot a\\ t_2 := b \cdot \left(t - 2\right)\\ t_3 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -6.95 \cdot 10^{+47}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq -2.5 \cdot 10^{-114}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-153}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 7 \cdot 10^{-298}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{+17}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- x (* t a))) (t_2 (* b (- t 2.0))) (t_3 (* y (- b z))))
   (if (<= y -6.95e+47)
     t_3
     (if (<= y -2.5e-114)
       t_1
       (if (<= y -3.4e-153)
         t_2
         (if (<= y 7e-298) t_1 (if (<= y 1.2e+17) t_2 t_3)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (t * a);
	double t_2 = b * (t - 2.0);
	double t_3 = y * (b - z);
	double tmp;
	if (y <= -6.95e+47) {
		tmp = t_3;
	} else if (y <= -2.5e-114) {
		tmp = t_1;
	} else if (y <= -3.4e-153) {
		tmp = t_2;
	} else if (y <= 7e-298) {
		tmp = t_1;
	} else if (y <= 1.2e+17) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = x - (t * a)
    t_2 = b * (t - 2.0d0)
    t_3 = y * (b - z)
    if (y <= (-6.95d+47)) then
        tmp = t_3
    else if (y <= (-2.5d-114)) then
        tmp = t_1
    else if (y <= (-3.4d-153)) then
        tmp = t_2
    else if (y <= 7d-298) then
        tmp = t_1
    else if (y <= 1.2d+17) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (t * a);
	double t_2 = b * (t - 2.0);
	double t_3 = y * (b - z);
	double tmp;
	if (y <= -6.95e+47) {
		tmp = t_3;
	} else if (y <= -2.5e-114) {
		tmp = t_1;
	} else if (y <= -3.4e-153) {
		tmp = t_2;
	} else if (y <= 7e-298) {
		tmp = t_1;
	} else if (y <= 1.2e+17) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x - (t * a)
	t_2 = b * (t - 2.0)
	t_3 = y * (b - z)
	tmp = 0
	if y <= -6.95e+47:
		tmp = t_3
	elif y <= -2.5e-114:
		tmp = t_1
	elif y <= -3.4e-153:
		tmp = t_2
	elif y <= 7e-298:
		tmp = t_1
	elif y <= 1.2e+17:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x - Float64(t * a))
	t_2 = Float64(b * Float64(t - 2.0))
	t_3 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -6.95e+47)
		tmp = t_3;
	elseif (y <= -2.5e-114)
		tmp = t_1;
	elseif (y <= -3.4e-153)
		tmp = t_2;
	elseif (y <= 7e-298)
		tmp = t_1;
	elseif (y <= 1.2e+17)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x - (t * a);
	t_2 = b * (t - 2.0);
	t_3 = y * (b - z);
	tmp = 0.0;
	if (y <= -6.95e+47)
		tmp = t_3;
	elseif (y <= -2.5e-114)
		tmp = t_1;
	elseif (y <= -3.4e-153)
		tmp = t_2;
	elseif (y <= 7e-298)
		tmp = t_1;
	elseif (y <= 1.2e+17)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(t - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.95e+47], t$95$3, If[LessEqual[y, -2.5e-114], t$95$1, If[LessEqual[y, -3.4e-153], t$95$2, If[LessEqual[y, 7e-298], t$95$1, If[LessEqual[y, 1.2e+17], t$95$2, t$95$3]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -6.94999999999999994e47 or 1.2e17 < y

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

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

   if -6.94999999999999994e47 < y < -2.49999999999999995e-114 or -3.3999999999999998e-153 < y < 6.9999999999999996e-298

   1. Initial program 98.5%

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

   3. Taylor expanded in b around 0 81.7%

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

   4. Taylor expanded in t around inf 49.1%

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

      1. *-commutative 49.1%

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

   6. Simplified 49.1%

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

   if -2.49999999999999995e-114 < y < -3.3999999999999998e-153 or 6.9999999999999996e-298 < y < 1.2e17

   1. Initial program 100.0%

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

   3. Taylor expanded in b around inf 52.3%

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

   4. Taylor expanded in y around 0 52.3%

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

4. Final simplification 60.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -6.95 \cdot 10^{+47}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;y \leq -2.5 \cdot 10^{-114}:\\ \;\;\;\;x - t \cdot a\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{-153}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{elif}\;y \leq 7 \cdot 10^{-298}:\\ \;\;\;\;x - t \cdot a\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{+17}:\\ \;\;\;\;b \cdot \left(t - 2\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 48.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -4.6 \cdot 10^{+50}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 5 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 1560000000:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 5 \cdot 10^{+44}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))))
   (if (<= t -4.6e+50)
     t_1
     (if (<= t 5e-18)
       (+ x a)
       (if (<= t 1560000000.0) (* y b) (if (<= t 5e+44) x t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -4.6e+50) {
		tmp = t_1;
	} else if (t <= 5e-18) {
		tmp = x + a;
	} else if (t <= 1560000000.0) {
		tmp = y * b;
	} else if (t <= 5e+44) {
		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 = t * (b - a)
    if (t <= (-4.6d+50)) then
        tmp = t_1
    else if (t <= 5d-18) then
        tmp = x + a
    else if (t <= 1560000000.0d0) then
        tmp = y * b
    else if (t <= 5d+44) 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 = t * (b - a);
	double tmp;
	if (t <= -4.6e+50) {
		tmp = t_1;
	} else if (t <= 5e-18) {
		tmp = x + a;
	} else if (t <= 1560000000.0) {
		tmp = y * b;
	} else if (t <= 5e+44) {
		tmp = x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -4.6e+50:
		tmp = t_1
	elif t <= 5e-18:
		tmp = x + a
	elif t <= 1560000000.0:
		tmp = y * b
	elif t <= 5e+44:
		tmp = x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -4.6e+50)
		tmp = t_1;
	elseif (t <= 5e-18)
		tmp = Float64(x + a);
	elseif (t <= 1560000000.0)
		tmp = Float64(y * b);
	elseif (t <= 5e+44)
		tmp = x;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	tmp = 0.0;
	if (t <= -4.6e+50)
		tmp = t_1;
	elseif (t <= 5e-18)
		tmp = x + a;
	elseif (t <= 1560000000.0)
		tmp = y * b;
	elseif (t <= 5e+44)
		tmp = x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.6e+50], t$95$1, If[LessEqual[t, 5e-18], N[(x + a), $MachinePrecision], If[LessEqual[t, 1560000000.0], N[(y * b), $MachinePrecision], If[LessEqual[t, 5e+44], x, t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -4.59999999999999994e50 or 4.9999999999999996e44 < t

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

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

   if -4.59999999999999994e50 < t < 5.00000000000000036e-18

   1. Initial program 96.9%

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

   3. Taylor expanded in b around 0 69.9%

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

   4. Taylor expanded in a around inf 39.8%

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

   5. Taylor expanded in t around 0 39.4%

      \[\leadsto \color{blue}{x - -1 \cdot a} \]
   6. Step-by-step derivation

      1. cancel-sign-sub-inv 39.4%

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

      2. metadata-eval 39.4%

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

      3. *-lft-identity 39.4%

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

      4. +-commutative 39.4%

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

   7. Simplified 39.4%

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

   if 5.00000000000000036e-18 < t < 1.56e9

   1. Initial program 99.8%

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

   3. Taylor expanded in z around 0 85.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 y around inf 66.2%

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

   if 1.56e9 < t < 4.9999999999999996e44

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

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

4. Final simplification 54.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -4.6 \cdot 10^{+50}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \mathbf{elif}\;t \leq 5 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 1560000000:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 5 \cdot 10^{+44}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 86.4% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -5.5e-24) (not (<= b 1.4e+24)))
   (+ (+ x (* b (- (+ y t) 2.0))) (* a (- 1.0 t)))
   (+ x (- (* z (- 1.0 y)) (* a (+ t -1.0))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if b < -5.4999999999999999e-24 or 1.4000000000000001e24 < b

   1. Initial program 94.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 91.5%

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

   if -5.4999999999999999e-24 < b < 1.4000000000000001e24

   1. Initial program 99.1%

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

   3. Taylor expanded in b around 0 94.8%

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

4. Final simplification 93.1%

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

Alternative 15: 35.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.55 \cdot 10^{+57}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq 5 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 3100000000:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 1.25 \cdot 10^{+96}:\\ \;\;\;\;x + a\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -2.55e+57)
   (* t b)
   (if (<= t 5e-18)
     (+ x a)
     (if (<= t 3100000000.0) (* y b) (if (<= t 1.25e+96) (+ x a) (* t b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.55e+57) {
		tmp = t * b;
	} else if (t <= 5e-18) {
		tmp = x + a;
	} else if (t <= 3100000000.0) {
		tmp = y * b;
	} else if (t <= 1.25e+96) {
		tmp = x + a;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (t <= (-2.55d+57)) then
        tmp = t * b
    else if (t <= 5d-18) then
        tmp = x + a
    else if (t <= 3100000000.0d0) then
        tmp = y * b
    else if (t <= 1.25d+96) then
        tmp = x + a
    else
        tmp = t * b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.55e+57) {
		tmp = t * b;
	} else if (t <= 5e-18) {
		tmp = x + a;
	} else if (t <= 3100000000.0) {
		tmp = y * b;
	} else if (t <= 1.25e+96) {
		tmp = x + a;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -2.55e+57:
		tmp = t * b
	elif t <= 5e-18:
		tmp = x + a
	elif t <= 3100000000.0:
		tmp = y * b
	elif t <= 1.25e+96:
		tmp = x + a
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -2.55e+57)
		tmp = Float64(t * b);
	elseif (t <= 5e-18)
		tmp = Float64(x + a);
	elseif (t <= 3100000000.0)
		tmp = Float64(y * b);
	elseif (t <= 1.25e+96)
		tmp = Float64(x + a);
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -2.55e+57)
		tmp = t * b;
	elseif (t <= 5e-18)
		tmp = x + a;
	elseif (t <= 3100000000.0)
		tmp = y * b;
	elseif (t <= 1.25e+96)
		tmp = x + a;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.55e+57], N[(t * b), $MachinePrecision], If[LessEqual[t, 5e-18], N[(x + a), $MachinePrecision], If[LessEqual[t, 3100000000.0], N[(y * b), $MachinePrecision], If[LessEqual[t, 1.25e+96], N[(x + a), $MachinePrecision], N[(t * b), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -2.55000000000000011e57 or 1.2500000000000001e96 < t

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

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

   4. Taylor expanded in t around inf 51.0%

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

   if -2.55000000000000011e57 < t < 5.00000000000000036e-18 or 3.1e9 < t < 1.2500000000000001e96

   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 b around 0 71.2%

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

   4. Taylor expanded in a around inf 39.4%

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

   5. Taylor expanded in t around 0 37.7%

      \[\leadsto \color{blue}{x - -1 \cdot a} \]
   6. Step-by-step derivation

      1. cancel-sign-sub-inv 37.7%

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

      2. metadata-eval 37.7%

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

      3. *-lft-identity 37.7%

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

      4. +-commutative 37.7%

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

   7. Simplified 37.7%

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

   if 5.00000000000000036e-18 < t < 3.1e9

   1. Initial program 99.8%

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

   3. Taylor expanded in z around 0 85.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 y around inf 66.2%

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

4. Final simplification 43.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2.55 \cdot 10^{+57}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq 5 \cdot 10^{-18}:\\ \;\;\;\;x + a\\ \mathbf{elif}\;t \leq 3100000000:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;t \leq 1.25 \cdot 10^{+96}:\\ \;\;\;\;x + a\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \]
5. Add Preprocessing

Alternative 16: 83.3% accurate, 0.9× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if b < -2.1e13 or 6.99999999999999999e25 < b

   1. Initial program 94.6%

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

   3. Taylor expanded in a around 0 87.7%

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

   4. Taylor expanded in z around 0 84.9%

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

   if -2.1e13 < b < 6.99999999999999999e25

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

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

4. Final simplification 89.2%

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

Alternative 17: 25.8% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -4.6 \cdot 10^{-27}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{-124}:\\ \;\;\;\;x\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+23}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= b -4.6e-27)
   (* t b)
   (if (<= b 9.5e-124) x (if (<= b 3.8e+23) z (* t b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -4.6e-27) {
		tmp = t * b;
	} else if (b <= 9.5e-124) {
		tmp = x;
	} else if (b <= 3.8e+23) {
		tmp = z;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (b <= (-4.6d-27)) then
        tmp = t * b
    else if (b <= 9.5d-124) then
        tmp = x
    else if (b <= 3.8d+23) then
        tmp = z
    else
        tmp = t * b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -4.6e-27) {
		tmp = t * b;
	} else if (b <= 9.5e-124) {
		tmp = x;
	} else if (b <= 3.8e+23) {
		tmp = z;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= -4.6e-27:
		tmp = t * b
	elif b <= 9.5e-124:
		tmp = x
	elif b <= 3.8e+23:
		tmp = z
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= -4.6e-27)
		tmp = Float64(t * b);
	elseif (b <= 9.5e-124)
		tmp = x;
	elseif (b <= 3.8e+23)
		tmp = z;
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= -4.6e-27)
		tmp = t * b;
	elseif (b <= 9.5e-124)
		tmp = x;
	elseif (b <= 3.8e+23)
		tmp = z;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.6e-27], N[(t * b), $MachinePrecision], If[LessEqual[b, 9.5e-124], x, If[LessEqual[b, 3.8e+23], z, N[(t * b), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if b < -4.5999999999999999e-27 or 3.79999999999999975e23 < b

   1. Initial program 94.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 75.1%

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

   4. Taylor expanded in t around inf 37.7%

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

   if -4.5999999999999999e-27 < b < 9.49999999999999989e-124

   1. Initial program 98.9%

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

   3. Taylor expanded in x around inf 27.5%

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

   if 9.49999999999999989e-124 < b < 3.79999999999999975e23

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

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

   4. Taylor expanded in y around 0 20.6%

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

4. Final simplification 32.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -4.6 \cdot 10^{-27}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{-124}:\\ \;\;\;\;x\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+23}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \]
5. Add Preprocessing

Alternative 18: 20.1% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{+168}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-263}:\\ \;\;\;\;a\\ \mathbf{elif}\;x \leq 6 \cdot 10^{+73}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.5e+168) x (if (<= x 1.55e-263) a (if (<= x 6e+73) z x))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.5e+168) {
		tmp = x;
	} else if (x <= 1.55e-263) {
		tmp = a;
	} else if (x <= 6e+73) {
		tmp = z;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (x <= (-1.5d+168)) then
        tmp = x
    else if (x <= 1.55d-263) then
        tmp = a
    else if (x <= 6d+73) then
        tmp = z
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.5e+168) {
		tmp = x;
	} else if (x <= 1.55e-263) {
		tmp = a;
	} else if (x <= 6e+73) {
		tmp = z;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.5e+168:
		tmp = x
	elif x <= 1.55e-263:
		tmp = a
	elif x <= 6e+73:
		tmp = z
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.5e+168)
		tmp = x;
	elseif (x <= 1.55e-263)
		tmp = a;
	elseif (x <= 6e+73)
		tmp = z;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.5e+168)
		tmp = x;
	elseif (x <= 1.55e-263)
		tmp = a;
	elseif (x <= 6e+73)
		tmp = z;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.5e+168], x, If[LessEqual[x, 1.55e-263], a, If[LessEqual[x, 6e+73], z, x]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.4999999999999999e168 or 6.00000000000000021e73 < x

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

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

   if -1.4999999999999999e168 < x < 1.55000000000000002e-263

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

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

   4. Taylor expanded in t around 0 16.4%

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

   if 1.55000000000000002e-263 < x < 6.00000000000000021e73

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

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

   4. Taylor expanded in y around 0 23.8%

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

4. Final simplification 25.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{+168}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-263}:\\ \;\;\;\;a\\ \mathbf{elif}\;x \leq 6 \cdot 10^{+73}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 19: 19.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.2 \cdot 10^{+172}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 4.6 \cdot 10^{+175}:\\ \;\;\;\;a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -1.2e+172) x (if (<= x 4.6e+175) a x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.2e+172) {
		tmp = x;
	} else if (x <= 4.6e+175) {
		tmp = a;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (x <= (-1.2d+172)) then
        tmp = x
    else if (x <= 4.6d+175) then
        tmp = a
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -1.2e+172) {
		tmp = x;
	} else if (x <= 4.6e+175) {
		tmp = a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -1.2e+172:
		tmp = x
	elif x <= 4.6e+175:
		tmp = a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -1.2e+172)
		tmp = x;
	elseif (x <= 4.6e+175)
		tmp = a;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -1.2e+172)
		tmp = x;
	elseif (x <= 4.6e+175)
		tmp = a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -1.2e+172], x, If[LessEqual[x, 4.6e+175], a, x]]

Derivation

1. Split input into 2 regimes

2. if x < -1.2e172 or 4.5999999999999999e175 < x

   1. Initial program 96.9%

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

   3. Taylor expanded in x around inf 45.5%

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

   if -1.2e172 < x < 4.5999999999999999e175

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

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

   4. Taylor expanded in t around 0 14.4%

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

4. Final simplification 22.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.2 \cdot 10^{+172}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 4.6 \cdot 10^{+175}:\\ \;\;\;\;a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 20: 11.1% accurate, 21.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

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

4. Taylor expanded in t around 0 11.7%

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

5. Final simplification 11.7%

   \[\leadsto a \]
6. Add Preprocessing

Reproduce

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