Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, E

Percentage Accurate: 85.5% → 90.0%

Time: 33.3s

Alternatives: 34

Speedup: 0.9×

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

Specification

Math

\[\begin{array}{l} \\ \left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \end{array} \]

FPCore

(FPCore (x y z t a b c i j k)
 :precision binary64
 (-
  (-
   (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c))
   (* (* x 4.0) i))
  (* (* j 27.0) k)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    code = (((((((x * 18.0d0) * y) * z) * t) - ((a * 4.0d0) * t)) + (b * c)) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}

Python

def code(x, y, z, t, a, b, c, i, j, k):
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k)

Julia

function code(x, y, z, t, a, b, c, i, j, k)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 18.0) * y) * z) * t) - Float64(Float64(a * 4.0) * t)) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j, k)
	tmp = (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(N[(N[(N[(N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] - N[(N[(a * 4.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]

Initial Program: 85.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \end{array} \]

FPCore

(FPCore (x y z t a b c i j k)
 :precision binary64
 (-
  (-
   (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c))
   (* (* x 4.0) i))
  (* (* j 27.0) k)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    code = (((((((x * 18.0d0) * y) * z) * t) - ((a * 4.0d0) * t)) + (b * c)) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}

Python

def code(x, y, z, t, a, b, c, i, j, k):
	return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k)

Julia

function code(x, y, z, t, a, b, c, i, j, k)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 18.0) * y) * z) * t) - Float64(Float64(a * 4.0) * t)) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j, k)
	tmp = (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(N[(N[(N[(N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] - N[(N[(a * 4.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]

Alternative 1: 90.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;x \leq -2 \cdot 10^{+15}:\\ \;\;\;\;x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + \left(\frac{b \cdot c + t \cdot \left(-4 \cdot a\right)}{x} + i \cdot -4\right)\right) - \left(j \cdot 27\right) \cdot k\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot \left(x \cdot 18\right)\right) \cdot y + a \cdot -4\right) + \left(b \cdot c - \left(\left(x \cdot 4\right) \cdot i + j \cdot \left(27 \cdot k\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= x -2e+15)
   (-
    (*
     x
     (+
      (* (* (* 18.0 t) y) z)
      (+ (/ (+ (* b c) (* t (* -4.0 a))) x) (* i -4.0))))
    (* (* j 27.0) k))
   (+
    (* t (+ (* (* z (* x 18.0)) y) (* a -4.0)))
    (- (* b c) (+ (* (* x 4.0) i) (* j (* 27.0 k)))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (x <= -2e+15) {
		tmp = (x * ((((18.0 * t) * y) * z) + ((((b * c) + (t * (-4.0 * a))) / x) + (i * -4.0)))) - ((j * 27.0) * k);
	} else {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (x <= (-2d+15)) then
        tmp = (x * ((((18.0d0 * t) * y) * z) + ((((b * c) + (t * ((-4.0d0) * a))) / x) + (i * (-4.0d0))))) - ((j * 27.0d0) * k)
    else
        tmp = (t * (((z * (x * 18.0d0)) * y) + (a * (-4.0d0)))) + ((b * c) - (((x * 4.0d0) * i) + (j * (27.0d0 * k))))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (x <= -2e+15) {
		tmp = (x * ((((18.0 * t) * y) * z) + ((((b * c) + (t * (-4.0 * a))) / x) + (i * -4.0)))) - ((j * 27.0) * k);
	} else {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if x <= -2e+15:
		tmp = (x * ((((18.0 * t) * y) * z) + ((((b * c) + (t * (-4.0 * a))) / x) + (i * -4.0)))) - ((j * 27.0) * k)
	else:
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (x <= -2e+15)
		tmp = Float64(Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(Float64(Float64(Float64(b * c) + Float64(t * Float64(-4.0 * a))) / x) + Float64(i * -4.0)))) - Float64(Float64(j * 27.0) * k));
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * Float64(x * 18.0)) * y) + Float64(a * -4.0))) + Float64(Float64(b * c) - Float64(Float64(Float64(x * 4.0) * i) + Float64(j * Float64(27.0 * k)))));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (x <= -2e+15)
		tmp = (x * ((((18.0 * t) * y) * z) + ((((b * c) + (t * (-4.0 * a))) / x) + (i * -4.0)))) - ((j * 27.0) * k);
	else
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[x, -2e+15], N[(N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(z * N[(x * 18.0), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] - N[(N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision] + N[(j * N[(27.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -2e15

   1. Initial program 73.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2e15 < x

   1. Initial program 90.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

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

Alternative 2: 53.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := t \cdot \left(-4 \cdot a\right)\\ t_2 := \left(j \cdot 27\right) \cdot k\\ t_3 := t\_1 - t\_2\\ \mathbf{if}\;b \cdot c \leq -70000000000:\\ \;\;\;\;t\_1 + b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -8.5 \cdot 10^{-189}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \cdot c \leq -3.1 \cdot 10^{-307}:\\ \;\;\;\;\left(18 \cdot \left(\left(t \cdot y\right) \cdot z\right) + -4 \cdot i\right) \cdot x\\ \mathbf{elif}\;b \cdot c \leq 5.8 \cdot 10^{-308}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \cdot c \leq 1.1 \cdot 10^{-254}:\\ \;\;\;\;x \cdot \left(t \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;b \cdot c \leq 6.1 \cdot 10^{-192}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;b \cdot c \leq 3.5 \cdot 10^{-116}:\\ \;\;\;\;x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + i \cdot -4\right)\\ \mathbf{elif}\;b \cdot c \leq 1.18 \cdot 10^{+100}:\\ \;\;\;\;i \cdot \left(x \cdot -4\right) - t\_2\\ \mathbf{else}:\\ \;\;\;\;b \cdot c + -27 \cdot \left(j \cdot k\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* t (* -4.0 a))) (t_2 (* (* j 27.0) k)) (t_3 (- t_1 t_2)))
   (if (<= (* b c) -70000000000.0)
     (+ t_1 (* b c))
     (if (<= (* b c) -8.5e-189)
       t_3
       (if (<= (* b c) -3.1e-307)
         (* (+ (* 18.0 (* (* t y) z)) (* -4.0 i)) x)
         (if (<= (* b c) 5.8e-308)
           t_3
           (if (<= (* b c) 1.1e-254)
             (* x (* t (* 18.0 (* y z))))
             (if (<= (* b c) 6.1e-192)
               t_3
               (if (<= (* b c) 3.5e-116)
                 (* x (+ (* (* (* 18.0 t) y) z) (* i -4.0)))
                 (if (<= (* b c) 1.18e+100)
                   (- (* i (* x -4.0)) t_2)
                   (+ (* b c) (* -27.0 (* j k)))))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = (j * 27.0) * k;
	double t_3 = t_1 - t_2;
	double tmp;
	if ((b * c) <= -70000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -8.5e-189) {
		tmp = t_3;
	} else if ((b * c) <= -3.1e-307) {
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	} else if ((b * c) <= 5.8e-308) {
		tmp = t_3;
	} else if ((b * c) <= 1.1e-254) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6.1e-192) {
		tmp = t_3;
	} else if ((b * c) <= 3.5e-116) {
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	} else if ((b * c) <= 1.18e+100) {
		tmp = (i * (x * -4.0)) - t_2;
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = t * ((-4.0d0) * a)
    t_2 = (j * 27.0d0) * k
    t_3 = t_1 - t_2
    if ((b * c) <= (-70000000000.0d0)) then
        tmp = t_1 + (b * c)
    else if ((b * c) <= (-8.5d-189)) then
        tmp = t_3
    else if ((b * c) <= (-3.1d-307)) then
        tmp = ((18.0d0 * ((t * y) * z)) + ((-4.0d0) * i)) * x
    else if ((b * c) <= 5.8d-308) then
        tmp = t_3
    else if ((b * c) <= 1.1d-254) then
        tmp = x * (t * (18.0d0 * (y * z)))
    else if ((b * c) <= 6.1d-192) then
        tmp = t_3
    else if ((b * c) <= 3.5d-116) then
        tmp = x * ((((18.0d0 * t) * y) * z) + (i * (-4.0d0)))
    else if ((b * c) <= 1.18d+100) then
        tmp = (i * (x * (-4.0d0))) - t_2
    else
        tmp = (b * c) + ((-27.0d0) * (j * k))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = (j * 27.0) * k;
	double t_3 = t_1 - t_2;
	double tmp;
	if ((b * c) <= -70000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -8.5e-189) {
		tmp = t_3;
	} else if ((b * c) <= -3.1e-307) {
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	} else if ((b * c) <= 5.8e-308) {
		tmp = t_3;
	} else if ((b * c) <= 1.1e-254) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6.1e-192) {
		tmp = t_3;
	} else if ((b * c) <= 3.5e-116) {
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	} else if ((b * c) <= 1.18e+100) {
		tmp = (i * (x * -4.0)) - t_2;
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = t * (-4.0 * a)
	t_2 = (j * 27.0) * k
	t_3 = t_1 - t_2
	tmp = 0
	if (b * c) <= -70000000000.0:
		tmp = t_1 + (b * c)
	elif (b * c) <= -8.5e-189:
		tmp = t_3
	elif (b * c) <= -3.1e-307:
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x
	elif (b * c) <= 5.8e-308:
		tmp = t_3
	elif (b * c) <= 1.1e-254:
		tmp = x * (t * (18.0 * (y * z)))
	elif (b * c) <= 6.1e-192:
		tmp = t_3
	elif (b * c) <= 3.5e-116:
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0))
	elif (b * c) <= 1.18e+100:
		tmp = (i * (x * -4.0)) - t_2
	else:
		tmp = (b * c) + (-27.0 * (j * k))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(t * Float64(-4.0 * a))
	t_2 = Float64(Float64(j * 27.0) * k)
	t_3 = Float64(t_1 - t_2)
	tmp = 0.0
	if (Float64(b * c) <= -70000000000.0)
		tmp = Float64(t_1 + Float64(b * c));
	elseif (Float64(b * c) <= -8.5e-189)
		tmp = t_3;
	elseif (Float64(b * c) <= -3.1e-307)
		tmp = Float64(Float64(Float64(18.0 * Float64(Float64(t * y) * z)) + Float64(-4.0 * i)) * x);
	elseif (Float64(b * c) <= 5.8e-308)
		tmp = t_3;
	elseif (Float64(b * c) <= 1.1e-254)
		tmp = Float64(x * Float64(t * Float64(18.0 * Float64(y * z))));
	elseif (Float64(b * c) <= 6.1e-192)
		tmp = t_3;
	elseif (Float64(b * c) <= 3.5e-116)
		tmp = Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(i * -4.0)));
	elseif (Float64(b * c) <= 1.18e+100)
		tmp = Float64(Float64(i * Float64(x * -4.0)) - t_2);
	else
		tmp = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = t * (-4.0 * a);
	t_2 = (j * 27.0) * k;
	t_3 = t_1 - t_2;
	tmp = 0.0;
	if ((b * c) <= -70000000000.0)
		tmp = t_1 + (b * c);
	elseif ((b * c) <= -8.5e-189)
		tmp = t_3;
	elseif ((b * c) <= -3.1e-307)
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	elseif ((b * c) <= 5.8e-308)
		tmp = t_3;
	elseif ((b * c) <= 1.1e-254)
		tmp = x * (t * (18.0 * (y * z)));
	elseif ((b * c) <= 6.1e-192)
		tmp = t_3;
	elseif ((b * c) <= 3.5e-116)
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	elseif ((b * c) <= 1.18e+100)
		tmp = (i * (x * -4.0)) - t_2;
	else
		tmp = (b * c) + (-27.0 * (j * k));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 - t$95$2), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -70000000000.0], N[(t$95$1 + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -8.5e-189], t$95$3, If[LessEqual[N[(b * c), $MachinePrecision], -3.1e-307], N[(N[(N[(18.0 * N[(N[(t * y), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * i), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 5.8e-308], t$95$3, If[LessEqual[N[(b * c), $MachinePrecision], 1.1e-254], N[(x * N[(t * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6.1e-192], t$95$3, If[LessEqual[N[(b * c), $MachinePrecision], 3.5e-116], N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.18e+100], N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]

Derivation

1. Split input into 7 regimes

2. if (*.f64 b c) < -7e10

   1. Initial program 87.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -7e10 < (*.f64 b c) < -8.50000000000000068e-189 or -3.0999999999999998e-307 < (*.f64 b c) < 5.8000000000000001e-308 or 1.1000000000000001e-254 < (*.f64 b c) < 6.0999999999999999e-192

   1. Initial program 86.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.50000000000000068e-189 < (*.f64 b c) < -3.0999999999999998e-307

   1. Initial program 80.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if 5.8000000000000001e-308 < (*.f64 b c) < 1.1000000000000001e-254

   1. Initial program 83.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 6.0999999999999999e-192 < (*.f64 b c) < 3.49999999999999984e-116

   1. Initial program 83.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 3.49999999999999984e-116 < (*.f64 b c) < 1.18e100

   1. Initial program 92.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.18e100 < (*.f64 b c)

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

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

Alternative 3: 53.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := t \cdot \left(-4 \cdot a\right)\\ t_2 := x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + i \cdot -4\right)\\ t_3 := \left(j \cdot 27\right) \cdot k\\ t_4 := t\_1 - t\_3\\ \mathbf{if}\;b \cdot c \leq -85000000000:\\ \;\;\;\;t\_1 + b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -1.2 \cdot 10^{-190}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;b \cdot c \leq -1.5 \cdot 10^{-304}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \cdot c \leq 6 \cdot 10^{-308}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;b \cdot c \leq 1.1 \cdot 10^{-254}:\\ \;\;\;\;x \cdot \left(t \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;b \cdot c \leq 6.4 \cdot 10^{-191}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;b \cdot c \leq 2.7 \cdot 10^{-117}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \cdot c \leq 1.68 \cdot 10^{+100}:\\ \;\;\;\;i \cdot \left(x \cdot -4\right) - t\_3\\ \mathbf{else}:\\ \;\;\;\;b \cdot c + -27 \cdot \left(j \cdot k\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* t (* -4.0 a)))
        (t_2 (* x (+ (* (* (* 18.0 t) y) z) (* i -4.0))))
        (t_3 (* (* j 27.0) k))
        (t_4 (- t_1 t_3)))
   (if (<= (* b c) -85000000000.0)
     (+ t_1 (* b c))
     (if (<= (* b c) -1.2e-190)
       t_4
       (if (<= (* b c) -1.5e-304)
         t_2
         (if (<= (* b c) 6e-308)
           t_4
           (if (<= (* b c) 1.1e-254)
             (* x (* t (* 18.0 (* y z))))
             (if (<= (* b c) 6.4e-191)
               t_4
               (if (<= (* b c) 2.7e-117)
                 t_2
                 (if (<= (* b c) 1.68e+100)
                   (- (* i (* x -4.0)) t_3)
                   (+ (* b c) (* -27.0 (* j k)))))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	double t_3 = (j * 27.0) * k;
	double t_4 = t_1 - t_3;
	double tmp;
	if ((b * c) <= -85000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -1.2e-190) {
		tmp = t_4;
	} else if ((b * c) <= -1.5e-304) {
		tmp = t_2;
	} else if ((b * c) <= 6e-308) {
		tmp = t_4;
	} else if ((b * c) <= 1.1e-254) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6.4e-191) {
		tmp = t_4;
	} else if ((b * c) <= 2.7e-117) {
		tmp = t_2;
	} else if ((b * c) <= 1.68e+100) {
		tmp = (i * (x * -4.0)) - t_3;
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = t * ((-4.0d0) * a)
    t_2 = x * ((((18.0d0 * t) * y) * z) + (i * (-4.0d0)))
    t_3 = (j * 27.0d0) * k
    t_4 = t_1 - t_3
    if ((b * c) <= (-85000000000.0d0)) then
        tmp = t_1 + (b * c)
    else if ((b * c) <= (-1.2d-190)) then
        tmp = t_4
    else if ((b * c) <= (-1.5d-304)) then
        tmp = t_2
    else if ((b * c) <= 6d-308) then
        tmp = t_4
    else if ((b * c) <= 1.1d-254) then
        tmp = x * (t * (18.0d0 * (y * z)))
    else if ((b * c) <= 6.4d-191) then
        tmp = t_4
    else if ((b * c) <= 2.7d-117) then
        tmp = t_2
    else if ((b * c) <= 1.68d+100) then
        tmp = (i * (x * (-4.0d0))) - t_3
    else
        tmp = (b * c) + ((-27.0d0) * (j * k))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	double t_3 = (j * 27.0) * k;
	double t_4 = t_1 - t_3;
	double tmp;
	if ((b * c) <= -85000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -1.2e-190) {
		tmp = t_4;
	} else if ((b * c) <= -1.5e-304) {
		tmp = t_2;
	} else if ((b * c) <= 6e-308) {
		tmp = t_4;
	} else if ((b * c) <= 1.1e-254) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6.4e-191) {
		tmp = t_4;
	} else if ((b * c) <= 2.7e-117) {
		tmp = t_2;
	} else if ((b * c) <= 1.68e+100) {
		tmp = (i * (x * -4.0)) - t_3;
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = t * (-4.0 * a)
	t_2 = x * ((((18.0 * t) * y) * z) + (i * -4.0))
	t_3 = (j * 27.0) * k
	t_4 = t_1 - t_3
	tmp = 0
	if (b * c) <= -85000000000.0:
		tmp = t_1 + (b * c)
	elif (b * c) <= -1.2e-190:
		tmp = t_4
	elif (b * c) <= -1.5e-304:
		tmp = t_2
	elif (b * c) <= 6e-308:
		tmp = t_4
	elif (b * c) <= 1.1e-254:
		tmp = x * (t * (18.0 * (y * z)))
	elif (b * c) <= 6.4e-191:
		tmp = t_4
	elif (b * c) <= 2.7e-117:
		tmp = t_2
	elif (b * c) <= 1.68e+100:
		tmp = (i * (x * -4.0)) - t_3
	else:
		tmp = (b * c) + (-27.0 * (j * k))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(t * Float64(-4.0 * a))
	t_2 = Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(i * -4.0)))
	t_3 = Float64(Float64(j * 27.0) * k)
	t_4 = Float64(t_1 - t_3)
	tmp = 0.0
	if (Float64(b * c) <= -85000000000.0)
		tmp = Float64(t_1 + Float64(b * c));
	elseif (Float64(b * c) <= -1.2e-190)
		tmp = t_4;
	elseif (Float64(b * c) <= -1.5e-304)
		tmp = t_2;
	elseif (Float64(b * c) <= 6e-308)
		tmp = t_4;
	elseif (Float64(b * c) <= 1.1e-254)
		tmp = Float64(x * Float64(t * Float64(18.0 * Float64(y * z))));
	elseif (Float64(b * c) <= 6.4e-191)
		tmp = t_4;
	elseif (Float64(b * c) <= 2.7e-117)
		tmp = t_2;
	elseif (Float64(b * c) <= 1.68e+100)
		tmp = Float64(Float64(i * Float64(x * -4.0)) - t_3);
	else
		tmp = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = t * (-4.0 * a);
	t_2 = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	t_3 = (j * 27.0) * k;
	t_4 = t_1 - t_3;
	tmp = 0.0;
	if ((b * c) <= -85000000000.0)
		tmp = t_1 + (b * c);
	elseif ((b * c) <= -1.2e-190)
		tmp = t_4;
	elseif ((b * c) <= -1.5e-304)
		tmp = t_2;
	elseif ((b * c) <= 6e-308)
		tmp = t_4;
	elseif ((b * c) <= 1.1e-254)
		tmp = x * (t * (18.0 * (y * z)));
	elseif ((b * c) <= 6.4e-191)
		tmp = t_4;
	elseif ((b * c) <= 2.7e-117)
		tmp = t_2;
	elseif ((b * c) <= 1.68e+100)
		tmp = (i * (x * -4.0)) - t_3;
	else
		tmp = (b * c) + (-27.0 * (j * k));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$1 - t$95$3), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -85000000000.0], N[(t$95$1 + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -1.2e-190], t$95$4, If[LessEqual[N[(b * c), $MachinePrecision], -1.5e-304], t$95$2, If[LessEqual[N[(b * c), $MachinePrecision], 6e-308], t$95$4, If[LessEqual[N[(b * c), $MachinePrecision], 1.1e-254], N[(x * N[(t * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6.4e-191], t$95$4, If[LessEqual[N[(b * c), $MachinePrecision], 2.7e-117], t$95$2, If[LessEqual[N[(b * c), $MachinePrecision], 1.68e+100], N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - t$95$3), $MachinePrecision], N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if (*.f64 b c) < -8.5e10

   1. Initial program 87.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -8.5e10 < (*.f64 b c) < -1.2e-190 or -1.5000000000000001e-304 < (*.f64 b c) < 6.00000000000000044e-308 or 1.1000000000000001e-254 < (*.f64 b c) < 6.4000000000000006e-191

   1. Initial program 86.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.2e-190 < (*.f64 b c) < -1.5000000000000001e-304 or 6.4000000000000006e-191 < (*.f64 b c) < 2.70000000000000003e-117

   1. Initial program 82.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 6.00000000000000044e-308 < (*.f64 b c) < 1.1000000000000001e-254

   1. Initial program 83.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 2.70000000000000003e-117 < (*.f64 b c) < 1.68000000000000008e100

   1. Initial program 92.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.68000000000000008e100 < (*.f64 b c)

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

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

Alternative 4: 36.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := 18 \cdot \left(y \cdot z\right)\\ \mathbf{if}\;b \cdot c \leq -3.3 \cdot 10^{+223}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -1.4 \cdot 10^{+39}:\\ \;\;\;\;t \cdot \left(x \cdot t\_1\right)\\ \mathbf{elif}\;b \cdot c \leq -1.65 \cdot 10^{-175}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{elif}\;b \cdot c \leq -5 \cdot 10^{-319}:\\ \;\;\;\;18 \cdot \left(\left(\left(x \cdot z\right) \cdot y\right) \cdot t\right)\\ \mathbf{elif}\;b \cdot c \leq 4.5 \cdot 10^{-308}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;b \cdot c \leq 6.4 \cdot 10^{-116}:\\ \;\;\;\;x \cdot \left(t \cdot t\_1\right)\\ \mathbf{elif}\;b \cdot c \leq 9.4 \cdot 10^{+47}:\\ \;\;\;\;k \cdot \left(j \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* 18.0 (* y z))))
   (if (<= (* b c) -3.3e+223)
     (* b c)
     (if (<= (* b c) -1.4e+39)
       (* t (* x t_1))
       (if (<= (* b c) -1.65e-175)
         (* j (* k -27.0))
         (if (<= (* b c) -5e-319)
           (* 18.0 (* (* (* x z) y) t))
           (if (<= (* b c) 4.5e-308)
             (* (* j k) -27.0)
             (if (<= (* b c) 6.4e-116)
               (* x (* t t_1))
               (if (<= (* b c) 9.4e+47) (* k (* j -27.0)) (* b c))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * (y * z);
	double tmp;
	if ((b * c) <= -3.3e+223) {
		tmp = b * c;
	} else if ((b * c) <= -1.4e+39) {
		tmp = t * (x * t_1);
	} else if ((b * c) <= -1.65e-175) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 4.5e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 6.4e-116) {
		tmp = x * (t * t_1);
	} else if ((b * c) <= 9.4e+47) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = 18.0d0 * (y * z)
    if ((b * c) <= (-3.3d+223)) then
        tmp = b * c
    else if ((b * c) <= (-1.4d+39)) then
        tmp = t * (x * t_1)
    else if ((b * c) <= (-1.65d-175)) then
        tmp = j * (k * (-27.0d0))
    else if ((b * c) <= (-5d-319)) then
        tmp = 18.0d0 * (((x * z) * y) * t)
    else if ((b * c) <= 4.5d-308) then
        tmp = (j * k) * (-27.0d0)
    else if ((b * c) <= 6.4d-116) then
        tmp = x * (t * t_1)
    else if ((b * c) <= 9.4d+47) then
        tmp = k * (j * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * (y * z);
	double tmp;
	if ((b * c) <= -3.3e+223) {
		tmp = b * c;
	} else if ((b * c) <= -1.4e+39) {
		tmp = t * (x * t_1);
	} else if ((b * c) <= -1.65e-175) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 4.5e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 6.4e-116) {
		tmp = x * (t * t_1);
	} else if ((b * c) <= 9.4e+47) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = 18.0 * (y * z)
	tmp = 0
	if (b * c) <= -3.3e+223:
		tmp = b * c
	elif (b * c) <= -1.4e+39:
		tmp = t * (x * t_1)
	elif (b * c) <= -1.65e-175:
		tmp = j * (k * -27.0)
	elif (b * c) <= -5e-319:
		tmp = 18.0 * (((x * z) * y) * t)
	elif (b * c) <= 4.5e-308:
		tmp = (j * k) * -27.0
	elif (b * c) <= 6.4e-116:
		tmp = x * (t * t_1)
	elif (b * c) <= 9.4e+47:
		tmp = k * (j * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(18.0 * Float64(y * z))
	tmp = 0.0
	if (Float64(b * c) <= -3.3e+223)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -1.4e+39)
		tmp = Float64(t * Float64(x * t_1));
	elseif (Float64(b * c) <= -1.65e-175)
		tmp = Float64(j * Float64(k * -27.0));
	elseif (Float64(b * c) <= -5e-319)
		tmp = Float64(18.0 * Float64(Float64(Float64(x * z) * y) * t));
	elseif (Float64(b * c) <= 4.5e-308)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (Float64(b * c) <= 6.4e-116)
		tmp = Float64(x * Float64(t * t_1));
	elseif (Float64(b * c) <= 9.4e+47)
		tmp = Float64(k * Float64(j * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = 18.0 * (y * z);
	tmp = 0.0;
	if ((b * c) <= -3.3e+223)
		tmp = b * c;
	elseif ((b * c) <= -1.4e+39)
		tmp = t * (x * t_1);
	elseif ((b * c) <= -1.65e-175)
		tmp = j * (k * -27.0);
	elseif ((b * c) <= -5e-319)
		tmp = 18.0 * (((x * z) * y) * t);
	elseif ((b * c) <= 4.5e-308)
		tmp = (j * k) * -27.0;
	elseif ((b * c) <= 6.4e-116)
		tmp = x * (t * t_1);
	elseif ((b * c) <= 9.4e+47)
		tmp = k * (j * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -3.3e+223], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -1.4e+39], N[(t * N[(x * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -1.65e-175], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -5e-319], N[(18.0 * N[(N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 4.5e-308], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6.4e-116], N[(x * N[(t * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 9.4e+47], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 7 regimes

2. if (*.f64 b c) < -3.3e223 or 9.39999999999999928e47 < (*.f64 b c)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -3.3e223 < (*.f64 b c) < -1.40000000000000001e39

   1. Initial program 89.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.40000000000000001e39 < (*.f64 b c) < -1.64999999999999999e-175

   1. Initial program 94.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -1.64999999999999999e-175 < (*.f64 b c) < -4.9999937e-319

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.9999937e-319 < (*.f64 b c) < 4.50000000000000009e-308

   1. Initial program 77.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if 4.50000000000000009e-308 < (*.f64 b c) < 6.40000000000000019e-116

   1. Initial program 86.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 6.40000000000000019e-116 < (*.f64 b c) < 9.39999999999999928e47

   1. Initial program 96.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 5: 36.8% accurate, 0.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;b \cdot c \leq -4.2 \cdot 10^{+223}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -6 \cdot 10^{+37}:\\ \;\;\;\;t \cdot \left(x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;b \cdot c \leq -1.95 \cdot 10^{-177}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{elif}\;b \cdot c \leq -5 \cdot 10^{-319}:\\ \;\;\;\;18 \cdot \left(\left(\left(x \cdot z\right) \cdot y\right) \cdot t\right)\\ \mathbf{elif}\;b \cdot c \leq 1.4 \cdot 10^{-308}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;b \cdot c \leq 1.6 \cdot 10^{-115}:\\ \;\;\;\;18 \cdot \left(\left(y \cdot \left(x \cdot t\right)\right) \cdot z\right)\\ \mathbf{elif}\;b \cdot c \leq 1.55 \cdot 10^{+48}:\\ \;\;\;\;k \cdot \left(j \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= (* b c) -4.2e+223)
   (* b c)
   (if (<= (* b c) -6e+37)
     (* t (* x (* 18.0 (* y z))))
     (if (<= (* b c) -1.95e-177)
       (* j (* k -27.0))
       (if (<= (* b c) -5e-319)
         (* 18.0 (* (* (* x z) y) t))
         (if (<= (* b c) 1.4e-308)
           (* (* j k) -27.0)
           (if (<= (* b c) 1.6e-115)
             (* 18.0 (* (* y (* x t)) z))
             (if (<= (* b c) 1.55e+48) (* k (* j -27.0)) (* b c)))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -4.2e+223) {
		tmp = b * c;
	} else if ((b * c) <= -6e+37) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if ((b * c) <= -1.95e-177) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 1.4e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 1.6e-115) {
		tmp = 18.0 * ((y * (x * t)) * z);
	} else if ((b * c) <= 1.55e+48) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((b * c) <= (-4.2d+223)) then
        tmp = b * c
    else if ((b * c) <= (-6d+37)) then
        tmp = t * (x * (18.0d0 * (y * z)))
    else if ((b * c) <= (-1.95d-177)) then
        tmp = j * (k * (-27.0d0))
    else if ((b * c) <= (-5d-319)) then
        tmp = 18.0d0 * (((x * z) * y) * t)
    else if ((b * c) <= 1.4d-308) then
        tmp = (j * k) * (-27.0d0)
    else if ((b * c) <= 1.6d-115) then
        tmp = 18.0d0 * ((y * (x * t)) * z)
    else if ((b * c) <= 1.55d+48) then
        tmp = k * (j * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -4.2e+223) {
		tmp = b * c;
	} else if ((b * c) <= -6e+37) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if ((b * c) <= -1.95e-177) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 1.4e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 1.6e-115) {
		tmp = 18.0 * ((y * (x * t)) * z);
	} else if ((b * c) <= 1.55e+48) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if (b * c) <= -4.2e+223:
		tmp = b * c
	elif (b * c) <= -6e+37:
		tmp = t * (x * (18.0 * (y * z)))
	elif (b * c) <= -1.95e-177:
		tmp = j * (k * -27.0)
	elif (b * c) <= -5e-319:
		tmp = 18.0 * (((x * z) * y) * t)
	elif (b * c) <= 1.4e-308:
		tmp = (j * k) * -27.0
	elif (b * c) <= 1.6e-115:
		tmp = 18.0 * ((y * (x * t)) * z)
	elif (b * c) <= 1.55e+48:
		tmp = k * (j * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (Float64(b * c) <= -4.2e+223)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -6e+37)
		tmp = Float64(t * Float64(x * Float64(18.0 * Float64(y * z))));
	elseif (Float64(b * c) <= -1.95e-177)
		tmp = Float64(j * Float64(k * -27.0));
	elseif (Float64(b * c) <= -5e-319)
		tmp = Float64(18.0 * Float64(Float64(Float64(x * z) * y) * t));
	elseif (Float64(b * c) <= 1.4e-308)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (Float64(b * c) <= 1.6e-115)
		tmp = Float64(18.0 * Float64(Float64(y * Float64(x * t)) * z));
	elseif (Float64(b * c) <= 1.55e+48)
		tmp = Float64(k * Float64(j * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if ((b * c) <= -4.2e+223)
		tmp = b * c;
	elseif ((b * c) <= -6e+37)
		tmp = t * (x * (18.0 * (y * z)));
	elseif ((b * c) <= -1.95e-177)
		tmp = j * (k * -27.0);
	elseif ((b * c) <= -5e-319)
		tmp = 18.0 * (((x * z) * y) * t);
	elseif ((b * c) <= 1.4e-308)
		tmp = (j * k) * -27.0;
	elseif ((b * c) <= 1.6e-115)
		tmp = 18.0 * ((y * (x * t)) * z);
	elseif ((b * c) <= 1.55e+48)
		tmp = k * (j * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[N[(b * c), $MachinePrecision], -4.2e+223], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -6e+37], N[(t * N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -1.95e-177], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -5e-319], N[(18.0 * N[(N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.4e-308], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.6e-115], N[(18.0 * N[(N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.55e+48], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 7 regimes

2. if (*.f64 b c) < -4.19999999999999981e223 or 1.55000000000000003e48 < (*.f64 b c)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -4.19999999999999981e223 < (*.f64 b c) < -6.00000000000000043e37

   1. Initial program 89.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -6.00000000000000043e37 < (*.f64 b c) < -1.95000000000000007e-177

   1. Initial program 94.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -1.95000000000000007e-177 < (*.f64 b c) < -4.9999937e-319

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.9999937e-319 < (*.f64 b c) < 1.4000000000000002e-308

   1. Initial program 77.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.4000000000000002e-308 < (*.f64 b c) < 1.6e-115

   1. Initial program 86.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.6e-115 < (*.f64 b c) < 1.55000000000000003e48

   1. Initial program 96.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 6: 37.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := 18 \cdot \left(\left(y \cdot \left(x \cdot t\right)\right) \cdot z\right)\\ \mathbf{if}\;b \cdot c \leq -2 \cdot 10^{+223}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -9 \cdot 10^{+21}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq -2.25 \cdot 10^{-176}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{elif}\;b \cdot c \leq -5 \cdot 10^{-319}:\\ \;\;\;\;18 \cdot \left(\left(\left(x \cdot z\right) \cdot y\right) \cdot t\right)\\ \mathbf{elif}\;b \cdot c \leq 1.3 \cdot 10^{-308}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;b \cdot c \leq 3 \cdot 10^{-115}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq 2.95 \cdot 10^{+47}:\\ \;\;\;\;k \cdot \left(j \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* 18.0 (* (* y (* x t)) z))))
   (if (<= (* b c) -2e+223)
     (* b c)
     (if (<= (* b c) -9e+21)
       t_1
       (if (<= (* b c) -2.25e-176)
         (* j (* k -27.0))
         (if (<= (* b c) -5e-319)
           (* 18.0 (* (* (* x z) y) t))
           (if (<= (* b c) 1.3e-308)
             (* (* j k) -27.0)
             (if (<= (* b c) 3e-115)
               t_1
               (if (<= (* b c) 2.95e+47) (* k (* j -27.0)) (* b c))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * ((y * (x * t)) * z);
	double tmp;
	if ((b * c) <= -2e+223) {
		tmp = b * c;
	} else if ((b * c) <= -9e+21) {
		tmp = t_1;
	} else if ((b * c) <= -2.25e-176) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 1.3e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 3e-115) {
		tmp = t_1;
	} else if ((b * c) <= 2.95e+47) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = 18.0d0 * ((y * (x * t)) * z)
    if ((b * c) <= (-2d+223)) then
        tmp = b * c
    else if ((b * c) <= (-9d+21)) then
        tmp = t_1
    else if ((b * c) <= (-2.25d-176)) then
        tmp = j * (k * (-27.0d0))
    else if ((b * c) <= (-5d-319)) then
        tmp = 18.0d0 * (((x * z) * y) * t)
    else if ((b * c) <= 1.3d-308) then
        tmp = (j * k) * (-27.0d0)
    else if ((b * c) <= 3d-115) then
        tmp = t_1
    else if ((b * c) <= 2.95d+47) then
        tmp = k * (j * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * ((y * (x * t)) * z);
	double tmp;
	if ((b * c) <= -2e+223) {
		tmp = b * c;
	} else if ((b * c) <= -9e+21) {
		tmp = t_1;
	} else if ((b * c) <= -2.25e-176) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if ((b * c) <= 1.3e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 3e-115) {
		tmp = t_1;
	} else if ((b * c) <= 2.95e+47) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = 18.0 * ((y * (x * t)) * z)
	tmp = 0
	if (b * c) <= -2e+223:
		tmp = b * c
	elif (b * c) <= -9e+21:
		tmp = t_1
	elif (b * c) <= -2.25e-176:
		tmp = j * (k * -27.0)
	elif (b * c) <= -5e-319:
		tmp = 18.0 * (((x * z) * y) * t)
	elif (b * c) <= 1.3e-308:
		tmp = (j * k) * -27.0
	elif (b * c) <= 3e-115:
		tmp = t_1
	elif (b * c) <= 2.95e+47:
		tmp = k * (j * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(18.0 * Float64(Float64(y * Float64(x * t)) * z))
	tmp = 0.0
	if (Float64(b * c) <= -2e+223)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -9e+21)
		tmp = t_1;
	elseif (Float64(b * c) <= -2.25e-176)
		tmp = Float64(j * Float64(k * -27.0));
	elseif (Float64(b * c) <= -5e-319)
		tmp = Float64(18.0 * Float64(Float64(Float64(x * z) * y) * t));
	elseif (Float64(b * c) <= 1.3e-308)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (Float64(b * c) <= 3e-115)
		tmp = t_1;
	elseif (Float64(b * c) <= 2.95e+47)
		tmp = Float64(k * Float64(j * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = 18.0 * ((y * (x * t)) * z);
	tmp = 0.0;
	if ((b * c) <= -2e+223)
		tmp = b * c;
	elseif ((b * c) <= -9e+21)
		tmp = t_1;
	elseif ((b * c) <= -2.25e-176)
		tmp = j * (k * -27.0);
	elseif ((b * c) <= -5e-319)
		tmp = 18.0 * (((x * z) * y) * t);
	elseif ((b * c) <= 1.3e-308)
		tmp = (j * k) * -27.0;
	elseif ((b * c) <= 3e-115)
		tmp = t_1;
	elseif ((b * c) <= 2.95e+47)
		tmp = k * (j * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(18.0 * N[(N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -2e+223], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -9e+21], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], -2.25e-176], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -5e-319], N[(18.0 * N[(N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.3e-308], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 3e-115], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], 2.95e+47], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if (*.f64 b c) < -2.00000000000000009e223 or 2.95000000000000017e47 < (*.f64 b c)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.00000000000000009e223 < (*.f64 b c) < -9e21 or 1.3e-308 < (*.f64 b c) < 3.0000000000000002e-115

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -9e21 < (*.f64 b c) < -2.25e-176

   1. Initial program 94.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -2.25e-176 < (*.f64 b c) < -4.9999937e-319

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.9999937e-319 < (*.f64 b c) < 1.3e-308

   1. Initial program 77.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if 3.0000000000000002e-115 < (*.f64 b c) < 2.95000000000000017e47

   1. Initial program 96.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 7: 37.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := 18 \cdot \left(\left(y \cdot \left(x \cdot t\right)\right) \cdot z\right)\\ \mathbf{if}\;b \cdot c \leq -2.25 \cdot 10^{+223}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -6.8 \cdot 10^{+19}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq -8.8 \cdot 10^{-175}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{elif}\;b \cdot c \leq -5 \cdot 10^{-319}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq 2.25 \cdot 10^{-308}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;b \cdot c \leq 7.2 \cdot 10^{-117}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq 1.42 \cdot 10^{+48}:\\ \;\;\;\;k \cdot \left(j \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* 18.0 (* (* y (* x t)) z))))
   (if (<= (* b c) -2.25e+223)
     (* b c)
     (if (<= (* b c) -6.8e+19)
       t_1
       (if (<= (* b c) -8.8e-175)
         (* j (* k -27.0))
         (if (<= (* b c) -5e-319)
           t_1
           (if (<= (* b c) 2.25e-308)
             (* (* j k) -27.0)
             (if (<= (* b c) 7.2e-117)
               t_1
               (if (<= (* b c) 1.42e+48) (* k (* j -27.0)) (* b c))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * ((y * (x * t)) * z);
	double tmp;
	if ((b * c) <= -2.25e+223) {
		tmp = b * c;
	} else if ((b * c) <= -6.8e+19) {
		tmp = t_1;
	} else if ((b * c) <= -8.8e-175) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = t_1;
	} else if ((b * c) <= 2.25e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 7.2e-117) {
		tmp = t_1;
	} else if ((b * c) <= 1.42e+48) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = 18.0d0 * ((y * (x * t)) * z)
    if ((b * c) <= (-2.25d+223)) then
        tmp = b * c
    else if ((b * c) <= (-6.8d+19)) then
        tmp = t_1
    else if ((b * c) <= (-8.8d-175)) then
        tmp = j * (k * (-27.0d0))
    else if ((b * c) <= (-5d-319)) then
        tmp = t_1
    else if ((b * c) <= 2.25d-308) then
        tmp = (j * k) * (-27.0d0)
    else if ((b * c) <= 7.2d-117) then
        tmp = t_1
    else if ((b * c) <= 1.42d+48) then
        tmp = k * (j * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = 18.0 * ((y * (x * t)) * z);
	double tmp;
	if ((b * c) <= -2.25e+223) {
		tmp = b * c;
	} else if ((b * c) <= -6.8e+19) {
		tmp = t_1;
	} else if ((b * c) <= -8.8e-175) {
		tmp = j * (k * -27.0);
	} else if ((b * c) <= -5e-319) {
		tmp = t_1;
	} else if ((b * c) <= 2.25e-308) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 7.2e-117) {
		tmp = t_1;
	} else if ((b * c) <= 1.42e+48) {
		tmp = k * (j * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = 18.0 * ((y * (x * t)) * z)
	tmp = 0
	if (b * c) <= -2.25e+223:
		tmp = b * c
	elif (b * c) <= -6.8e+19:
		tmp = t_1
	elif (b * c) <= -8.8e-175:
		tmp = j * (k * -27.0)
	elif (b * c) <= -5e-319:
		tmp = t_1
	elif (b * c) <= 2.25e-308:
		tmp = (j * k) * -27.0
	elif (b * c) <= 7.2e-117:
		tmp = t_1
	elif (b * c) <= 1.42e+48:
		tmp = k * (j * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(18.0 * Float64(Float64(y * Float64(x * t)) * z))
	tmp = 0.0
	if (Float64(b * c) <= -2.25e+223)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -6.8e+19)
		tmp = t_1;
	elseif (Float64(b * c) <= -8.8e-175)
		tmp = Float64(j * Float64(k * -27.0));
	elseif (Float64(b * c) <= -5e-319)
		tmp = t_1;
	elseif (Float64(b * c) <= 2.25e-308)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (Float64(b * c) <= 7.2e-117)
		tmp = t_1;
	elseif (Float64(b * c) <= 1.42e+48)
		tmp = Float64(k * Float64(j * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = 18.0 * ((y * (x * t)) * z);
	tmp = 0.0;
	if ((b * c) <= -2.25e+223)
		tmp = b * c;
	elseif ((b * c) <= -6.8e+19)
		tmp = t_1;
	elseif ((b * c) <= -8.8e-175)
		tmp = j * (k * -27.0);
	elseif ((b * c) <= -5e-319)
		tmp = t_1;
	elseif ((b * c) <= 2.25e-308)
		tmp = (j * k) * -27.0;
	elseif ((b * c) <= 7.2e-117)
		tmp = t_1;
	elseif ((b * c) <= 1.42e+48)
		tmp = k * (j * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(18.0 * N[(N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -2.25e+223], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -6.8e+19], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], -8.8e-175], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -5e-319], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], 2.25e-308], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 7.2e-117], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], 1.42e+48], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if (*.f64 b c) < -2.25e223 or 1.42e48 < (*.f64 b c)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.25e223 < (*.f64 b c) < -6.8e19 or -8.8e-175 < (*.f64 b c) < -4.9999937e-319 or 2.25000000000000004e-308 < (*.f64 b c) < 7.2000000000000001e-117

   1. Initial program 88.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -6.8e19 < (*.f64 b c) < -8.8e-175

   1. Initial program 94.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -4.9999937e-319 < (*.f64 b c) < 2.25000000000000004e-308

   1. Initial program 77.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if 7.2000000000000001e-117 < (*.f64 b c) < 1.42e48

   1. Initial program 96.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 8: 54.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := t \cdot \left(-4 \cdot a\right)\\ t_2 := t\_1 - \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;b \cdot c \leq -85000000000:\\ \;\;\;\;t\_1 + b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -3.9 \cdot 10^{-184}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \cdot c \leq -1.9 \cdot 10^{-301}:\\ \;\;\;\;x \cdot \left(18 \cdot \left(\left(y \cdot z\right) \cdot t\right) + i \cdot -4\right)\\ \mathbf{elif}\;b \cdot c \leq 6 \cdot 10^{-308}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \cdot c \leq 7 \cdot 10^{-250}:\\ \;\;\;\;x \cdot \left(t \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;b \cdot c \leq 6 \cdot 10^{+100}:\\ \;\;\;\;i \cdot \left(x \cdot -4\right) - \left(k \cdot j\right) \cdot 27\\ \mathbf{else}:\\ \;\;\;\;b \cdot c + -27 \cdot \left(j \cdot k\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* t (* -4.0 a))) (t_2 (- t_1 (* (* j 27.0) k))))
   (if (<= (* b c) -85000000000.0)
     (+ t_1 (* b c))
     (if (<= (* b c) -3.9e-184)
       t_2
       (if (<= (* b c) -1.9e-301)
         (* x (+ (* 18.0 (* (* y z) t)) (* i -4.0)))
         (if (<= (* b c) 6e-308)
           t_2
           (if (<= (* b c) 7e-250)
             (* x (* t (* 18.0 (* y z))))
             (if (<= (* b c) 6e+100)
               (- (* i (* x -4.0)) (* (* k j) 27.0))
               (+ (* b c) (* -27.0 (* j k)))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = t_1 - ((j * 27.0) * k);
	double tmp;
	if ((b * c) <= -85000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -3.9e-184) {
		tmp = t_2;
	} else if ((b * c) <= -1.9e-301) {
		tmp = x * ((18.0 * ((y * z) * t)) + (i * -4.0));
	} else if ((b * c) <= 6e-308) {
		tmp = t_2;
	} else if ((b * c) <= 7e-250) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6e+100) {
		tmp = (i * (x * -4.0)) - ((k * j) * 27.0);
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = t * ((-4.0d0) * a)
    t_2 = t_1 - ((j * 27.0d0) * k)
    if ((b * c) <= (-85000000000.0d0)) then
        tmp = t_1 + (b * c)
    else if ((b * c) <= (-3.9d-184)) then
        tmp = t_2
    else if ((b * c) <= (-1.9d-301)) then
        tmp = x * ((18.0d0 * ((y * z) * t)) + (i * (-4.0d0)))
    else if ((b * c) <= 6d-308) then
        tmp = t_2
    else if ((b * c) <= 7d-250) then
        tmp = x * (t * (18.0d0 * (y * z)))
    else if ((b * c) <= 6d+100) then
        tmp = (i * (x * (-4.0d0))) - ((k * j) * 27.0d0)
    else
        tmp = (b * c) + ((-27.0d0) * (j * k))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = t * (-4.0 * a);
	double t_2 = t_1 - ((j * 27.0) * k);
	double tmp;
	if ((b * c) <= -85000000000.0) {
		tmp = t_1 + (b * c);
	} else if ((b * c) <= -3.9e-184) {
		tmp = t_2;
	} else if ((b * c) <= -1.9e-301) {
		tmp = x * ((18.0 * ((y * z) * t)) + (i * -4.0));
	} else if ((b * c) <= 6e-308) {
		tmp = t_2;
	} else if ((b * c) <= 7e-250) {
		tmp = x * (t * (18.0 * (y * z)));
	} else if ((b * c) <= 6e+100) {
		tmp = (i * (x * -4.0)) - ((k * j) * 27.0);
	} else {
		tmp = (b * c) + (-27.0 * (j * k));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = t * (-4.0 * a)
	t_2 = t_1 - ((j * 27.0) * k)
	tmp = 0
	if (b * c) <= -85000000000.0:
		tmp = t_1 + (b * c)
	elif (b * c) <= -3.9e-184:
		tmp = t_2
	elif (b * c) <= -1.9e-301:
		tmp = x * ((18.0 * ((y * z) * t)) + (i * -4.0))
	elif (b * c) <= 6e-308:
		tmp = t_2
	elif (b * c) <= 7e-250:
		tmp = x * (t * (18.0 * (y * z)))
	elif (b * c) <= 6e+100:
		tmp = (i * (x * -4.0)) - ((k * j) * 27.0)
	else:
		tmp = (b * c) + (-27.0 * (j * k))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(t * Float64(-4.0 * a))
	t_2 = Float64(t_1 - Float64(Float64(j * 27.0) * k))
	tmp = 0.0
	if (Float64(b * c) <= -85000000000.0)
		tmp = Float64(t_1 + Float64(b * c));
	elseif (Float64(b * c) <= -3.9e-184)
		tmp = t_2;
	elseif (Float64(b * c) <= -1.9e-301)
		tmp = Float64(x * Float64(Float64(18.0 * Float64(Float64(y * z) * t)) + Float64(i * -4.0)));
	elseif (Float64(b * c) <= 6e-308)
		tmp = t_2;
	elseif (Float64(b * c) <= 7e-250)
		tmp = Float64(x * Float64(t * Float64(18.0 * Float64(y * z))));
	elseif (Float64(b * c) <= 6e+100)
		tmp = Float64(Float64(i * Float64(x * -4.0)) - Float64(Float64(k * j) * 27.0));
	else
		tmp = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = t * (-4.0 * a);
	t_2 = t_1 - ((j * 27.0) * k);
	tmp = 0.0;
	if ((b * c) <= -85000000000.0)
		tmp = t_1 + (b * c);
	elseif ((b * c) <= -3.9e-184)
		tmp = t_2;
	elseif ((b * c) <= -1.9e-301)
		tmp = x * ((18.0 * ((y * z) * t)) + (i * -4.0));
	elseif ((b * c) <= 6e-308)
		tmp = t_2;
	elseif ((b * c) <= 7e-250)
		tmp = x * (t * (18.0 * (y * z)));
	elseif ((b * c) <= 6e+100)
		tmp = (i * (x * -4.0)) - ((k * j) * 27.0);
	else
		tmp = (b * c) + (-27.0 * (j * k));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -85000000000.0], N[(t$95$1 + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -3.9e-184], t$95$2, If[LessEqual[N[(b * c), $MachinePrecision], -1.9e-301], N[(x * N[(N[(18.0 * N[(N[(y * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6e-308], t$95$2, If[LessEqual[N[(b * c), $MachinePrecision], 7e-250], N[(x * N[(t * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6e+100], N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - N[(N[(k * j), $MachinePrecision] * 27.0), $MachinePrecision]), $MachinePrecision], N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if (*.f64 b c) < -8.5e10

   1. Initial program 87.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -8.5e10 < (*.f64 b c) < -3.89999999999999994e-184 or -1.89999999999999998e-301 < (*.f64 b c) < 6.00000000000000044e-308

   1. Initial program 85.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.89999999999999994e-184 < (*.f64 b c) < -1.89999999999999998e-301

   1. Initial program 80.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 6.00000000000000044e-308 < (*.f64 b c) < 6.9999999999999998e-250

   1. Initial program 85.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 6.9999999999999998e-250 < (*.f64 b c) < 5.99999999999999971e100

   1. Initial program 90.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 5.99999999999999971e100 < (*.f64 b c)

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

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

Alternative 9: 48.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(a \cdot t + i \cdot x\right) \cdot -4\\ t_2 := b \cdot c + -27 \cdot \left(j \cdot k\right)\\ \mathbf{if}\;c \leq -4.7 \cdot 10^{-48}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;c \leq 2.75 \cdot 10^{-306}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 9.8 \cdot 10^{-281}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;c \leq 4.3 \cdot 10^{-110}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 1.2 \cdot 10^{-62}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;c \leq 7.5 \cdot 10^{+16}:\\ \;\;\;\;t \cdot \left(x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;c \leq 2.5 \cdot 10^{+99}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (+ (* a t) (* i x)) -4.0)) (t_2 (+ (* b c) (* -27.0 (* j k)))))
   (if (<= c -4.7e-48)
     t_2
     (if (<= c 2.75e-306)
       t_1
       (if (<= c 9.8e-281)
         t_2
         (if (<= c 4.3e-110)
           t_1
           (if (<= c 1.2e-62)
             t_2
             (if (<= c 7.5e+16)
               (* t (* x (* 18.0 (* y z))))
               (if (<= c 2.5e+99) t_1 t_2)))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * -4.0;
	double t_2 = (b * c) + (-27.0 * (j * k));
	double tmp;
	if (c <= -4.7e-48) {
		tmp = t_2;
	} else if (c <= 2.75e-306) {
		tmp = t_1;
	} else if (c <= 9.8e-281) {
		tmp = t_2;
	} else if (c <= 4.3e-110) {
		tmp = t_1;
	} else if (c <= 1.2e-62) {
		tmp = t_2;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 2.5e+99) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((a * t) + (i * x)) * (-4.0d0)
    t_2 = (b * c) + ((-27.0d0) * (j * k))
    if (c <= (-4.7d-48)) then
        tmp = t_2
    else if (c <= 2.75d-306) then
        tmp = t_1
    else if (c <= 9.8d-281) then
        tmp = t_2
    else if (c <= 4.3d-110) then
        tmp = t_1
    else if (c <= 1.2d-62) then
        tmp = t_2
    else if (c <= 7.5d+16) then
        tmp = t * (x * (18.0d0 * (y * z)))
    else if (c <= 2.5d+99) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * -4.0;
	double t_2 = (b * c) + (-27.0 * (j * k));
	double tmp;
	if (c <= -4.7e-48) {
		tmp = t_2;
	} else if (c <= 2.75e-306) {
		tmp = t_1;
	} else if (c <= 9.8e-281) {
		tmp = t_2;
	} else if (c <= 4.3e-110) {
		tmp = t_1;
	} else if (c <= 1.2e-62) {
		tmp = t_2;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 2.5e+99) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = ((a * t) + (i * x)) * -4.0
	t_2 = (b * c) + (-27.0 * (j * k))
	tmp = 0
	if c <= -4.7e-48:
		tmp = t_2
	elif c <= 2.75e-306:
		tmp = t_1
	elif c <= 9.8e-281:
		tmp = t_2
	elif c <= 4.3e-110:
		tmp = t_1
	elif c <= 1.2e-62:
		tmp = t_2
	elif c <= 7.5e+16:
		tmp = t * (x * (18.0 * (y * z)))
	elif c <= 2.5e+99:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0)
	t_2 = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)))
	tmp = 0.0
	if (c <= -4.7e-48)
		tmp = t_2;
	elseif (c <= 2.75e-306)
		tmp = t_1;
	elseif (c <= 9.8e-281)
		tmp = t_2;
	elseif (c <= 4.3e-110)
		tmp = t_1;
	elseif (c <= 1.2e-62)
		tmp = t_2;
	elseif (c <= 7.5e+16)
		tmp = Float64(t * Float64(x * Float64(18.0 * Float64(y * z))));
	elseif (c <= 2.5e+99)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = ((a * t) + (i * x)) * -4.0;
	t_2 = (b * c) + (-27.0 * (j * k));
	tmp = 0.0;
	if (c <= -4.7e-48)
		tmp = t_2;
	elseif (c <= 2.75e-306)
		tmp = t_1;
	elseif (c <= 9.8e-281)
		tmp = t_2;
	elseif (c <= 4.3e-110)
		tmp = t_1;
	elseif (c <= 1.2e-62)
		tmp = t_2;
	elseif (c <= 7.5e+16)
		tmp = t * (x * (18.0 * (y * z)));
	elseif (c <= 2.5e+99)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -4.7e-48], t$95$2, If[LessEqual[c, 2.75e-306], t$95$1, If[LessEqual[c, 9.8e-281], t$95$2, If[LessEqual[c, 4.3e-110], t$95$1, If[LessEqual[c, 1.2e-62], t$95$2, If[LessEqual[c, 7.5e+16], N[(t * N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.5e+99], t$95$1, t$95$2]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if c < -4.6999999999999998e-48 or 2.74999999999999996e-306 < c < 9.7999999999999999e-281 or 4.30000000000000025e-110 < c < 1.19999999999999992e-62 or 2.50000000000000004e99 < c

   1. Initial program 84.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -4.6999999999999998e-48 < c < 2.74999999999999996e-306 or 9.7999999999999999e-281 < c < 4.30000000000000025e-110 or 7.5e16 < c < 2.50000000000000004e99

   1. Initial program 91.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 1.19999999999999992e-62 < c < 7.5e16

   1. Initial program 87.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 10: 49.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := b \cdot c + -27 \cdot \left(j \cdot k\right)\\ t_2 := t \cdot \left(-4 \cdot a\right)\\ \mathbf{if}\;t \leq -1.3 \cdot 10^{+255}:\\ \;\;\;\;t\_2 - \left(j \cdot 27\right) \cdot k\\ \mathbf{elif}\;t \leq -3.5 \cdot 10^{+137}:\\ \;\;\;\;18 \cdot \left(\left(\left(x \cdot z\right) \cdot y\right) \cdot t\right)\\ \mathbf{elif}\;t \leq -1.1 \cdot 10^{-175}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -4.5 \cdot 10^{-256}:\\ \;\;\;\;b \cdot c + x \cdot \left(-4 \cdot i\right)\\ \mathbf{elif}\;t \leq 9.8 \cdot 10^{-297}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.15 \cdot 10^{-70}:\\ \;\;\;\;j \cdot \left(k \cdot -27 - \frac{x \cdot \left(4 \cdot i\right)}{j}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2 + b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (+ (* b c) (* -27.0 (* j k)))) (t_2 (* t (* -4.0 a))))
   (if (<= t -1.3e+255)
     (- t_2 (* (* j 27.0) k))
     (if (<= t -3.5e+137)
       (* 18.0 (* (* (* x z) y) t))
       (if (<= t -1.1e-175)
         t_1
         (if (<= t -4.5e-256)
           (+ (* b c) (* x (* -4.0 i)))
           (if (<= t 9.8e-297)
             t_1
             (if (<= t 2.15e-70)
               (* j (- (* k -27.0) (/ (* x (* 4.0 i)) j)))
               (+ t_2 (* b c))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (-27.0 * (j * k));
	double t_2 = t * (-4.0 * a);
	double tmp;
	if (t <= -1.3e+255) {
		tmp = t_2 - ((j * 27.0) * k);
	} else if (t <= -3.5e+137) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if (t <= -1.1e-175) {
		tmp = t_1;
	} else if (t <= -4.5e-256) {
		tmp = (b * c) + (x * (-4.0 * i));
	} else if (t <= 9.8e-297) {
		tmp = t_1;
	} else if (t <= 2.15e-70) {
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	} else {
		tmp = t_2 + (b * c);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (b * c) + ((-27.0d0) * (j * k))
    t_2 = t * ((-4.0d0) * a)
    if (t <= (-1.3d+255)) then
        tmp = t_2 - ((j * 27.0d0) * k)
    else if (t <= (-3.5d+137)) then
        tmp = 18.0d0 * (((x * z) * y) * t)
    else if (t <= (-1.1d-175)) then
        tmp = t_1
    else if (t <= (-4.5d-256)) then
        tmp = (b * c) + (x * ((-4.0d0) * i))
    else if (t <= 9.8d-297) then
        tmp = t_1
    else if (t <= 2.15d-70) then
        tmp = j * ((k * (-27.0d0)) - ((x * (4.0d0 * i)) / j))
    else
        tmp = t_2 + (b * c)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (-27.0 * (j * k));
	double t_2 = t * (-4.0 * a);
	double tmp;
	if (t <= -1.3e+255) {
		tmp = t_2 - ((j * 27.0) * k);
	} else if (t <= -3.5e+137) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if (t <= -1.1e-175) {
		tmp = t_1;
	} else if (t <= -4.5e-256) {
		tmp = (b * c) + (x * (-4.0 * i));
	} else if (t <= 9.8e-297) {
		tmp = t_1;
	} else if (t <= 2.15e-70) {
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	} else {
		tmp = t_2 + (b * c);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (b * c) + (-27.0 * (j * k))
	t_2 = t * (-4.0 * a)
	tmp = 0
	if t <= -1.3e+255:
		tmp = t_2 - ((j * 27.0) * k)
	elif t <= -3.5e+137:
		tmp = 18.0 * (((x * z) * y) * t)
	elif t <= -1.1e-175:
		tmp = t_1
	elif t <= -4.5e-256:
		tmp = (b * c) + (x * (-4.0 * i))
	elif t <= 9.8e-297:
		tmp = t_1
	elif t <= 2.15e-70:
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j))
	else:
		tmp = t_2 + (b * c)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)))
	t_2 = Float64(t * Float64(-4.0 * a))
	tmp = 0.0
	if (t <= -1.3e+255)
		tmp = Float64(t_2 - Float64(Float64(j * 27.0) * k));
	elseif (t <= -3.5e+137)
		tmp = Float64(18.0 * Float64(Float64(Float64(x * z) * y) * t));
	elseif (t <= -1.1e-175)
		tmp = t_1;
	elseif (t <= -4.5e-256)
		tmp = Float64(Float64(b * c) + Float64(x * Float64(-4.0 * i)));
	elseif (t <= 9.8e-297)
		tmp = t_1;
	elseif (t <= 2.15e-70)
		tmp = Float64(j * Float64(Float64(k * -27.0) - Float64(Float64(x * Float64(4.0 * i)) / j)));
	else
		tmp = Float64(t_2 + Float64(b * c));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (b * c) + (-27.0 * (j * k));
	t_2 = t * (-4.0 * a);
	tmp = 0.0;
	if (t <= -1.3e+255)
		tmp = t_2 - ((j * 27.0) * k);
	elseif (t <= -3.5e+137)
		tmp = 18.0 * (((x * z) * y) * t);
	elseif (t <= -1.1e-175)
		tmp = t_1;
	elseif (t <= -4.5e-256)
		tmp = (b * c) + (x * (-4.0 * i));
	elseif (t <= 9.8e-297)
		tmp = t_1;
	elseif (t <= 2.15e-70)
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	else
		tmp = t_2 + (b * c);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.3e+255], N[(t$95$2 - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.5e+137], N[(18.0 * N[(N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.1e-175], t$95$1, If[LessEqual[t, -4.5e-256], N[(N[(b * c), $MachinePrecision] + N[(x * N[(-4.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.8e-297], t$95$1, If[LessEqual[t, 2.15e-70], N[(j * N[(N[(k * -27.0), $MachinePrecision] - N[(N[(x * N[(4.0 * i), $MachinePrecision]), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$2 + N[(b * c), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if t < -1.30000000000000005e255

   1. Initial program 89.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.30000000000000005e255 < t < -3.5000000000000001e137

   1. Initial program 75.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -3.5000000000000001e137 < t < -1.1e-175 or -4.5000000000000003e-256 < t < 9.79999999999999995e-297

   1. Initial program 91.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -1.1e-175 < t < -4.5000000000000003e-256

   1. Initial program 100.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if 9.79999999999999995e-297 < t < 2.15e-70

   1. Initial program 78.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in j around -inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.15e-70 < t

   1. Initial program 89.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 11: 37.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := j \cdot \left(k \cdot -27\right)\\ \mathbf{if}\;b \cdot c \leq -1.65 \cdot 10^{+184}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -2.7 \cdot 10^{+48}:\\ \;\;\;\;t \cdot \left(-4 \cdot a\right)\\ \mathbf{elif}\;b \cdot c \leq -4 \cdot 10^{-177}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq -5 \cdot 10^{-319}:\\ \;\;\;\;18 \cdot \left(\left(x \cdot y\right) \cdot \left(z \cdot t\right)\right)\\ \mathbf{elif}\;b \cdot c \leq 7.2 \cdot 10^{+47}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* j (* k -27.0))))
   (if (<= (* b c) -1.65e+184)
     (* b c)
     (if (<= (* b c) -2.7e+48)
       (* t (* -4.0 a))
       (if (<= (* b c) -4e-177)
         t_1
         (if (<= (* b c) -5e-319)
           (* 18.0 (* (* x y) (* z t)))
           (if (<= (* b c) 7.2e+47) t_1 (* b c))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = j * (k * -27.0);
	double tmp;
	if ((b * c) <= -1.65e+184) {
		tmp = b * c;
	} else if ((b * c) <= -2.7e+48) {
		tmp = t * (-4.0 * a);
	} else if ((b * c) <= -4e-177) {
		tmp = t_1;
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * ((x * y) * (z * t));
	} else if ((b * c) <= 7.2e+47) {
		tmp = t_1;
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = j * (k * (-27.0d0))
    if ((b * c) <= (-1.65d+184)) then
        tmp = b * c
    else if ((b * c) <= (-2.7d+48)) then
        tmp = t * ((-4.0d0) * a)
    else if ((b * c) <= (-4d-177)) then
        tmp = t_1
    else if ((b * c) <= (-5d-319)) then
        tmp = 18.0d0 * ((x * y) * (z * t))
    else if ((b * c) <= 7.2d+47) then
        tmp = t_1
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = j * (k * -27.0);
	double tmp;
	if ((b * c) <= -1.65e+184) {
		tmp = b * c;
	} else if ((b * c) <= -2.7e+48) {
		tmp = t * (-4.0 * a);
	} else if ((b * c) <= -4e-177) {
		tmp = t_1;
	} else if ((b * c) <= -5e-319) {
		tmp = 18.0 * ((x * y) * (z * t));
	} else if ((b * c) <= 7.2e+47) {
		tmp = t_1;
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = j * (k * -27.0)
	tmp = 0
	if (b * c) <= -1.65e+184:
		tmp = b * c
	elif (b * c) <= -2.7e+48:
		tmp = t * (-4.0 * a)
	elif (b * c) <= -4e-177:
		tmp = t_1
	elif (b * c) <= -5e-319:
		tmp = 18.0 * ((x * y) * (z * t))
	elif (b * c) <= 7.2e+47:
		tmp = t_1
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(j * Float64(k * -27.0))
	tmp = 0.0
	if (Float64(b * c) <= -1.65e+184)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -2.7e+48)
		tmp = Float64(t * Float64(-4.0 * a));
	elseif (Float64(b * c) <= -4e-177)
		tmp = t_1;
	elseif (Float64(b * c) <= -5e-319)
		tmp = Float64(18.0 * Float64(Float64(x * y) * Float64(z * t)));
	elseif (Float64(b * c) <= 7.2e+47)
		tmp = t_1;
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = j * (k * -27.0);
	tmp = 0.0;
	if ((b * c) <= -1.65e+184)
		tmp = b * c;
	elseif ((b * c) <= -2.7e+48)
		tmp = t * (-4.0 * a);
	elseif ((b * c) <= -4e-177)
		tmp = t_1;
	elseif ((b * c) <= -5e-319)
		tmp = 18.0 * ((x * y) * (z * t));
	elseif ((b * c) <= 7.2e+47)
		tmp = t_1;
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -1.65e+184], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -2.7e+48], N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -4e-177], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], -5e-319], N[(18.0 * N[(N[(x * y), $MachinePrecision] * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 7.2e+47], t$95$1, N[(b * c), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if (*.f64 b c) < -1.6499999999999999e184 or 7.20000000000000015e47 < (*.f64 b c)

   1. Initial program 84.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.6499999999999999e184 < (*.f64 b c) < -2.70000000000000004e48

   1. Initial program 95.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.70000000000000004e48 < (*.f64 b c) < -3.99999999999999981e-177 or -4.9999937e-319 < (*.f64 b c) < 7.20000000000000015e47

   1. Initial program 87.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -3.99999999999999981e-177 < (*.f64 b c) < -4.9999937e-319

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 12: 48.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := i \cdot \left(x \cdot -4\right) - \left(k \cdot j\right) \cdot 27\\ t_2 := t \cdot \left(-4 \cdot a\right) + b \cdot c\\ \mathbf{if}\;c \leq -1.08 \cdot 10^{-44}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;c \leq 8.8 \cdot 10^{-134}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 1.95 \cdot 10^{-102}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;c \leq 2.2 \cdot 10^{-61}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 7.5 \cdot 10^{+16}:\\ \;\;\;\;t \cdot \left(x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;c \leq 1.7 \cdot 10^{+99}:\\ \;\;\;\;\left(a \cdot t + i \cdot x\right) \cdot -4\\ \mathbf{else}:\\ \;\;\;\;b \cdot c - \left(j \cdot 27\right) \cdot k\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (- (* i (* x -4.0)) (* (* k j) 27.0)))
        (t_2 (+ (* t (* -4.0 a)) (* b c))))
   (if (<= c -1.08e-44)
     t_2
     (if (<= c 8.8e-134)
       t_1
       (if (<= c 1.95e-102)
         t_2
         (if (<= c 2.2e-61)
           t_1
           (if (<= c 7.5e+16)
             (* t (* x (* 18.0 (* y z))))
             (if (<= c 1.7e+99)
               (* (+ (* a t) (* i x)) -4.0)
               (- (* b c) (* (* j 27.0) k))))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (i * (x * -4.0)) - ((k * j) * 27.0);
	double t_2 = (t * (-4.0 * a)) + (b * c);
	double tmp;
	if (c <= -1.08e-44) {
		tmp = t_2;
	} else if (c <= 8.8e-134) {
		tmp = t_1;
	} else if (c <= 1.95e-102) {
		tmp = t_2;
	} else if (c <= 2.2e-61) {
		tmp = t_1;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 1.7e+99) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - ((j * 27.0) * k);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (i * (x * (-4.0d0))) - ((k * j) * 27.0d0)
    t_2 = (t * ((-4.0d0) * a)) + (b * c)
    if (c <= (-1.08d-44)) then
        tmp = t_2
    else if (c <= 8.8d-134) then
        tmp = t_1
    else if (c <= 1.95d-102) then
        tmp = t_2
    else if (c <= 2.2d-61) then
        tmp = t_1
    else if (c <= 7.5d+16) then
        tmp = t * (x * (18.0d0 * (y * z)))
    else if (c <= 1.7d+99) then
        tmp = ((a * t) + (i * x)) * (-4.0d0)
    else
        tmp = (b * c) - ((j * 27.0d0) * k)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (i * (x * -4.0)) - ((k * j) * 27.0);
	double t_2 = (t * (-4.0 * a)) + (b * c);
	double tmp;
	if (c <= -1.08e-44) {
		tmp = t_2;
	} else if (c <= 8.8e-134) {
		tmp = t_1;
	} else if (c <= 1.95e-102) {
		tmp = t_2;
	} else if (c <= 2.2e-61) {
		tmp = t_1;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 1.7e+99) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - ((j * 27.0) * k);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (i * (x * -4.0)) - ((k * j) * 27.0)
	t_2 = (t * (-4.0 * a)) + (b * c)
	tmp = 0
	if c <= -1.08e-44:
		tmp = t_2
	elif c <= 8.8e-134:
		tmp = t_1
	elif c <= 1.95e-102:
		tmp = t_2
	elif c <= 2.2e-61:
		tmp = t_1
	elif c <= 7.5e+16:
		tmp = t * (x * (18.0 * (y * z)))
	elif c <= 1.7e+99:
		tmp = ((a * t) + (i * x)) * -4.0
	else:
		tmp = (b * c) - ((j * 27.0) * k)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(i * Float64(x * -4.0)) - Float64(Float64(k * j) * 27.0))
	t_2 = Float64(Float64(t * Float64(-4.0 * a)) + Float64(b * c))
	tmp = 0.0
	if (c <= -1.08e-44)
		tmp = t_2;
	elseif (c <= 8.8e-134)
		tmp = t_1;
	elseif (c <= 1.95e-102)
		tmp = t_2;
	elseif (c <= 2.2e-61)
		tmp = t_1;
	elseif (c <= 7.5e+16)
		tmp = Float64(t * Float64(x * Float64(18.0 * Float64(y * z))));
	elseif (c <= 1.7e+99)
		tmp = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0);
	else
		tmp = Float64(Float64(b * c) - Float64(Float64(j * 27.0) * k));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (i * (x * -4.0)) - ((k * j) * 27.0);
	t_2 = (t * (-4.0 * a)) + (b * c);
	tmp = 0.0;
	if (c <= -1.08e-44)
		tmp = t_2;
	elseif (c <= 8.8e-134)
		tmp = t_1;
	elseif (c <= 1.95e-102)
		tmp = t_2;
	elseif (c <= 2.2e-61)
		tmp = t_1;
	elseif (c <= 7.5e+16)
		tmp = t * (x * (18.0 * (y * z)));
	elseif (c <= 1.7e+99)
		tmp = ((a * t) + (i * x)) * -4.0;
	else
		tmp = (b * c) - ((j * 27.0) * k);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - N[(N[(k * j), $MachinePrecision] * 27.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.08e-44], t$95$2, If[LessEqual[c, 8.8e-134], t$95$1, If[LessEqual[c, 1.95e-102], t$95$2, If[LessEqual[c, 2.2e-61], t$95$1, If[LessEqual[c, 7.5e+16], N[(t * N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.7e+99], N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision], N[(N[(b * c), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if c < -1.07999999999999994e-44 or 8.7999999999999999e-134 < c < 1.95e-102

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.07999999999999994e-44 < c < 8.7999999999999999e-134 or 1.95e-102 < c < 2.20000000000000009e-61

   1. Initial program 85.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 2.20000000000000009e-61 < c < 7.5e16

   1. Initial program 87.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 7.5e16 < c < 1.69999999999999992e99

   1. Initial program 99.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 1.69999999999999992e99 < c

   1. Initial program 85.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 13: 48.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := t \cdot \left(-4 \cdot a\right) + b \cdot c\\ t_2 := \left(j \cdot 27\right) \cdot k\\ t_3 := i \cdot \left(x \cdot -4\right) - t\_2\\ \mathbf{if}\;c \leq -4.9 \cdot 10^{-45}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 6.9 \cdot 10^{-134}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;c \leq 4.2 \cdot 10^{-103}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 2.1 \cdot 10^{-61}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;c \leq 8 \cdot 10^{+16}:\\ \;\;\;\;t \cdot \left(x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;c \leq 9.2 \cdot 10^{+98}:\\ \;\;\;\;\left(a \cdot t + i \cdot x\right) \cdot -4\\ \mathbf{else}:\\ \;\;\;\;b \cdot c - t\_2\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (+ (* t (* -4.0 a)) (* b c)))
        (t_2 (* (* j 27.0) k))
        (t_3 (- (* i (* x -4.0)) t_2)))
   (if (<= c -4.9e-45)
     t_1
     (if (<= c 6.9e-134)
       t_3
       (if (<= c 4.2e-103)
         t_1
         (if (<= c 2.1e-61)
           t_3
           (if (<= c 8e+16)
             (* t (* x (* 18.0 (* y z))))
             (if (<= c 9.2e+98)
               (* (+ (* a t) (* i x)) -4.0)
               (- (* b c) t_2)))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (t * (-4.0 * a)) + (b * c);
	double t_2 = (j * 27.0) * k;
	double t_3 = (i * (x * -4.0)) - t_2;
	double tmp;
	if (c <= -4.9e-45) {
		tmp = t_1;
	} else if (c <= 6.9e-134) {
		tmp = t_3;
	} else if (c <= 4.2e-103) {
		tmp = t_1;
	} else if (c <= 2.1e-61) {
		tmp = t_3;
	} else if (c <= 8e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 9.2e+98) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - t_2;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = (t * ((-4.0d0) * a)) + (b * c)
    t_2 = (j * 27.0d0) * k
    t_3 = (i * (x * (-4.0d0))) - t_2
    if (c <= (-4.9d-45)) then
        tmp = t_1
    else if (c <= 6.9d-134) then
        tmp = t_3
    else if (c <= 4.2d-103) then
        tmp = t_1
    else if (c <= 2.1d-61) then
        tmp = t_3
    else if (c <= 8d+16) then
        tmp = t * (x * (18.0d0 * (y * z)))
    else if (c <= 9.2d+98) then
        tmp = ((a * t) + (i * x)) * (-4.0d0)
    else
        tmp = (b * c) - t_2
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (t * (-4.0 * a)) + (b * c);
	double t_2 = (j * 27.0) * k;
	double t_3 = (i * (x * -4.0)) - t_2;
	double tmp;
	if (c <= -4.9e-45) {
		tmp = t_1;
	} else if (c <= 6.9e-134) {
		tmp = t_3;
	} else if (c <= 4.2e-103) {
		tmp = t_1;
	} else if (c <= 2.1e-61) {
		tmp = t_3;
	} else if (c <= 8e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 9.2e+98) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - t_2;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (t * (-4.0 * a)) + (b * c)
	t_2 = (j * 27.0) * k
	t_3 = (i * (x * -4.0)) - t_2
	tmp = 0
	if c <= -4.9e-45:
		tmp = t_1
	elif c <= 6.9e-134:
		tmp = t_3
	elif c <= 4.2e-103:
		tmp = t_1
	elif c <= 2.1e-61:
		tmp = t_3
	elif c <= 8e+16:
		tmp = t * (x * (18.0 * (y * z)))
	elif c <= 9.2e+98:
		tmp = ((a * t) + (i * x)) * -4.0
	else:
		tmp = (b * c) - t_2
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(t * Float64(-4.0 * a)) + Float64(b * c))
	t_2 = Float64(Float64(j * 27.0) * k)
	t_3 = Float64(Float64(i * Float64(x * -4.0)) - t_2)
	tmp = 0.0
	if (c <= -4.9e-45)
		tmp = t_1;
	elseif (c <= 6.9e-134)
		tmp = t_3;
	elseif (c <= 4.2e-103)
		tmp = t_1;
	elseif (c <= 2.1e-61)
		tmp = t_3;
	elseif (c <= 8e+16)
		tmp = Float64(t * Float64(x * Float64(18.0 * Float64(y * z))));
	elseif (c <= 9.2e+98)
		tmp = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0);
	else
		tmp = Float64(Float64(b * c) - t_2);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (t * (-4.0 * a)) + (b * c);
	t_2 = (j * 27.0) * k;
	t_3 = (i * (x * -4.0)) - t_2;
	tmp = 0.0;
	if (c <= -4.9e-45)
		tmp = t_1;
	elseif (c <= 6.9e-134)
		tmp = t_3;
	elseif (c <= 4.2e-103)
		tmp = t_1;
	elseif (c <= 2.1e-61)
		tmp = t_3;
	elseif (c <= 8e+16)
		tmp = t * (x * (18.0 * (y * z)));
	elseif (c <= 9.2e+98)
		tmp = ((a * t) + (i * x)) * -4.0;
	else
		tmp = (b * c) - t_2;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$3 = N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision]}, If[LessEqual[c, -4.9e-45], t$95$1, If[LessEqual[c, 6.9e-134], t$95$3, If[LessEqual[c, 4.2e-103], t$95$1, If[LessEqual[c, 2.1e-61], t$95$3, If[LessEqual[c, 8e+16], N[(t * N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 9.2e+98], N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision], N[(N[(b * c), $MachinePrecision] - t$95$2), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if c < -4.8999999999999998e-45 or 6.9000000000000001e-134 < c < 4.20000000000000009e-103

   1. Initial program 88.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -4.8999999999999998e-45 < c < 6.9000000000000001e-134 or 4.20000000000000009e-103 < c < 2.0999999999999999e-61

   1. Initial program 85.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.0999999999999999e-61 < c < 8e16

   1. Initial program 87.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 8e16 < c < 9.20000000000000053e98

   1. Initial program 99.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 9.20000000000000053e98 < c

   1. Initial program 85.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 14: 74.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t \leq -2.3 \cdot 10^{+139}:\\ \;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + b \cdot c\\ \mathbf{elif}\;t \leq -1.66 \cdot 10^{-68}:\\ \;\;\;\;\left(b \cdot c + t \cdot \left(-4 \cdot a\right)\right) - t\_1\\ \mathbf{elif}\;t \leq -7.2 \cdot 10^{-92}:\\ \;\;\;\;x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + i \cdot -4\right)\\ \mathbf{elif}\;t \leq 102000000:\\ \;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - t\_1\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot x\right) \cdot \left(18 \cdot y\right) + a \cdot -4\right) + b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)))
   (if (<= t -2.3e+139)
     (+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) (* b c))
     (if (<= t -1.66e-68)
       (- (+ (* b c) (* t (* -4.0 a))) t_1)
       (if (<= t -7.2e-92)
         (* x (+ (* (* (* 18.0 t) y) z) (* i -4.0)))
         (if (<= t 102000000.0)
           (- (- (* b c) (* (* x 4.0) i)) t_1)
           (+ (* t (+ (* (* z x) (* 18.0 y)) (* a -4.0))) (* b c))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t <= -2.3e+139) {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	} else if (t <= -1.66e-68) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t <= -7.2e-92) {
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	} else if (t <= 102000000.0) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    if (t <= (-2.3d+139)) then
        tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + (b * c)
    else if (t <= (-1.66d-68)) then
        tmp = ((b * c) + (t * ((-4.0d0) * a))) - t_1
    else if (t <= (-7.2d-92)) then
        tmp = x * ((((18.0d0 * t) * y) * z) + (i * (-4.0d0)))
    else if (t <= 102000000.0d0) then
        tmp = ((b * c) - ((x * 4.0d0) * i)) - t_1
    else
        tmp = (t * (((z * x) * (18.0d0 * y)) + (a * (-4.0d0)))) + (b * c)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t <= -2.3e+139) {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	} else if (t <= -1.66e-68) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t <= -7.2e-92) {
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	} else if (t <= 102000000.0) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	tmp = 0
	if t <= -2.3e+139:
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c)
	elif t <= -1.66e-68:
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1
	elif t <= -7.2e-92:
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0))
	elif t <= 102000000.0:
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1
	else:
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t <= -2.3e+139)
		tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(b * c));
	elseif (t <= -1.66e-68)
		tmp = Float64(Float64(Float64(b * c) + Float64(t * Float64(-4.0 * a))) - t_1);
	elseif (t <= -7.2e-92)
		tmp = Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(i * -4.0)));
	elseif (t <= 102000000.0)
		tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - t_1);
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * x) * Float64(18.0 * y)) + Float64(a * -4.0))) + Float64(b * c));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	tmp = 0.0;
	if (t <= -2.3e+139)
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	elseif (t <= -1.66e-68)
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	elseif (t <= -7.2e-92)
		tmp = x * ((((18.0 * t) * y) * z) + (i * -4.0));
	elseif (t <= 102000000.0)
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	else
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t, -2.3e+139], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.66e-68], N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[t, -7.2e-92], N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 102000000.0], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[(t * N[(N[(N[(z * x), $MachinePrecision] * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if t < -2.3e139

   1. Initial program 80.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.3e139 < t < -1.6600000000000001e-68

   1. Initial program 97.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.6600000000000001e-68 < t < -7.20000000000000032e-92

   1. Initial program 84.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -7.20000000000000032e-92 < t < 1.02e8

   1. Initial program 84.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.02e8 < t

   1. Initial program 89.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 15: 73.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ t_2 := t \cdot \left(\left(z \cdot x\right) \cdot \left(18 \cdot y\right) + a \cdot -4\right) + b \cdot c\\ \mathbf{if}\;t \leq -1.15 \cdot 10^{+139}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t \leq -5.8 \cdot 10^{-129}:\\ \;\;\;\;\left(b \cdot c + t \cdot \left(-4 \cdot a\right)\right) - t\_1\\ \mathbf{elif}\;t \leq -9.8 \cdot 10^{-155}:\\ \;\;\;\;\left(18 \cdot \left(x \cdot \left(y \cdot z\right)\right)\right) \cdot t + b \cdot c\\ \mathbf{elif}\;t \leq 1250000:\\ \;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k))
        (t_2 (+ (* t (+ (* (* z x) (* 18.0 y)) (* a -4.0))) (* b c))))
   (if (<= t -1.15e+139)
     t_2
     (if (<= t -5.8e-129)
       (- (+ (* b c) (* t (* -4.0 a))) t_1)
       (if (<= t -9.8e-155)
         (+ (* (* 18.0 (* x (* y z))) t) (* b c))
         (if (<= t 1250000.0) (- (- (* b c) (* (* x 4.0) i)) t_1) t_2))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	double tmp;
	if (t <= -1.15e+139) {
		tmp = t_2;
	} else if (t <= -5.8e-129) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t <= -9.8e-155) {
		tmp = ((18.0 * (x * (y * z))) * t) + (b * c);
	} else if (t <= 1250000.0) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    t_2 = (t * (((z * x) * (18.0d0 * y)) + (a * (-4.0d0)))) + (b * c)
    if (t <= (-1.15d+139)) then
        tmp = t_2
    else if (t <= (-5.8d-129)) then
        tmp = ((b * c) + (t * ((-4.0d0) * a))) - t_1
    else if (t <= (-9.8d-155)) then
        tmp = ((18.0d0 * (x * (y * z))) * t) + (b * c)
    else if (t <= 1250000.0d0) then
        tmp = ((b * c) - ((x * 4.0d0) * i)) - t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	double tmp;
	if (t <= -1.15e+139) {
		tmp = t_2;
	} else if (t <= -5.8e-129) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t <= -9.8e-155) {
		tmp = ((18.0 * (x * (y * z))) * t) + (b * c);
	} else if (t <= 1250000.0) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	t_2 = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c)
	tmp = 0
	if t <= -1.15e+139:
		tmp = t_2
	elif t <= -5.8e-129:
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1
	elif t <= -9.8e-155:
		tmp = ((18.0 * (x * (y * z))) * t) + (b * c)
	elif t <= 1250000.0:
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1
	else:
		tmp = t_2
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	t_2 = Float64(Float64(t * Float64(Float64(Float64(z * x) * Float64(18.0 * y)) + Float64(a * -4.0))) + Float64(b * c))
	tmp = 0.0
	if (t <= -1.15e+139)
		tmp = t_2;
	elseif (t <= -5.8e-129)
		tmp = Float64(Float64(Float64(b * c) + Float64(t * Float64(-4.0 * a))) - t_1);
	elseif (t <= -9.8e-155)
		tmp = Float64(Float64(Float64(18.0 * Float64(x * Float64(y * z))) * t) + Float64(b * c));
	elseif (t <= 1250000.0)
		tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - t_1);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	t_2 = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	tmp = 0.0;
	if (t <= -1.15e+139)
		tmp = t_2;
	elseif (t <= -5.8e-129)
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	elseif (t <= -9.8e-155)
		tmp = ((18.0 * (x * (y * z))) * t) + (b * c);
	elseif (t <= 1250000.0)
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(N[(N[(z * x), $MachinePrecision] * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.15e+139], t$95$2, If[LessEqual[t, -5.8e-129], N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[t, -9.8e-155], N[(N[(N[(18.0 * N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1250000.0], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], t$95$2]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -1.15e139 or 1.25e6 < t

   1. Initial program 85.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -1.15e139 < t < -5.80000000000000034e-129

   1. Initial program 94.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -5.80000000000000034e-129 < t < -9.80000000000000026e-155

   1. Initial program 75.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -9.80000000000000026e-155 < t < 1.25e6

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 16: 49.1% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(a \cdot t + i \cdot x\right) \cdot -4\\ \mathbf{if}\;b \cdot c \leq -4.5 \cdot 10^{+186}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -9500000000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \cdot c \leq -6.7 \cdot 10^{-102}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;b \cdot c \leq 6.5 \cdot 10^{+100}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (+ (* a t) (* i x)) -4.0)))
   (if (<= (* b c) -4.5e+186)
     (* b c)
     (if (<= (* b c) -9500000000.0)
       t_1
       (if (<= (* b c) -6.7e-102)
         (* (* j k) -27.0)
         (if (<= (* b c) 6.5e+100) t_1 (* b c)))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * -4.0;
	double tmp;
	if ((b * c) <= -4.5e+186) {
		tmp = b * c;
	} else if ((b * c) <= -9500000000.0) {
		tmp = t_1;
	} else if ((b * c) <= -6.7e-102) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 6.5e+100) {
		tmp = t_1;
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = ((a * t) + (i * x)) * (-4.0d0)
    if ((b * c) <= (-4.5d+186)) then
        tmp = b * c
    else if ((b * c) <= (-9500000000.0d0)) then
        tmp = t_1
    else if ((b * c) <= (-6.7d-102)) then
        tmp = (j * k) * (-27.0d0)
    else if ((b * c) <= 6.5d+100) then
        tmp = t_1
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * -4.0;
	double tmp;
	if ((b * c) <= -4.5e+186) {
		tmp = b * c;
	} else if ((b * c) <= -9500000000.0) {
		tmp = t_1;
	} else if ((b * c) <= -6.7e-102) {
		tmp = (j * k) * -27.0;
	} else if ((b * c) <= 6.5e+100) {
		tmp = t_1;
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = ((a * t) + (i * x)) * -4.0
	tmp = 0
	if (b * c) <= -4.5e+186:
		tmp = b * c
	elif (b * c) <= -9500000000.0:
		tmp = t_1
	elif (b * c) <= -6.7e-102:
		tmp = (j * k) * -27.0
	elif (b * c) <= 6.5e+100:
		tmp = t_1
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0)
	tmp = 0.0
	if (Float64(b * c) <= -4.5e+186)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -9500000000.0)
		tmp = t_1;
	elseif (Float64(b * c) <= -6.7e-102)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (Float64(b * c) <= 6.5e+100)
		tmp = t_1;
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = ((a * t) + (i * x)) * -4.0;
	tmp = 0.0;
	if ((b * c) <= -4.5e+186)
		tmp = b * c;
	elseif ((b * c) <= -9500000000.0)
		tmp = t_1;
	elseif ((b * c) <= -6.7e-102)
		tmp = (j * k) * -27.0;
	elseif ((b * c) <= 6.5e+100)
		tmp = t_1;
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -4.5e+186], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -9500000000.0], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], -6.7e-102], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 6.5e+100], t$95$1, N[(b * c), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 b c) < -4.50000000000000045e186 or 6.50000000000000001e100 < (*.f64 b c)

   1. Initial program 85.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -4.50000000000000045e186 < (*.f64 b c) < -9.5e9 or -6.7e-102 < (*.f64 b c) < 6.50000000000000001e100

   1. Initial program 87.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if -9.5e9 < (*.f64 b c) < -6.7e-102

   1. Initial program 89.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

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

Alternative 17: 53.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := b \cdot c + -27 \cdot \left(j \cdot k\right)\\ t_2 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t\_2 \leq -5 \cdot 10^{+108}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_2 \leq 10^{+96}:\\ \;\;\;\;t \cdot \left(-4 \cdot a\right) + b \cdot c\\ \mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+239}:\\ \;\;\;\;18 \cdot \left(\left(x \cdot y\right) \cdot \left(z \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (+ (* b c) (* -27.0 (* j k)))) (t_2 (* (* j 27.0) k)))
   (if (<= t_2 -5e+108)
     t_1
     (if (<= t_2 1e+96)
       (+ (* t (* -4.0 a)) (* b c))
       (if (<= t_2 5e+239) (* 18.0 (* (* x y) (* z t))) t_1)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (-27.0 * (j * k));
	double t_2 = (j * 27.0) * k;
	double tmp;
	if (t_2 <= -5e+108) {
		tmp = t_1;
	} else if (t_2 <= 1e+96) {
		tmp = (t * (-4.0 * a)) + (b * c);
	} else if (t_2 <= 5e+239) {
		tmp = 18.0 * ((x * y) * (z * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (b * c) + ((-27.0d0) * (j * k))
    t_2 = (j * 27.0d0) * k
    if (t_2 <= (-5d+108)) then
        tmp = t_1
    else if (t_2 <= 1d+96) then
        tmp = (t * ((-4.0d0) * a)) + (b * c)
    else if (t_2 <= 5d+239) then
        tmp = 18.0d0 * ((x * y) * (z * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (-27.0 * (j * k));
	double t_2 = (j * 27.0) * k;
	double tmp;
	if (t_2 <= -5e+108) {
		tmp = t_1;
	} else if (t_2 <= 1e+96) {
		tmp = (t * (-4.0 * a)) + (b * c);
	} else if (t_2 <= 5e+239) {
		tmp = 18.0 * ((x * y) * (z * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (b * c) + (-27.0 * (j * k))
	t_2 = (j * 27.0) * k
	tmp = 0
	if t_2 <= -5e+108:
		tmp = t_1
	elif t_2 <= 1e+96:
		tmp = (t * (-4.0 * a)) + (b * c)
	elif t_2 <= 5e+239:
		tmp = 18.0 * ((x * y) * (z * t))
	else:
		tmp = t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)))
	t_2 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t_2 <= -5e+108)
		tmp = t_1;
	elseif (t_2 <= 1e+96)
		tmp = Float64(Float64(t * Float64(-4.0 * a)) + Float64(b * c));
	elseif (t_2 <= 5e+239)
		tmp = Float64(18.0 * Float64(Float64(x * y) * Float64(z * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (b * c) + (-27.0 * (j * k));
	t_2 = (j * 27.0) * k;
	tmp = 0.0;
	if (t_2 <= -5e+108)
		tmp = t_1;
	elseif (t_2 <= 1e+96)
		tmp = (t * (-4.0 * a)) + (b * c);
	elseif (t_2 <= 5e+239)
		tmp = 18.0 * ((x * y) * (z * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+108], t$95$1, If[LessEqual[t$95$2, 1e+96], N[(N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e+239], N[(18.0 * N[(N[(x * y), $MachinePrecision] * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -4.99999999999999991e108 or 5.00000000000000007e239 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 83.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -4.99999999999999991e108 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.00000000000000005e96

   1. Initial program 89.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 1.00000000000000005e96 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 5.00000000000000007e239

   1. Initial program 85.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 18: 49.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ t_2 := t \cdot \left(-4 \cdot a\right)\\ \mathbf{if}\;c \leq -1.12 \cdot 10^{-48}:\\ \;\;\;\;t\_2 + b \cdot c\\ \mathbf{elif}\;c \leq -6.5 \cdot 10^{-290}:\\ \;\;\;\;i \cdot \left(x \cdot -4\right) - t\_1\\ \mathbf{elif}\;c \leq 2.2 \cdot 10^{-61}:\\ \;\;\;\;t\_2 - t\_1\\ \mathbf{elif}\;c \leq 7.5 \cdot 10^{+16}:\\ \;\;\;\;t \cdot \left(x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\ \mathbf{elif}\;c \leq 9.5 \cdot 10^{+98}:\\ \;\;\;\;\left(a \cdot t + i \cdot x\right) \cdot -4\\ \mathbf{else}:\\ \;\;\;\;b \cdot c - t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)) (t_2 (* t (* -4.0 a))))
   (if (<= c -1.12e-48)
     (+ t_2 (* b c))
     (if (<= c -6.5e-290)
       (- (* i (* x -4.0)) t_1)
       (if (<= c 2.2e-61)
         (- t_2 t_1)
         (if (<= c 7.5e+16)
           (* t (* x (* 18.0 (* y z))))
           (if (<= c 9.5e+98)
             (* (+ (* a t) (* i x)) -4.0)
             (- (* b c) t_1))))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = t * (-4.0 * a);
	double tmp;
	if (c <= -1.12e-48) {
		tmp = t_2 + (b * c);
	} else if (c <= -6.5e-290) {
		tmp = (i * (x * -4.0)) - t_1;
	} else if (c <= 2.2e-61) {
		tmp = t_2 - t_1;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 9.5e+98) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    t_2 = t * ((-4.0d0) * a)
    if (c <= (-1.12d-48)) then
        tmp = t_2 + (b * c)
    else if (c <= (-6.5d-290)) then
        tmp = (i * (x * (-4.0d0))) - t_1
    else if (c <= 2.2d-61) then
        tmp = t_2 - t_1
    else if (c <= 7.5d+16) then
        tmp = t * (x * (18.0d0 * (y * z)))
    else if (c <= 9.5d+98) then
        tmp = ((a * t) + (i * x)) * (-4.0d0)
    else
        tmp = (b * c) - t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = t * (-4.0 * a);
	double tmp;
	if (c <= -1.12e-48) {
		tmp = t_2 + (b * c);
	} else if (c <= -6.5e-290) {
		tmp = (i * (x * -4.0)) - t_1;
	} else if (c <= 2.2e-61) {
		tmp = t_2 - t_1;
	} else if (c <= 7.5e+16) {
		tmp = t * (x * (18.0 * (y * z)));
	} else if (c <= 9.5e+98) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else {
		tmp = (b * c) - t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	t_2 = t * (-4.0 * a)
	tmp = 0
	if c <= -1.12e-48:
		tmp = t_2 + (b * c)
	elif c <= -6.5e-290:
		tmp = (i * (x * -4.0)) - t_1
	elif c <= 2.2e-61:
		tmp = t_2 - t_1
	elif c <= 7.5e+16:
		tmp = t * (x * (18.0 * (y * z)))
	elif c <= 9.5e+98:
		tmp = ((a * t) + (i * x)) * -4.0
	else:
		tmp = (b * c) - t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	t_2 = Float64(t * Float64(-4.0 * a))
	tmp = 0.0
	if (c <= -1.12e-48)
		tmp = Float64(t_2 + Float64(b * c));
	elseif (c <= -6.5e-290)
		tmp = Float64(Float64(i * Float64(x * -4.0)) - t_1);
	elseif (c <= 2.2e-61)
		tmp = Float64(t_2 - t_1);
	elseif (c <= 7.5e+16)
		tmp = Float64(t * Float64(x * Float64(18.0 * Float64(y * z))));
	elseif (c <= 9.5e+98)
		tmp = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0);
	else
		tmp = Float64(Float64(b * c) - t_1);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	t_2 = t * (-4.0 * a);
	tmp = 0.0;
	if (c <= -1.12e-48)
		tmp = t_2 + (b * c);
	elseif (c <= -6.5e-290)
		tmp = (i * (x * -4.0)) - t_1;
	elseif (c <= 2.2e-61)
		tmp = t_2 - t_1;
	elseif (c <= 7.5e+16)
		tmp = t * (x * (18.0 * (y * z)));
	elseif (c <= 9.5e+98)
		tmp = ((a * t) + (i * x)) * -4.0;
	else
		tmp = (b * c) - t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.12e-48], N[(t$95$2 + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -6.5e-290], N[(N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[c, 2.2e-61], N[(t$95$2 - t$95$1), $MachinePrecision], If[LessEqual[c, 7.5e+16], N[(t * N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 9.5e+98], N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision], N[(N[(b * c), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if c < -1.11999999999999999e-48

   1. Initial program 86.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.11999999999999999e-48 < c < -6.4999999999999997e-290

   1. Initial program 89.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.4999999999999997e-290 < c < 2.20000000000000009e-61

   1. Initial program 84.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.20000000000000009e-61 < c < 7.5e16

   1. Initial program 87.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 7.5e16 < c < 9.5000000000000001e98

   1. Initial program 99.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 9.5000000000000001e98 < c

   1. Initial program 85.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 19: 50.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := b \cdot c + x \cdot \left(-4 \cdot i\right)\\ t_2 := b \cdot c + -27 \cdot \left(j \cdot k\right)\\ \mathbf{if}\;k \leq -6.2 \cdot 10^{-48}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;k \leq -3.3 \cdot 10^{-219}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;k \leq 3.65 \cdot 10^{-241}:\\ \;\;\;\;\left(a \cdot t + i \cdot x\right) \cdot -4\\ \mathbf{elif}\;k \leq 9 \cdot 10^{-136}:\\ \;\;\;\;18 \cdot \left(\left(\left(x \cdot z\right) \cdot y\right) \cdot t\right)\\ \mathbf{elif}\;k \leq 2.6 \cdot 10^{+25}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (+ (* b c) (* x (* -4.0 i)))) (t_2 (+ (* b c) (* -27.0 (* j k)))))
   (if (<= k -6.2e-48)
     t_2
     (if (<= k -3.3e-219)
       t_1
       (if (<= k 3.65e-241)
         (* (+ (* a t) (* i x)) -4.0)
         (if (<= k 9e-136)
           (* 18.0 (* (* (* x z) y) t))
           (if (<= k 2.6e+25) t_1 t_2)))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (x * (-4.0 * i));
	double t_2 = (b * c) + (-27.0 * (j * k));
	double tmp;
	if (k <= -6.2e-48) {
		tmp = t_2;
	} else if (k <= -3.3e-219) {
		tmp = t_1;
	} else if (k <= 3.65e-241) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else if (k <= 9e-136) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if (k <= 2.6e+25) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (b * c) + (x * ((-4.0d0) * i))
    t_2 = (b * c) + ((-27.0d0) * (j * k))
    if (k <= (-6.2d-48)) then
        tmp = t_2
    else if (k <= (-3.3d-219)) then
        tmp = t_1
    else if (k <= 3.65d-241) then
        tmp = ((a * t) + (i * x)) * (-4.0d0)
    else if (k <= 9d-136) then
        tmp = 18.0d0 * (((x * z) * y) * t)
    else if (k <= 2.6d+25) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) + (x * (-4.0 * i));
	double t_2 = (b * c) + (-27.0 * (j * k));
	double tmp;
	if (k <= -6.2e-48) {
		tmp = t_2;
	} else if (k <= -3.3e-219) {
		tmp = t_1;
	} else if (k <= 3.65e-241) {
		tmp = ((a * t) + (i * x)) * -4.0;
	} else if (k <= 9e-136) {
		tmp = 18.0 * (((x * z) * y) * t);
	} else if (k <= 2.6e+25) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (b * c) + (x * (-4.0 * i))
	t_2 = (b * c) + (-27.0 * (j * k))
	tmp = 0
	if k <= -6.2e-48:
		tmp = t_2
	elif k <= -3.3e-219:
		tmp = t_1
	elif k <= 3.65e-241:
		tmp = ((a * t) + (i * x)) * -4.0
	elif k <= 9e-136:
		tmp = 18.0 * (((x * z) * y) * t)
	elif k <= 2.6e+25:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(b * c) + Float64(x * Float64(-4.0 * i)))
	t_2 = Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)))
	tmp = 0.0
	if (k <= -6.2e-48)
		tmp = t_2;
	elseif (k <= -3.3e-219)
		tmp = t_1;
	elseif (k <= 3.65e-241)
		tmp = Float64(Float64(Float64(a * t) + Float64(i * x)) * -4.0);
	elseif (k <= 9e-136)
		tmp = Float64(18.0 * Float64(Float64(Float64(x * z) * y) * t));
	elseif (k <= 2.6e+25)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (b * c) + (x * (-4.0 * i));
	t_2 = (b * c) + (-27.0 * (j * k));
	tmp = 0.0;
	if (k <= -6.2e-48)
		tmp = t_2;
	elseif (k <= -3.3e-219)
		tmp = t_1;
	elseif (k <= 3.65e-241)
		tmp = ((a * t) + (i * x)) * -4.0;
	elseif (k <= 9e-136)
		tmp = 18.0 * (((x * z) * y) * t);
	elseif (k <= 2.6e+25)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] + N[(x * N[(-4.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -6.2e-48], t$95$2, If[LessEqual[k, -3.3e-219], t$95$1, If[LessEqual[k, 3.65e-241], N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision], If[LessEqual[k, 9e-136], N[(18.0 * N[(N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.6e+25], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if k < -6.20000000000000033e-48 or 2.5999999999999998e25 < k

   1. Initial program 85.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -6.20000000000000033e-48 < k < -3.3000000000000002e-219 or 8.99999999999999944e-136 < k < 2.5999999999999998e25

   1. Initial program 89.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -3.3000000000000002e-219 < k < 3.64999999999999989e-241

   1. Initial program 92.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in b around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 3.64999999999999989e-241 < k < 8.99999999999999944e-136

   1. Initial program 84.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 20: 89.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := b \cdot c - \left(\left(x \cdot 4\right) \cdot i + j \cdot \left(27 \cdot k\right)\right)\\ \mathbf{if}\;y \leq -1 \cdot 10^{-135}:\\ \;\;\;\;t \cdot \left(\left(z \cdot \left(x \cdot 18\right)\right) \cdot y + a \cdot -4\right) + t\_1\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (- (* b c) (+ (* (* x 4.0) i) (* j (* 27.0 k))))))
   (if (<= y -1e-135)
     (+ (* t (+ (* (* z (* x 18.0)) y) (* a -4.0))) t_1)
     (+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) t_1))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) - (((x * 4.0) * i) + (j * (27.0 * k)));
	double tmp;
	if (y <= -1e-135) {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + t_1;
	} else {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (b * c) - (((x * 4.0d0) * i) + (j * (27.0d0 * k)))
    if (y <= (-1d-135)) then
        tmp = (t * (((z * (x * 18.0d0)) * y) + (a * (-4.0d0)))) + t_1
    else
        tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (b * c) - (((x * 4.0) * i) + (j * (27.0 * k)));
	double tmp;
	if (y <= -1e-135) {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + t_1;
	} else {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (b * c) - (((x * 4.0) * i) + (j * (27.0 * k)))
	tmp = 0
	if y <= -1e-135:
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + t_1
	else:
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(b * c) - Float64(Float64(Float64(x * 4.0) * i) + Float64(j * Float64(27.0 * k))))
	tmp = 0.0
	if (y <= -1e-135)
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * Float64(x * 18.0)) * y) + Float64(a * -4.0))) + t_1);
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + t_1);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (b * c) - (((x * 4.0) * i) + (j * (27.0 * k)));
	tmp = 0.0;
	if (y <= -1e-135)
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + t_1;
	else
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] - N[(N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision] + N[(j * N[(27.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1e-135], N[(N[(t * N[(N[(N[(z * N[(x * 18.0), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if y < -1e-135

   1. Initial program 86.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   if -1e-135 < y

   1. Initial program 87.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

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

Alternative 21: 89.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;x \leq -1.6 \cdot 10^{+94}:\\ \;\;\;\;\left(b \cdot c + x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + i \cdot -4\right)\right) - \left(j \cdot 27\right) \cdot k\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot \left(x \cdot 18\right)\right) \cdot y + a \cdot -4\right) + \left(b \cdot c - \left(\left(x \cdot 4\right) \cdot i + j \cdot \left(27 \cdot k\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= x -1.6e+94)
   (- (+ (* b c) (* x (+ (* (* (* 18.0 t) y) z) (* i -4.0)))) (* (* j 27.0) k))
   (+
    (* t (+ (* (* z (* x 18.0)) y) (* a -4.0)))
    (- (* b c) (+ (* (* x 4.0) i) (* j (* 27.0 k)))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (x <= -1.6e+94) {
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	} else {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (x <= (-1.6d+94)) then
        tmp = ((b * c) + (x * ((((18.0d0 * t) * y) * z) + (i * (-4.0d0))))) - ((j * 27.0d0) * k)
    else
        tmp = (t * (((z * (x * 18.0d0)) * y) + (a * (-4.0d0)))) + ((b * c) - (((x * 4.0d0) * i) + (j * (27.0d0 * k))))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (x <= -1.6e+94) {
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	} else {
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if x <= -1.6e+94:
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k)
	else:
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (x <= -1.6e+94)
		tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(i * -4.0)))) - Float64(Float64(j * 27.0) * k));
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * Float64(x * 18.0)) * y) + Float64(a * -4.0))) + Float64(Float64(b * c) - Float64(Float64(Float64(x * 4.0) * i) + Float64(j * Float64(27.0 * k)))));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (x <= -1.6e+94)
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	else
		tmp = (t * (((z * (x * 18.0)) * y) + (a * -4.0))) + ((b * c) - (((x * 4.0) * i) + (j * (27.0 * k))));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[x, -1.6e+94], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(z * N[(x * 18.0), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] - N[(N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision] + N[(j * N[(27.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -1.60000000000000007e94

   1. Initial program 65.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.60000000000000007e94 < x

   1. Initial program 90.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

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

Alternative 22: 81.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;z \leq -9.5 \cdot 10^{-12}:\\ \;\;\;\;\left(18 \cdot \left(\left(t \cdot y\right) \cdot z\right) + -4 \cdot i\right) \cdot x\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{+57}:\\ \;\;\;\;b \cdot c + \left(j \cdot \left(k \cdot -27\right) + -4 \cdot \left(x \cdot i + t \cdot a\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(b \cdot c + x \cdot \left(\left(\left(18 \cdot t\right) \cdot y\right) \cdot z + i \cdot -4\right)\right) - \left(j \cdot 27\right) \cdot k\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= z -9.5e-12)
   (* (+ (* 18.0 (* (* t y) z)) (* -4.0 i)) x)
   (if (<= z 7.2e+57)
     (+ (* b c) (+ (* j (* k -27.0)) (* -4.0 (+ (* x i) (* t a)))))
     (-
      (+ (* b c) (* x (+ (* (* (* 18.0 t) y) z) (* i -4.0))))
      (* (* j 27.0) k)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (z <= -9.5e-12) {
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	} else if (z <= 7.2e+57) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (z <= (-9.5d-12)) then
        tmp = ((18.0d0 * ((t * y) * z)) + ((-4.0d0) * i)) * x
    else if (z <= 7.2d+57) then
        tmp = (b * c) + ((j * (k * (-27.0d0))) + ((-4.0d0) * ((x * i) + (t * a))))
    else
        tmp = ((b * c) + (x * ((((18.0d0 * t) * y) * z) + (i * (-4.0d0))))) - ((j * 27.0d0) * k)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (z <= -9.5e-12) {
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	} else if (z <= 7.2e+57) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if z <= -9.5e-12:
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x
	elif z <= 7.2e+57:
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))))
	else:
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (z <= -9.5e-12)
		tmp = Float64(Float64(Float64(18.0 * Float64(Float64(t * y) * z)) + Float64(-4.0 * i)) * x);
	elseif (z <= 7.2e+57)
		tmp = Float64(Float64(b * c) + Float64(Float64(j * Float64(k * -27.0)) + Float64(-4.0 * Float64(Float64(x * i) + Float64(t * a)))));
	else
		tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(Float64(Float64(18.0 * t) * y) * z) + Float64(i * -4.0)))) - Float64(Float64(j * 27.0) * k));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (z <= -9.5e-12)
		tmp = ((18.0 * ((t * y) * z)) + (-4.0 * i)) * x;
	elseif (z <= 7.2e+57)
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	else
		tmp = ((b * c) + (x * ((((18.0 * t) * y) * z) + (i * -4.0)))) - ((j * 27.0) * k);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[z, -9.5e-12], N[(N[(N[(18.0 * N[(N[(t * y), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * i), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 7.2e+57], N[(N[(b * c), $MachinePrecision] + N[(N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(N[(x * i), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(N[(N[(18.0 * t), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -9.4999999999999995e-12

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -9.4999999999999995e-12 < z < 7.2000000000000005e57

   1. Initial program 86.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 7.2000000000000005e57 < z

   1. Initial program 92.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 23: 70.4% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t\_1 \leq -5 \cdot 10^{+108}:\\ \;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - t\_1\\ \mathbf{elif}\;t\_1 \leq 10^{+96}:\\ \;\;\;\;b \cdot c + -4 \cdot \left(a \cdot t + i \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;18 \cdot \left(\left(z \cdot \left(x \cdot y\right)\right) \cdot t\right) - t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)))
   (if (<= t_1 -5e+108)
     (- (- (* b c) (* (* x 4.0) i)) t_1)
     (if (<= t_1 1e+96)
       (+ (* b c) (* -4.0 (+ (* a t) (* i x))))
       (- (* 18.0 (* (* z (* x y)) t)) t_1)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -5e+108) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    if (t_1 <= (-5d+108)) then
        tmp = ((b * c) - ((x * 4.0d0) * i)) - t_1
    else if (t_1 <= 1d+96) then
        tmp = (b * c) + ((-4.0d0) * ((a * t) + (i * x)))
    else
        tmp = (18.0d0 * ((z * (x * y)) * t)) - t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -5e+108) {
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	tmp = 0
	if t_1 <= -5e+108:
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1
	elif t_1 <= 1e+96:
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)))
	else:
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t_1 <= -5e+108)
		tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - t_1);
	elseif (t_1 <= 1e+96)
		tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(a * t) + Float64(i * x))));
	else
		tmp = Float64(Float64(18.0 * Float64(Float64(z * Float64(x * y)) * t)) - t_1);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	tmp = 0.0;
	if (t_1 <= -5e+108)
		tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
	elseif (t_1 <= 1e+96)
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	else
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+108], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[t$95$1, 1e+96], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(18.0 * N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -4.99999999999999991e108

   1. Initial program 83.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.99999999999999991e108 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.00000000000000005e96

   1. Initial program 89.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if 1.00000000000000005e96 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 24: 70.4% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t\_1 \leq -2 \cdot 10^{+120}:\\ \;\;\;\;\left(b \cdot c + t \cdot \left(-4 \cdot a\right)\right) - t\_1\\ \mathbf{elif}\;t\_1 \leq 10^{+96}:\\ \;\;\;\;b \cdot c + -4 \cdot \left(a \cdot t + i \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;18 \cdot \left(\left(z \cdot \left(x \cdot y\right)\right) \cdot t\right) - t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)))
   (if (<= t_1 -2e+120)
     (- (+ (* b c) (* t (* -4.0 a))) t_1)
     (if (<= t_1 1e+96)
       (+ (* b c) (* -4.0 (+ (* a t) (* i x))))
       (- (* 18.0 (* (* z (* x y)) t)) t_1)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -2e+120) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    if (t_1 <= (-2d+120)) then
        tmp = ((b * c) + (t * ((-4.0d0) * a))) - t_1
    else if (t_1 <= 1d+96) then
        tmp = (b * c) + ((-4.0d0) * ((a * t) + (i * x)))
    else
        tmp = (18.0d0 * ((z * (x * y)) * t)) - t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -2e+120) {
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	tmp = 0
	if t_1 <= -2e+120:
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1
	elif t_1 <= 1e+96:
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)))
	else:
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t_1 <= -2e+120)
		tmp = Float64(Float64(Float64(b * c) + Float64(t * Float64(-4.0 * a))) - t_1);
	elseif (t_1 <= 1e+96)
		tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(a * t) + Float64(i * x))));
	else
		tmp = Float64(Float64(18.0 * Float64(Float64(z * Float64(x * y)) * t)) - t_1);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	tmp = 0.0;
	if (t_1 <= -2e+120)
		tmp = ((b * c) + (t * (-4.0 * a))) - t_1;
	elseif (t_1 <= 1e+96)
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	else
		tmp = (18.0 * ((z * (x * y)) * t)) - t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+120], N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[t$95$1, 1e+96], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(18.0 * N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2e120

   1. Initial program 82.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2e120 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.00000000000000005e96

   1. Initial program 89.4%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if 1.00000000000000005e96 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 84.8%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 25: 68.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ t_2 := 18 \cdot \left(\left(z \cdot \left(x \cdot y\right)\right) \cdot t\right) - t\_1\\ \mathbf{if}\;t\_1 \leq -2 \cdot 10^{+251}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_1 \leq 10^{+96}:\\ \;\;\;\;b \cdot c + -4 \cdot \left(a \cdot t + i \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)) (t_2 (- (* 18.0 (* (* z (* x y)) t)) t_1)))
   (if (<= t_1 -2e+251)
     t_2
     (if (<= t_1 1e+96) (+ (* b c) (* -4.0 (+ (* a t) (* i x)))) t_2))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = (18.0 * ((z * (x * y)) * t)) - t_1;
	double tmp;
	if (t_1 <= -2e+251) {
		tmp = t_2;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    t_2 = (18.0d0 * ((z * (x * y)) * t)) - t_1
    if (t_1 <= (-2d+251)) then
        tmp = t_2
    else if (t_1 <= 1d+96) then
        tmp = (b * c) + ((-4.0d0) * ((a * t) + (i * x)))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double t_2 = (18.0 * ((z * (x * y)) * t)) - t_1;
	double tmp;
	if (t_1 <= -2e+251) {
		tmp = t_2;
	} else if (t_1 <= 1e+96) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	t_2 = (18.0 * ((z * (x * y)) * t)) - t_1
	tmp = 0
	if t_1 <= -2e+251:
		tmp = t_2
	elif t_1 <= 1e+96:
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)))
	else:
		tmp = t_2
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	t_2 = Float64(Float64(18.0 * Float64(Float64(z * Float64(x * y)) * t)) - t_1)
	tmp = 0.0
	if (t_1 <= -2e+251)
		tmp = t_2;
	elseif (t_1 <= 1e+96)
		tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(a * t) + Float64(i * x))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	t_2 = (18.0 * ((z * (x * y)) * t)) - t_1;
	tmp = 0.0;
	if (t_1 <= -2e+251)
		tmp = t_2;
	elseif (t_1 <= 1e+96)
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(N[(18.0 * N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+251], t$95$2, If[LessEqual[t$95$1, 1e+96], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2.0000000000000001e251 or 1.00000000000000005e96 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 81.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.0000000000000001e251 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.00000000000000005e96

   1. Initial program 89.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

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

Alternative 26: 69.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{+274}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;t\_1 \leq 10^{+110}:\\ \;\;\;\;b \cdot c + -4 \cdot \left(a \cdot t + i \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;-4 \cdot \left(x \cdot i + t \cdot a\right) - t\_1\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)))
   (if (<= t_1 -1e+274)
     (* (* j k) -27.0)
     (if (<= t_1 1e+110)
       (+ (* b c) (* -4.0 (+ (* a t) (* i x))))
       (- (* -4.0 (+ (* x i) (* t a))) t_1)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -1e+274) {
		tmp = (j * k) * -27.0;
	} else if (t_1 <= 1e+110) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (-4.0 * ((x * i) + (t * a))) - t_1;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    if (t_1 <= (-1d+274)) then
        tmp = (j * k) * (-27.0d0)
    else if (t_1 <= 1d+110) then
        tmp = (b * c) + ((-4.0d0) * ((a * t) + (i * x)))
    else
        tmp = ((-4.0d0) * ((x * i) + (t * a))) - t_1
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -1e+274) {
		tmp = (j * k) * -27.0;
	} else if (t_1 <= 1e+110) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = (-4.0 * ((x * i) + (t * a))) - t_1;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	tmp = 0
	if t_1 <= -1e+274:
		tmp = (j * k) * -27.0
	elif t_1 <= 1e+110:
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)))
	else:
		tmp = (-4.0 * ((x * i) + (t * a))) - t_1
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t_1 <= -1e+274)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (t_1 <= 1e+110)
		tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(a * t) + Float64(i * x))));
	else
		tmp = Float64(Float64(-4.0 * Float64(Float64(x * i) + Float64(t * a))) - t_1);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	tmp = 0.0;
	if (t_1 <= -1e+274)
		tmp = (j * k) * -27.0;
	elseif (t_1 <= 1e+110)
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	else
		tmp = (-4.0 * ((x * i) + (t * a))) - t_1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+274], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+110], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(-4.0 * N[(N[(x * i), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -9.99999999999999921e273

   1. Initial program 70.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if -9.99999999999999921e273 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1e110

   1. Initial program 89.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if 1e110 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 27: 68.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} t_1 := \left(j \cdot 27\right) \cdot k\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{+274}:\\ \;\;\;\;\left(j \cdot k\right) \cdot -27\\ \mathbf{elif}\;t\_1 \leq 10^{+110}:\\ \;\;\;\;b \cdot c + -4 \cdot \left(a \cdot t + i \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(k \cdot -27 - \frac{x \cdot \left(4 \cdot i\right)}{j}\right)\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (* j 27.0) k)))
   (if (<= t_1 -1e+274)
     (* (* j k) -27.0)
     (if (<= t_1 1e+110)
       (+ (* b c) (* -4.0 (+ (* a t) (* i x))))
       (* j (- (* k -27.0) (/ (* x (* 4.0 i)) j)))))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -1e+274) {
		tmp = (j * k) * -27.0;
	} else if (t_1 <= 1e+110) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (j * 27.0d0) * k
    if (t_1 <= (-1d+274)) then
        tmp = (j * k) * (-27.0d0)
    else if (t_1 <= 1d+110) then
        tmp = (b * c) + ((-4.0d0) * ((a * t) + (i * x)))
    else
        tmp = j * ((k * (-27.0d0)) - ((x * (4.0d0 * i)) / j))
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = (j * 27.0) * k;
	double tmp;
	if (t_1 <= -1e+274) {
		tmp = (j * k) * -27.0;
	} else if (t_1 <= 1e+110) {
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	} else {
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = (j * 27.0) * k
	tmp = 0
	if t_1 <= -1e+274:
		tmp = (j * k) * -27.0
	elif t_1 <= 1e+110:
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)))
	else:
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j))
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(j * 27.0) * k)
	tmp = 0.0
	if (t_1 <= -1e+274)
		tmp = Float64(Float64(j * k) * -27.0);
	elseif (t_1 <= 1e+110)
		tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(a * t) + Float64(i * x))));
	else
		tmp = Float64(j * Float64(Float64(k * -27.0) - Float64(Float64(x * Float64(4.0 * i)) / j)));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = (j * 27.0) * k;
	tmp = 0.0;
	if (t_1 <= -1e+274)
		tmp = (j * k) * -27.0;
	elseif (t_1 <= 1e+110)
		tmp = (b * c) + (-4.0 * ((a * t) + (i * x)));
	else
		tmp = j * ((k * -27.0) - ((x * (4.0 * i)) / j));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+274], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+110], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(N[(k * -27.0), $MachinePrecision] - N[(N[(x * N[(4.0 * i), $MachinePrecision]), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -9.99999999999999921e273

   1. Initial program 70.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if -9.99999999999999921e273 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1e110

   1. Initial program 89.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in j around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if 1e110 < (*.f64 (*.f64 j #s(literal 27 binary64)) k)

   1. Initial program 87.2%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in j around -inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 28: 81.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;t \leq -8.6 \cdot 10^{+123}:\\ \;\;\;\;t \cdot \left(18 \cdot \left(z \cdot \left(x \cdot y\right)\right) + -4 \cdot a\right) - \left(j \cdot 27\right) \cdot k\\ \mathbf{elif}\;t \leq 1.88 \cdot 10^{+24}:\\ \;\;\;\;b \cdot c + \left(j \cdot \left(k \cdot -27\right) + -4 \cdot \left(x \cdot i + t \cdot a\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot x\right) \cdot \left(18 \cdot y\right) + a \cdot -4\right) + b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= t -8.6e+123)
   (- (* t (+ (* 18.0 (* z (* x y))) (* -4.0 a))) (* (* j 27.0) k))
   (if (<= t 1.88e+24)
     (+ (* b c) (+ (* j (* k -27.0)) (* -4.0 (+ (* x i) (* t a)))))
     (+ (* t (+ (* (* z x) (* 18.0 y)) (* a -4.0))) (* b c)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -8.6e+123) {
		tmp = (t * ((18.0 * (z * (x * y))) + (-4.0 * a))) - ((j * 27.0) * k);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (t <= (-8.6d+123)) then
        tmp = (t * ((18.0d0 * (z * (x * y))) + ((-4.0d0) * a))) - ((j * 27.0d0) * k)
    else if (t <= 1.88d+24) then
        tmp = (b * c) + ((j * (k * (-27.0d0))) + ((-4.0d0) * ((x * i) + (t * a))))
    else
        tmp = (t * (((z * x) * (18.0d0 * y)) + (a * (-4.0d0)))) + (b * c)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -8.6e+123) {
		tmp = (t * ((18.0 * (z * (x * y))) + (-4.0 * a))) - ((j * 27.0) * k);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if t <= -8.6e+123:
		tmp = (t * ((18.0 * (z * (x * y))) + (-4.0 * a))) - ((j * 27.0) * k)
	elif t <= 1.88e+24:
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))))
	else:
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (t <= -8.6e+123)
		tmp = Float64(Float64(t * Float64(Float64(18.0 * Float64(z * Float64(x * y))) + Float64(-4.0 * a))) - Float64(Float64(j * 27.0) * k));
	elseif (t <= 1.88e+24)
		tmp = Float64(Float64(b * c) + Float64(Float64(j * Float64(k * -27.0)) + Float64(-4.0 * Float64(Float64(x * i) + Float64(t * a)))));
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * x) * Float64(18.0 * y)) + Float64(a * -4.0))) + Float64(b * c));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (t <= -8.6e+123)
		tmp = (t * ((18.0 * (z * (x * y))) + (-4.0 * a))) - ((j * 27.0) * k);
	elseif (t <= 1.88e+24)
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	else
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[t, -8.6e+123], N[(N[(t * N[(N[(18.0 * N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.88e+24], N[(N[(b * c), $MachinePrecision] + N[(N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(N[(x * i), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(z * x), $MachinePrecision] * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -8.59999999999999972e123

   1. Initial program 82.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.59999999999999972e123 < t < 1.8799999999999999e24

   1. Initial program 88.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 1.8799999999999999e24 < t

   1. Initial program 88.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 29: 81.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;t \leq -2.4 \cdot 10^{+123}:\\ \;\;\;\;t \cdot \left(18 \cdot \left(x \cdot \left(y \cdot z\right)\right) + -4 \cdot a\right) - \left(j \cdot 27\right) \cdot k\\ \mathbf{elif}\;t \leq 1.88 \cdot 10^{+24}:\\ \;\;\;\;b \cdot c + \left(j \cdot \left(k \cdot -27\right) + -4 \cdot \left(x \cdot i + t \cdot a\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot x\right) \cdot \left(18 \cdot y\right) + a \cdot -4\right) + b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= t -2.4e+123)
   (- (* t (+ (* 18.0 (* x (* y z))) (* -4.0 a))) (* (* j 27.0) k))
   (if (<= t 1.88e+24)
     (+ (* b c) (+ (* j (* k -27.0)) (* -4.0 (+ (* x i) (* t a)))))
     (+ (* t (+ (* (* z x) (* 18.0 y)) (* a -4.0))) (* b c)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -2.4e+123) {
		tmp = (t * ((18.0 * (x * (y * z))) + (-4.0 * a))) - ((j * 27.0) * k);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (t <= (-2.4d+123)) then
        tmp = (t * ((18.0d0 * (x * (y * z))) + ((-4.0d0) * a))) - ((j * 27.0d0) * k)
    else if (t <= 1.88d+24) then
        tmp = (b * c) + ((j * (k * (-27.0d0))) + ((-4.0d0) * ((x * i) + (t * a))))
    else
        tmp = (t * (((z * x) * (18.0d0 * y)) + (a * (-4.0d0)))) + (b * c)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -2.4e+123) {
		tmp = (t * ((18.0 * (x * (y * z))) + (-4.0 * a))) - ((j * 27.0) * k);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if t <= -2.4e+123:
		tmp = (t * ((18.0 * (x * (y * z))) + (-4.0 * a))) - ((j * 27.0) * k)
	elif t <= 1.88e+24:
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))))
	else:
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (t <= -2.4e+123)
		tmp = Float64(Float64(t * Float64(Float64(18.0 * Float64(x * Float64(y * z))) + Float64(-4.0 * a))) - Float64(Float64(j * 27.0) * k));
	elseif (t <= 1.88e+24)
		tmp = Float64(Float64(b * c) + Float64(Float64(j * Float64(k * -27.0)) + Float64(-4.0 * Float64(Float64(x * i) + Float64(t * a)))));
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * x) * Float64(18.0 * y)) + Float64(a * -4.0))) + Float64(b * c));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (t <= -2.4e+123)
		tmp = (t * ((18.0 * (x * (y * z))) + (-4.0 * a))) - ((j * 27.0) * k);
	elseif (t <= 1.88e+24)
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	else
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[t, -2.4e+123], N[(N[(t * N[(N[(18.0 * N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.88e+24], N[(N[(b * c), $MachinePrecision] + N[(N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(N[(x * i), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(z * x), $MachinePrecision] * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -2.39999999999999989e123

   1. Initial program 82.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.39999999999999989e123 < t < 1.8799999999999999e24

   1. Initial program 88.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 1.8799999999999999e24 < t

   1. Initial program 88.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 30: 80.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;t \leq -3.5 \cdot 10^{+140}:\\ \;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + b \cdot c\\ \mathbf{elif}\;t \leq 1.88 \cdot 10^{+24}:\\ \;\;\;\;b \cdot c + \left(j \cdot \left(k \cdot -27\right) + -4 \cdot \left(x \cdot i + t \cdot a\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(\left(z \cdot x\right) \cdot \left(18 \cdot y\right) + a \cdot -4\right) + b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= t -3.5e+140)
   (+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) (* b c))
   (if (<= t 1.88e+24)
     (+ (* b c) (+ (* j (* k -27.0)) (* -4.0 (+ (* x i) (* t a)))))
     (+ (* t (+ (* (* z x) (* 18.0 y)) (* a -4.0))) (* b c)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -3.5e+140) {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (t <= (-3.5d+140)) then
        tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + (b * c)
    else if (t <= 1.88d+24) then
        tmp = (b * c) + ((j * (k * (-27.0d0))) + ((-4.0d0) * ((x * i) + (t * a))))
    else
        tmp = (t * (((z * x) * (18.0d0 * y)) + (a * (-4.0d0)))) + (b * c)
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (t <= -3.5e+140) {
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	} else if (t <= 1.88e+24) {
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	} else {
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if t <= -3.5e+140:
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c)
	elif t <= 1.88e+24:
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))))
	else:
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c)
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (t <= -3.5e+140)
		tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(b * c));
	elseif (t <= 1.88e+24)
		tmp = Float64(Float64(b * c) + Float64(Float64(j * Float64(k * -27.0)) + Float64(-4.0 * Float64(Float64(x * i) + Float64(t * a)))));
	else
		tmp = Float64(Float64(t * Float64(Float64(Float64(z * x) * Float64(18.0 * y)) + Float64(a * -4.0))) + Float64(b * c));
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (t <= -3.5e+140)
		tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (b * c);
	elseif (t <= 1.88e+24)
		tmp = (b * c) + ((j * (k * -27.0)) + (-4.0 * ((x * i) + (t * a))));
	else
		tmp = (t * (((z * x) * (18.0 * y)) + (a * -4.0))) + (b * c);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[t, -3.5e+140], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.88e+24], N[(N[(b * c), $MachinePrecision] + N[(N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(N[(x * i), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(z * x), $MachinePrecision] * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.49999999999999989e140

   1. Initial program 80.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -3.49999999999999989e140 < t < 1.8799999999999999e24

   1. Initial program 88.7%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 1.8799999999999999e24 < t

   1. Initial program 88.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

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

Alternative 31: 37.3% accurate, 1.2× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;b \cdot c \leq -2.2 \cdot 10^{+186}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq -6.4 \cdot 10^{+47}:\\ \;\;\;\;t \cdot \left(-4 \cdot a\right)\\ \mathbf{elif}\;b \cdot c \leq 9.8 \cdot 10^{+47}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= (* b c) -2.2e+186)
   (* b c)
   (if (<= (* b c) -6.4e+47)
     (* t (* -4.0 a))
     (if (<= (* b c) 9.8e+47) (* j (* k -27.0)) (* b c)))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -2.2e+186) {
		tmp = b * c;
	} else if ((b * c) <= -6.4e+47) {
		tmp = t * (-4.0 * a);
	} else if ((b * c) <= 9.8e+47) {
		tmp = j * (k * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((b * c) <= (-2.2d+186)) then
        tmp = b * c
    else if ((b * c) <= (-6.4d+47)) then
        tmp = t * ((-4.0d0) * a)
    else if ((b * c) <= 9.8d+47) then
        tmp = j * (k * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -2.2e+186) {
		tmp = b * c;
	} else if ((b * c) <= -6.4e+47) {
		tmp = t * (-4.0 * a);
	} else if ((b * c) <= 9.8e+47) {
		tmp = j * (k * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if (b * c) <= -2.2e+186:
		tmp = b * c
	elif (b * c) <= -6.4e+47:
		tmp = t * (-4.0 * a)
	elif (b * c) <= 9.8e+47:
		tmp = j * (k * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (Float64(b * c) <= -2.2e+186)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= -6.4e+47)
		tmp = Float64(t * Float64(-4.0 * a));
	elseif (Float64(b * c) <= 9.8e+47)
		tmp = Float64(j * Float64(k * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if ((b * c) <= -2.2e+186)
		tmp = b * c;
	elseif ((b * c) <= -6.4e+47)
		tmp = t * (-4.0 * a);
	elseif ((b * c) <= 9.8e+47)
		tmp = j * (k * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[N[(b * c), $MachinePrecision], -2.2e+186], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -6.4e+47], N[(t * N[(-4.0 * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 9.8e+47], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 b c) < -2.1999999999999998e186 or 9.8000000000000006e47 < (*.f64 b c)

   1. Initial program 84.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.1999999999999998e186 < (*.f64 b c) < -6.4e47

   1. Initial program 95.1%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -6.4e47 < (*.f64 b c) < 9.8000000000000006e47

   1. Initial program 87.6%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 32: 37.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;b \cdot c \leq -4.4 \cdot 10^{+151}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;b \cdot c \leq 1.12 \cdot 10^{+48}:\\ \;\;\;\;j \cdot \left(k \cdot -27\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= (* b c) -4.4e+151)
   (* b c)
   (if (<= (* b c) 1.12e+48) (* j (* k -27.0)) (* b c))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -4.4e+151) {
		tmp = b * c;
	} else if ((b * c) <= 1.12e+48) {
		tmp = j * (k * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((b * c) <= (-4.4d+151)) then
        tmp = b * c
    else if ((b * c) <= 1.12d+48) then
        tmp = j * (k * (-27.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if ((b * c) <= -4.4e+151) {
		tmp = b * c;
	} else if ((b * c) <= 1.12e+48) {
		tmp = j * (k * -27.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if (b * c) <= -4.4e+151:
		tmp = b * c
	elif (b * c) <= 1.12e+48:
		tmp = j * (k * -27.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (Float64(b * c) <= -4.4e+151)
		tmp = Float64(b * c);
	elseif (Float64(b * c) <= 1.12e+48)
		tmp = Float64(j * Float64(k * -27.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if ((b * c) <= -4.4e+151)
		tmp = b * c;
	elseif ((b * c) <= 1.12e+48)
		tmp = j * (k * -27.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[N[(b * c), $MachinePrecision], -4.4e+151], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.12e+48], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 b c) < -4.40000000000000013e151 or 1.11999999999999995e48 < (*.f64 b c)

   1. Initial program 84.9%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -4.40000000000000013e151 < (*.f64 b c) < 1.11999999999999995e48

   1. Initial program 88.5%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 33: 32.0% accurate, 2.1× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ \begin{array}{l} \mathbf{if}\;c \leq -9.5 \cdot 10^{-47}:\\ \;\;\;\;b \cdot c\\ \mathbf{elif}\;c \leq 5.6 \cdot 10^{+45}:\\ \;\;\;\;i \cdot \left(x \cdot -4\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot c\\ \end{array} \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
 :precision binary64
 (if (<= c -9.5e-47) (* b c) (if (<= c 5.6e+45) (* i (* x -4.0)) (* b c))))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (c <= -9.5e-47) {
		tmp = b * c;
	} else if (c <= 5.6e+45) {
		tmp = i * (x * -4.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: tmp
    if (c <= (-9.5d-47)) then
        tmp = b * c
    else if (c <= 5.6d+45) then
        tmp = i * (x * (-4.0d0))
    else
        tmp = b * c
    end if
    code = tmp
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double tmp;
	if (c <= -9.5e-47) {
		tmp = b * c;
	} else if (c <= 5.6e+45) {
		tmp = i * (x * -4.0);
	} else {
		tmp = b * c;
	}
	return tmp;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	tmp = 0
	if c <= -9.5e-47:
		tmp = b * c
	elif c <= 5.6e+45:
		tmp = i * (x * -4.0)
	else:
		tmp = b * c
	return tmp

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0
	if (c <= -9.5e-47)
		tmp = Float64(b * c);
	elseif (c <= 5.6e+45)
		tmp = Float64(i * Float64(x * -4.0));
	else
		tmp = Float64(b * c);
	end
	return tmp
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	tmp = 0.0;
	if (c <= -9.5e-47)
		tmp = b * c;
	elseif (c <= 5.6e+45)
		tmp = i * (x * -4.0);
	else
		tmp = b * c;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[c, -9.5e-47], N[(b * c), $MachinePrecision], If[LessEqual[c, 5.6e+45], N[(i * N[(x * -4.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if c < -9.4999999999999991e-47 or 5.5999999999999999e45 < c

   1. Initial program 87.0%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -9.4999999999999991e-47 < c < 5.5999999999999999e45

   1. Initial program 87.3%

      \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 34: 23.9% accurate, 10.3× speedup

Math

\[\begin{array}{l} [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\\\ [x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\ \\ b \cdot c \end{array} \]

FPCore

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k) :precision binary64 (* b c))

C

assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return b * c;
}

Fortran

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    code = b * c
end function

Java

assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	return b * c;
}

Python

[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k])
def code(x, y, z, t, a, b, c, i, j, k):
	return b * c

Julia

x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k])
function code(x, y, z, t, a, b, c, i, j, k)
	return Float64(b * c)
end

MATLAB

x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp = code(x, y, z, t, a, b, c, i, j, k)
	tmp = b * c;
end

Wolfram

NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(b * c), $MachinePrecision]

Derivation

1. Initial program 87.2%

   \[\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in b around inf 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]
8. Add Preprocessing

Developer target: 89.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(a \cdot t + i \cdot x\right) \cdot 4\\ t_2 := \left(\left(18 \cdot t\right) \cdot \left(\left(x \cdot y\right) \cdot z\right) - t\_1\right) - \left(\left(k \cdot j\right) \cdot 27 - c \cdot b\right)\\ \mathbf{if}\;t < -1.6210815397541398 \cdot 10^{-69}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t < 165.68027943805222:\\ \;\;\;\;\left(\left(18 \cdot y\right) \cdot \left(x \cdot \left(z \cdot t\right)\right) - t\_1\right) + \left(c \cdot b - 27 \cdot \left(k \cdot j\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j k)
 :precision binary64
 (let* ((t_1 (* (+ (* a t) (* i x)) 4.0))
        (t_2
         (-
          (- (* (* 18.0 t) (* (* x y) z)) t_1)
          (- (* (* k j) 27.0) (* c b)))))
   (if (< t -1.6210815397541398e-69)
     t_2
     (if (< t 165.68027943805222)
       (+ (- (* (* 18.0 y) (* x (* z t))) t_1) (- (* c b) (* 27.0 (* k j))))
       t_2))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * 4.0;
	double t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b));
	double tmp;
	if (t < -1.6210815397541398e-69) {
		tmp = t_2;
	} else if (t < 165.68027943805222) {
		tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j, k)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8), intent (in) :: k
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((a * t) + (i * x)) * 4.0d0
    t_2 = (((18.0d0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0d0) - (c * b))
    if (t < (-1.6210815397541398d-69)) then
        tmp = t_2
    else if (t < 165.68027943805222d0) then
        tmp = (((18.0d0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0d0 * (k * j)))
    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 c, double i, double j, double k) {
	double t_1 = ((a * t) + (i * x)) * 4.0;
	double t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b));
	double tmp;
	if (t < -1.6210815397541398e-69) {
		tmp = t_2;
	} else if (t < 165.68027943805222) {
		tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j, k):
	t_1 = ((a * t) + (i * x)) * 4.0
	t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b))
	tmp = 0
	if t < -1.6210815397541398e-69:
		tmp = t_2
	elif t < 165.68027943805222:
		tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j, k)
	t_1 = Float64(Float64(Float64(a * t) + Float64(i * x)) * 4.0)
	t_2 = Float64(Float64(Float64(Float64(18.0 * t) * Float64(Float64(x * y) * z)) - t_1) - Float64(Float64(Float64(k * j) * 27.0) - Float64(c * b)))
	tmp = 0.0
	if (t < -1.6210815397541398e-69)
		tmp = t_2;
	elseif (t < 165.68027943805222)
		tmp = Float64(Float64(Float64(Float64(18.0 * y) * Float64(x * Float64(z * t))) - t_1) + Float64(Float64(c * b) - Float64(27.0 * Float64(k * j))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
	t_1 = ((a * t) + (i * x)) * 4.0;
	t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b));
	tmp = 0.0;
	if (t < -1.6210815397541398e-69)
		tmp = t_2;
	elseif (t < 165.68027943805222)
		tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * 4.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(18.0 * t), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision] - N[(N[(N[(k * j), $MachinePrecision] * 27.0), $MachinePrecision] - N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -1.6210815397541398e-69], t$95$2, If[Less[t, 165.68027943805222], N[(N[(N[(N[(18.0 * y), $MachinePrecision] * N[(x * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision] + N[(N[(c * b), $MachinePrecision] - N[(27.0 * N[(k * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z t a b c i j k)
  :name "Diagrams.Solve.Polynomial:cubForm  from diagrams-solve-0.1, E"
  :precision binary64

  :alt
  (if (< t -1.6210815397541398e-69) (- (- (* (* 18.0 t) (* (* x y) z)) (* (+ (* a t) (* i x)) 4.0)) (- (* (* k j) 27.0) (* c b))) (if (< t 165.68027943805222) (+ (- (* (* 18.0 y) (* x (* z t))) (* (+ (* a t) (* i x)) 4.0)) (- (* c b) (* 27.0 (* k j)))) (- (- (* (* 18.0 t) (* (* x y) z)) (* (+ (* a t) (* i x)) 4.0)) (- (* (* k j) 27.0) (* c b)))))

  (- (- (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c)) (* (* x 4.0) i)) (* (* j 27.0) k)))